C#总结

时间：2015-03-05 14:54:22 阅读：270 评论：0 收藏：0 [点我收藏+]

标签：c#

ref http://www.w3cschool.cc/csharp/csharp-generic.html

https://msdn.microsoft.com/zh-cn/library/aa288460(v=vs.71).aspx

http://blog.csdn.net/hawksoft/article/details/7534332

using
数组：
- int [] array = new int[10]
- int[,] tbl = new int[1,2]
- int[][] tbl = new int[1][]
- int[,] numbers = { {1, 2}, {3, 4}, {5, 6} }; numbers[1,1]
- int[][] numbers = { new int[] {2,3,4}, new int[] {5,6,7,8,9} }; numbers[0][2]
- System.Array 类提供许多有用的其他方法/属性，如用于排序、搜索和复制数组的方法。
- foreach (int i in numbers)
属性：
- public class A {}
- A中：public string Name{ get{return xx} set{xx = value}}
虚函数：
- A中：public virtual void f()
- A的子类B：public class B : A {}
- B中：public override void f() 重写
- public new void f() 覆盖
- A a = new B()
interal: 只能在程序集中访问。你写了一个记录日志的DLL，任何项目只要引用此DLL就能实现记录日志的功能，这个DLL文件的程序就是一个程序集。
自定义一个可以foreach的集合类：https://msdn.microsoft.com/zh-cn/library/aa288462(v=vs.71).aspx
结构：
- 结构可能看似类，但存在一些重要差异，应引起注意。首先，类为引用类型，而结构为值类型。使用结构，您可以创建行为类似内置类型的对象，同时享有它们的好处。
- 在类上调用“新建”(New) 运算符时，它将在堆上进行分配。但是，当实例化结构时，将在堆栈上创建结构。这样将产生性能增益。而且，您不会像对待类那样处理对结构实例的引用。您将直接对结构实例进行操作。鉴于此原因，向方法传递结构时，结构将通过值传递，而不是作为引用传递。
- 当向方法传递结构时，将传递该结构的副本，而传递类实例时，将传递一个引用。
- 结构可以声明构造函数，但它们必须带参数。声明结构的默认（无参数）构造函数是错误的。结构成员不能有初始值设定项。总是提供默认构造函数以将结构成员初始化为它们的默认值。
- 如果不使用“新建”(new)，那么在初始化所有字段之前，字段将保持未赋值状态，且对象不可用。
- 对于结构，不像类那样存在继承。一个结构不能从另一个结构或类继承，而且不能作为一个类的基。但是，结构从基类对象继承。结构可实现接口，而且实现方式与类实现接口的方式完全相同。
- 结构控制：[FieldOffset(0)]

索引器：类似虚拟数组

- 对象可以用[]访问
- public int this[long index] {get{ ...} set{ ...} }

- 自动转换：

- 可以将转换声明为 implicit（需要时自动转换）或 explicit（需要调用转换）。所有转换都必须为 static，并且必须采用在其上定义转换的类型，或返回该类型。
- A中：static public implicit operator A(int value)
- static public explicit operator int(A a)

运算符重载：

- public static Complex operator +(Complex c1, Complex c2)
- public override bool Equals(object o)
- public override int GetHashCode()
- public override string ToString()

委托：类似函数指针

- 委托声明定义一种类型，它用一组特定的参数以及返回类型封装方法。对于静态方法，委托对象封装要调用的方法。对于实例方法，委托对象同时封装一个实例和该实例上的一个方法。
- public delegate void ProcessBookDelegate(Book book);//声明一个委托
- BookDB中，有Book列表：public void process(ProcessBookDelegate processBook){ processBook(b) } //调用委托，可以通过使用 BeginInvoke 和 EndInvoke 方法同步或异步调用委托。
- Processor中，有一系列的inter方法：void f1(Book b) ...
- 调用：bookDB.process(new ProcessBookDelegate (Processor.f1)) //实例化委托
- 委托的+和-: a = new ProcessBookDelegate (Processor.f1)
- b = new ProcessBookDelegate (Processor.f2)
- c = a + b =>调用c(book)时，同时调用f1和f2
- c = a - b

事件：利用委托
- 有两个对象：Listener和Subject
- Subject：持有event，当发生变化时将主动调用event
- Listener：持有Subject的ref，并且负责向Subject中的event对象attach和dettach自己的方法
- --------------------观察者模式Observer----------------------
- Subject接口中有三类主要方法，分别注册观察者（attatch）、删除观察者(detach)和通知观察者(notify)，
- ConcreteSubjects实现类存储具体的状态并持有多个ConceteObserver对象（可以组织成ArrayList），当状态改变时就调用notify方法，notify方法中遍历所有的ConcreteObserver，调用其updata方法。
- Subject声明事件：public delegate void EventHandler(object sender, EventArgs e); // 声明该事件的委托类型，委托类型定义传递给处理该事件的方法的一组参数
- public event EventHandler Changed; //声明事件本身，声明事件的方法与声明委托类型的字段类似，只是关键字 event 在事件声明前面，在修饰符后面。事件通常被声明为公共事件，但允许任意可访问修饰符
- Subject 调用事件：类声明了事件以后，可以就像处理所指示的委托类型的字段那样处理该事件。如果没有任何客户将委托与该事件挂钩，该字段将为空；否则该字段引用应在调用该事件时调用的委托。因此，调用事件时通常先检查是否为空，然后再调用事件。
- if (Changed != null) Changed(this, e); //调用方法，一般名为onChanged
- Listener与事件挂钩：在该字段上撰写新的委托、从字段（可能是复合字段）移除委托。
- Subject.Changed += new EventHandler(Listener.f1)
- Subject.Changed -= new EventHandler(Lintener.f1)
- 总的来说，和委托很像。只是添加了一个event Changed，可以集中管理所有EventHandler
- event可看做一个委托的实例，当没有函数时，为null，否则就是绑定的函数
- 事件和继承：由于事件只能从声明它们的类中调用，因此派生类不能直接调用在基类内声明的事件。虽然这有时符合需要，但通常使派生类能够自由调用事件更合适。这通常通过为事件创建受保护的调用方法来实现。通过调用该调用方法，派生类便可以调用此事件。为获得更大的灵活性，调用方法通常声明为虚拟的，这允许派生类重写调用方法。这使得派生类可以截获基类正在调用的事件，有可能对这些事件执行它自己的处理。
- 接口中的事件：事件和字段之间的另一个差异是，事件可放在接口中，而字段不能。当实现接口时，实现类必须在实现接口的类中提供相应的事件。

特性Attribute：
- 用于在运行时传递程序中各种元素（比如类、方法、结构、枚举、组件等）的行为信息的声明性标签。您可以通过使用特性向程序添加声明性信息。一个声明性标签是通过放置在它所应用的元素前面的方括号（[ ]）来描述的。
- 预定义特性：
- AttributeUsage：描述了如何使用一个自定义特性类
- Conditional：这个预定义特性标记了一个条件方法，其执行依赖于它顶的预处理标识符。它会引起方法调用的条件编译，取决于指定的值，比如 Debug 或 Trace。例如，当调试代码时显示变量的值。
- Obsolete：这个预定义特性标记了不应被使用的程序实体。
- 自定义特性：.Net 框架允许创建自定义特性，用于存储声明性的信息，且可在运行时被检索。
- 创建并使用自定义特性包含四个步骤：
- 声明自定义特性：一个新的自定义特性应派生自 System.Attribute 类
- - // 一个自定义特性 BugFix 被赋给类及其成员
  - [AttributeUsage(AttributeTargets.Class |
  - AttributeTargets.Constructor |
  - AttributeTargets.Field |
  - AttributeTargets.Method |
  - AttributeTargets.Property,
  - AllowMultiple = true)]
  - public class DeBugInfo : System.Attribute
- 构建自定义特性：和构建类一样，必须有构造函数，传入必须(positional)的参数
- 在目标程序元素上应用自定义特性：
- - [DeBugInfo(45, "Zara Ali", "12/8/2012", Message = "Return type mismatch")]
- 通过反射访问特性
- - System.Reflection.MemberInfo info = typeof(MyClass);
  - info.GetCustomAttributes

反射：

- 它允许在运行时查看属性（attribute）信息。
- 它允许审查集合中的各种类型，以及实例化这些类型。
- 它允许延迟绑定的方法和属性（property）。
- 它允许在运行时创建新类型，然后使用这些类型执行一些任务。

- Type type = Type.GetType("System.Int32", false, true);
- object o = System.Activator.CreateInstance(type);
- Debug.Assert(o.GetType() == typeof(int));

匿名方法：通过delegate实现

- delegate void MyDelegate(int n);
- MyDelegate nc = delegate(int x) {...}
- 调用：nc(10)

lambda表达式：Lambda 表达式的作用是为了使用更简单的方式来编写匿名方法，彻底简化委托的使用方式。

- MyDelegate nc =(int x)=> {...}
- 当中 “ => ” 是 Lambda 表达式的操作符，在左边用作定义一个参数列表，右边可以操作这些参数。

动态对象：利用DynamicObject

- 定义一个委托,参数个数可变,参数都是object类型:这里的委托有个dynamic参数,代表调用这个委托的动态对象本身.
- - public delegate object MyDelegate(dynamic Sender, params object[] PMs);
- 定义一个委托对象，以绑定匿名方法。因为dynamic对象不能直接用匿名方法,这里用对象去承载
- - public class DelegateObj
  - {
  - private MyDelegate _delegate;
  - public MyDelegate CallMethod//调用方法
  - {
  - get { return _delegate; }
  - }
  - private DelegateObj(MyDelegate d)//构造函数
  - {
  - _delegate = d;
  - }
  - public static DelegateObj Function(MyDelegate D)// 构造委托对象
  - {
  - return new DelegateObj(D);
  - }
  - }

- 定义一个动态对象：

- public class DynObj : DynamicObject
- {
- private Dictionary<string, object> _values; //保存对象动态定义的属性值
- public DynObj()
- {
- _values = new Dictionary<string, object>();
- }
- public object GetPropertyValue(string propertyName) //获取属性值
- {
- if (_values.ContainsKey(propertyName) == true)
- {
- return _values[propertyName];
- }
- return null;
- }
- public void SetPropertyValue(string propertyName,object value) // 设置属性值
- {
- if (_values.ContainsKey(propertyName) == true)
- {
- _values[propertyName] = value;
- }
- else
- {
- _values.Add(propertyName, value);
- }
- }
- public override bool TryGetMember(GetMemberBinder binder, out object result)// 实现动态对象属性成员访问的方法，得到返回指定属性的值
- {
- result = GetPropertyValue(binder.Name);
- return result == null ? false : true;
- }
- public override bool TrySetMember(SetMemberBinder binder, object value)// 实现动态对象属性值设置的方法。
- {
- SetPropertyValue(binder.Name, value);
- return true;
- }
- public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)// 动态对象动态方法调用时执行的实际代码
- {
- var theDelegateObj = GetPropertyValue(binder.Name) as DelegateObj;
- if (theDelegateObj == null || theDelegateObj.CallMethod == null)
- {
- result = null;
- return false;
- }
- result = theDelegateObj.CallMethod(this,args);
- return true;
- }
- public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
- {
- return base.TryInvoke(binder, args, out result);
- }
- }

- 使用方法：

- dynamic theObj = new DynObj();
- theObj.aaa = "this is a test";//动态属性
- theObj.show = DelegateObj.Function((s, pms) =>
- { // 动态方法 }
- );//这里使用lambda表达式，实际上也可以是由delegate定义的一个匿名函数
- theObj.show("hello");

Linq
- 使用类似sql语句的方式查询xml以及集合中的数据
- IEnumerable<int> scoreQuery =
- from score in scores
- where score > 80
- select score;

System.Generic

- System.Collections.Generic.Dictionary<>; //键/值对集合
- System.Collections.Generic.KeyValuePair<>; //键/值对结构, 作为 Dictionary<> 的一个元素存在
- System.Collections.Generic.SortedDictionary<>; //相当于 Key 能自动排序 Dictionary<>
- System.Collections.Generic.SortedList<>; //和 SortedDictionary<> 功能相似, 但内部算法不同, 其 Keys、Values 可通过索引访问
- System.Collections.Generic.HashSet<>; //无序、无重复的元素集合
- System.Collections.Generic.SortedSet<>; //相当于能自动排序的 HashSet<>
- System.Collections.Generic.List<>; //相当于泛型的 ArrayList, 元素可重复、可排序、可插入、可索引访问
- System.Collections.Generic.Queue<>; //队列, 先进先出
- System.Collections.Generic.Stack<>; //堆栈, 后进先出
- System.Collections.Generic.LinkedList<>; //双向链表
- System.Collections.Generic.LinkedListNode<>; //LinkedList<> 的节点
- System.Collections.Generic.SynchronizedCollection<>; //线程安全的集合
- System.Collections.Generic.SynchronizedReadOnlyCollection<>; //线程安全的只读集合
- System.Collections.Generic.SynchronizedKeyedCollection<>; // 线程安全的键/ 值集合
- 字符串方法：http://www.w3cschool.cc/csharp/csharp-string.html

C#总结

标签：c#

原文地址：http://blog.csdn.net/peerlessbloom/article/details/44081161

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行