array类
Array类：提供创建、操作、搜索和排序数组的方法，因而在公共语言运行库中用作所有数组的基类。
- 只有系统和编译器能够从 Array 类显式派生，用户不能派生与此类
- 实现了 System.Collections.Generic .IList <T >、 System.Collections.Generic .ICollection <T > 和 System.Collections.Generic.IEnumerable <T > 泛型接口
1.数组的GetType方法;
int[] h=new int[10]; h.GetType()====== System.Int32[]
2. Array.IsArray 属性
typeof(Array).IsArray FALSE
typeof(h.GetType().IsArray） true
3.数组的复制 同类型或者不同类型的标准数组之间copy自动转换（拆箱，装箱）
1）Array .ConstrainedCopy 复制没成功，则目标数组不变
public static void ConstrainedCopy(
Array sourceArray,
int sourceIndex,
Array destinationArray,
int destinationIndex,
int length
)
2）Array .Copy 方法
将一个 Array 的一部分元素复制到另一个 Array 中，并根据需要执行类型强制转换和装箱。
Copy(Array, Array, Int32/Int64) 将元数组从第一个索引开始，指定长度复制到目标数组
Copy(Array, Int32/Int64, Array, Int32/Int64, Int32/Int64) 从指定的源索引开始，指定长度，复制到目标数组中以目标索引为起始位置的地方。
3）Array派生类的CopyTo
public void CopyTo(
Array array,
int index
)
int[] myArray={1,2,3,4,5,6,7,8,9,10};
myArray.CopyTo(deArray, 0); //1,2,3,4,5,..,9,10 将源数组的所有元素复制到目标数组指定起始的位置。目标数组要有足够大的空间。
4.数组的清除 Array.Clear
静态方法 Clear ,Array.Clear()，并不是真正的删除值。
引用类型变为null，bool类型变为false，其余为0
5.查找值 Array.Exists,TrueForAll,Find,FindLast,FindAll
Predicate<T>委托 – _
public static bool Exists<T>(
T[] array,
Predicate<T> match
)
Predicate <T > 是对方法的委托，如果传递给它的对象与委托中定义的条件匹配，则该方法返回 true。 array 的元素被逐个传递给 Predicate <T >，找到一个匹配项时处理就会停止。
表示定义一组条件并确定指定对象是否符合这些条件的方法。
public delegate bool Predicate<T>(
T obj
)
说明：在 C# 和 Visual Basic 中，不必显式创建 Predicate<string> 委托（在 Visual Basic 中为 Predicate(Of String)）。这些语言会通过上下文推知正确的委托，并自动创建委托。
Array.TrueForAll,Exists
Find,FindLast,FindAll
6.调整数组大小
public static void Resize<T>(
ref T[] array,
int newSize
)
新长度大于旧长度,则其余都为数组类型的默认值
新长度小，则将新数组复制满，其余元素忽略
相等，则不做任何操作。
7. 数组排序sort 默认提供的是不稳定排序（相同大小的元素位置可能会改变）
1)基元类型数组或者集合的默认排序
先来说说NET 托管的基类型，有byte,sbyte,int,uint,short,ushort,long,ulong,float,double,char,bool,object,string,decimal。如果数组是这些类型的，那么可以直接使用 数组.sort()方法，因为基元类型默认都实现了Icomparable<T>接口中的CompareTo(T t1,T t2)方法
例: 整形数组a包括了 9,8,7,6,5,….,0的10个值，使用Array.sort(a) 排序后就变成了0,1,2,….9，可见默认的排序方法是从小到达排序的
static void Main(string[] args){Array a = Array.CreateInstance(typeof(int), 10);for(int i=9;i>=0;i--)a.SetValue(9-i, i);foreach (int i in a){Console.WriteLine(i);}Array.Sort(a);Console.WriteLine("排序后的数组为");foreach (int i in a){Console.WriteLine(i);}Console.ReadLine();}
2)不想使用默认的排序规则，使用自定义的排序规则
查看msdn帮助中Array.sort方法发现有2种基本的自定义规则。一个是参数为Icomparer<T>，另一个是Comparison<(Of <(T>)>) 一个委托方法 public delegate int xx(T x,Ty)
- 实现Icomparer<T>接口中的 compare方法
例：将一个整形的数组 按照从大到小的顺序排列。还是针对上面的例子中数组a，因为上面的数组a经过默认排序后变成从小到大，现自定义规则让其变成从大到小排序.
public interface IComparer<in T>
{
// 摘要:
// 比较两个对象并返回一个值，指示一个对象是小于、等于还是大于另一个对象。
//
// 参数:
// x:
// 要比较的第一个对象。
//
// y:
// 要比较的第二个对象。
//
// 返回结果:
// 一个带符号整数，它指示 x 与 y 的相对值，如下表所示。值含义小于零x 小于 y。零x 等于 y。大于零x 大于 y。
int Compare(T x, T y);
}
自定义规则的代码：
public class ReverseComparer : IComparer<int>
{
public int Compare(int x, int y)
{
return y.CompareTo(x); // y小于x，返回负数
}
}
调用排序规则
ReverseComparer c=new ReverseComparer();
Array.Sort(a, c);
Console.WriteLine("排序后的数组为"); ///打印出9，8，7，6，5
Comparison<(Of <(T>)>) 就是一个委托方法 public delegate int xx(T x,Ty)
使用委托参数，实现自定义排序规则
public int customerCompare(int x, int y){if (x > y){return 1;}else if (x == y){return 0;}else{return -1;}}
调用:
public delegate int Comparison<T>( T x, T y )
public class ReverseComparer //这没实现Icomparer接口compare方法
{
//从小到大排列
public int customerCompare(int x, int y)
{
if (x > y)
{
return 1;
}
else if (x == y)
{
return 0;
}
else
{
return -1;
}
}
}
ReverseComparer c=new ReverseComparer();
Array.Sort(a, c.customerCompare);
Console.WriteLine("排序后的数组为");
3)自定义类型，实现sort
要想实现类型集合可以sort方法，则类型必须实现Icomparable接口的CompareTo方法，一旦实现了CompareTo方法只要集合调用了sort()方法就直接返回默认的排序（因为归根到底都是基于类型，所以如果最终是数值类型，则还是按照从小到大排序)。
public interface IComparable
{
int CompareTo(object obj);
}
自定义类型Person,实现默认排序 按照person id从小到大排序
public class person:IComparable<person>{public int id;public string name;//默认唯一方法public int CompareTo(person p){if (this.id > p.id){return 1;}else if (this.id == p.id){return 0;}else{return -1;}}}
数组persons实现排序
public class persons : List<person>{public List<person> l;public persons(){l = new List<person>();}}
数组初始化数据
List<person> l = new List<person>();l.Add(new person { id = 44, name = "name44" });l.Add(new person { id = 1, name = "name1" });l.Add(new person { id = 99, name = "name99" });Console.WriteLine("Persons 排序前的数据为");foreach (person p in l){Console.WriteLine(p.id + "-" + p.name);}Console.WriteLine("Persons 排序后的数据为");l.Sort();foreach (person p in l){Console.WriteLine(p.id + "-" + p.name);}Console.ReadLine();
默认将按照id大小排序,从小到大……………………………………………………
4)自定义类型实现默认排序之外的其他排序
和基于类型一样有2种方法。一是定义个class实现Icomparer<T>接口中comparer方法.另外一个就是委托。参照上面基元类型的其他排序规则
5)匿名函数之其他排序规则
如果一个类型里有4个属性，都是基元类型，如下
public class user:IComparable<user>
{
public int id { get; set; }
public string name { get; set; }
public int age { get; set; }
public int mobile { get; set; }
}
例如：在业务1时候，需要按照id排序；在业务2的时候需要按照name排序；在业务3的时候需要按照age排序；业务4的时候需要按照mobile排序
首先想到的是可以自定义类实现comparer方法或者委托方法。对于类型user来说，系统中可能排序有8种可能，id 大小排序2种，name排序2种，age排序2种，mobile排序2种。
对于实现comparer接口来说,要自定义8个类实现Icomparable<T>接口的comparer方法，对于委托方法Comparison<(Of <(T>)>) 要实现8个函数。
此时可以使用匿名函数，在排序的时候生成排序规则
按照姓名排序:persons.sort(delegate(person a, person b) { return a.name.CompareTo(b.name); })
按照id排序:persons.sort(delegate(person a, person b) { return a.id.CompareTo(b.id); })
总结
Icomparable<T> 接口 public int CompareTo(object)方法，实现了此方法就可以默认实现sort方法
Icomparer<T>接口的 public int Compare(T a,Tb)方法 里面可以调用a.CompareTo(b)，是一个排序方法
Comparison<(Of <(T>)>) 就是一个委托方法 public delegate int xx(T x,Ty)
要想实现比较必须实现Icomparable<t>,基元类型都实现了此方法。 自定义类若想实现比较，要实现此接口中的方法（如果自定义类没实现这个接口，那么这个此类型的数组将不能使用sort方法），当然也可以在自定义类型中再创建一个 compare方法，实现另一种排序规则。 CompareTo 是默认排序规则。
对于基元数据类型的数组，默认的sort方法就是从小到大排序（不稳定的快速排序方法，相等的元素位置不保证不变），如果自定义排序规则，则实现Icomparer<T>中的 Compare方法
另外其他一些：
Sort<(Of <(T>)>)(array<T>[]()[], Int32, Int32) 对数组的某个范围内进行排序， 参数：数组，起始索引，长度
Sort<(Of <(TKey, TValue>)>)(array<TKey>[]()[], array<TValue>[]()[], IComparer<(Of <(TKey>)>))基于第一个 Array 中的关键字，使用指定的 IComparer<(Of <(T>)>) 泛型接口，对两个 Array 对象（一个包含关键字，另一个包含对应的项）进行排序。