您当前位置：首页 > php开源 > php教程 > C#总结

C#总结

来源：程序员人生发布时间：2015-03-27 08:02:36 阅读次数：3491次

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: 只能在程序集中访问。你写了1个记录日志的DLL，任何项目只要援用此DLL就可以实现记录日志的功能，这个DLL文件的程序就是1个程序集。
自定义1个可以foreach的集合类：https://msdn.microsoft.com/zh-cn/library/aa288462(v=vs.71).aspx
结构：
- 结构可能看似类，但存在1些重要差异，应引发注意。首先，类为援用类型，而结构为值类型。使用结构，您可以创建行动类似内置类型的对象，同时享有它们的好处。
- 在类上调用“新建”(New) 运算符时，它将在堆上进行分配。但是，当实例化结构时，将在堆栈上创建结构。这样将产生性能增益。而且，您不会像对待类那样处理对结构实例的援用。您将直接对结构实例进行操作。鉴于此缘由，向方法传递结构时，结构将通过值传递，而不是作为援用传递。
- 当向方法传递结构时，将传递该结构的副本，而传递类实例时，将传递1个援用。
- 结构可以声明构造函数，但它们必须带参数。声明结构的默许（无参数）构造函数是毛病的。结构成员不能有初始值设定项。总是提供默许构造函数以将结构成员初始化为它们的默许值。
- 如果不使用“新建”(new)，那末在初始化所有字段之前，字段将保持未赋值状态，且对象不可用。
- 对结构，不像类那样存在继承。1个结构不能从另外一个结构或类继承，而且不能作为1个类的基。但是，结构从基类对象继承。结构可实现接口，而且实现方式与类实现接口的方式完全相同。
- 结构控制：[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()

拜托：类似函数指针

- 拜托声明定义1种类型，它用1组特定的参数和返回类型封装方法。对静态方法，拜托对象封装要调用的方法。对实例方法，拜托对象同时封装1个实例和该实例上的1个方法。
- public delegate void ProcessBookDelegate(Book book);//声明1个拜托
- BookDB中，有Book列表：public void process(ProcessBookDelegate processBook){ processBook(b) } //调用拜托，可以通过使用 BeginInvoke 和 EndInvoke 方法同步或异步调用拜托。
- Processor中，有1系列的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接口中有3类主要方法，分别注册视察者（attatch）、删除视察者(detach)和通知视察者(notify)，
- ConcreteSubjects实现类存储具体的状态并持有多个ConceteObserver对象（可以组织成ArrayList），当状态改变时就调用notify方法，notify方法中遍历所有的ConcreteObserver，调用其updata方法。
- Subject声明事件：public delegate void EventHandler(object sender, EventArgs e); // 声明该事件的拜托类型，拜托类型定义传递给处理该事件的方法的1组参数
- public event EventHandler Changed; //声明事件本身，声明事件的方法与声明拜托类型的字段类似，只是关键字 event 在事件声明前面，在修饰符后面。事件通常被声明为公共事件，但允许任意可访问修饰符
- Subject 调用事件：类声明了事件以后，可以就像处理所唆使的拜托类型的字段那样处理该事件。如果没有任何客户将拜托与该事件挂钩，该字段将为空；否则该字段援用应在调用该事件时调用的拜托。因此，调用事件时通常先检查是不是为空，然后再调用事件。
- if (Changed != null) Changed(this, e); //调用方法，1般名为onChanged
- Listener与事件挂钩：在该字段上撰写新的拜托、从字段（多是复合字段）移除拜托。
- Subject.Changed += new EventHandler(Listener.f1)
- Subject.Changed -= new EventHandler(Lintener.f1)
- 总的来讲，和拜托很像。只是添加了1个event Changed，可以集中管理所有EventHandler
- event可看作1个拜托的实例，当没有函数时，为null，否则就是绑定的函数
- 事件和继承：由于事件只能从声明它们的类中调用，因此派生类不能直接调用在基类内声明的事件。虽然这有时符合需要，但通常使派生类能够自由调用事件更适合。这通常通过为事件创建受保护的调用方法来实现。通过调用该调用方法，派生类即可以调用此事件。为取得更大的灵活性，调用方法通常声明为虚拟的，这允许派生类重写调用方法。这使得派生类可以截获基类正在调用的事件，有可能对这些事件履行它自己的处理。
- 接口中的事件：事件和字段之间的另外一个差异是，事件可放在接口中，而字段不能。当实现接口时，实现类必须在实现接口的类中提供相应的事件。

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

反射：

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

- 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 表达式的操作符，在左侧用作定义1个参数列表，右侧可以操作这些参数。

动态对象：利用DynamicObject

- 定义1个拜托,参数个数可变,参数都是object类型:这里的拜托有个dynamic参数,代表调用这个拜托的动态对象本身.
- - public delegate object MyDelegate(dynamic Sender, params object[] PMs);
- 定义1个拜托对象，以绑定匿名方法。由于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);
  - }
  - }

- 定义1个动态对象：

- 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定义的1个匿名函数
- 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<> 的1个元素存在
- 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

生活不易，码农辛苦
如果您觉得本网站对您的学习有所帮助,可以手机扫描二维码进行捐赠
程序员人生

------分隔线----------------------------

上一篇 恭喜自己荣升CSDN认证专家博客

下一篇 linux shell 统计项目目录存储信息

分享到:

------分隔线----------------------------

为码而活

积分：4237

15粉丝

7关注

栏目热点