// 刚开始声明变量, 没有分配数组,所以为null
Int32[] myInts; // 声明一个数组引用
// 在托管堆上分配了100个未装箱Int32所需的内存块,返回该内存块的地址
// 所有Int32都被初始化为0。因为数组是引用类型,
// 所以内存块中还包含类型对象指针,同步索引块,一些开销字段(额外成员)
myInts = new Int32[100]; //创建含有100个Int32的数组


Control[] myCon;
// Control是引用类型,50个引用全部被初始化为null
myCon = new Control[50];

// 执行一些代码
myCon[1] = new Button();
myCon[2] = new TextBox();
myCon[3] = myCon[2]; //两个元素引用同一个对象
myCon[1] = new DataGrid();
myCon[1] = new ComboBox();
myCon[1] = new Button();

// 创建一个二维数组，由Double值构成
Double[,] myDoubles = new Double[10,20];

// 创建一个三维数组，由String引用构成
String[,,] myStrings = new String[5,3,10];

//CLR还支持交错数组，即由数组构成的数组。下面例子演示了如何创建一个多边形数组，其中每一个多边形都由一个Point实例数组构成。
// 创建一个含有Point数组的一维数组
Point[][] myPolygons = new Point[3][];

// myPolygons[0]引用一个含有10个Point实例的数组
myPolygons[0] = new Point[10];

// myPolygons[1]引用一个含有20个Point实例的数组
myPolygons[1] = new Point[20];

// myPolygons[2]引用一个含有30个Point实例的数组
myPolygons[2] = new Point[30];

// 显示第一个多边形中的Point
for (Int32 x =0 ; x < myPolygons[0].Length; x++)
{
    Console.WriteLine(myPolygons[0][x]);
}

// 可以在声明时初始化数组,在这种情况下，无需长度说明符，因为它已由初始化列表中的元素数目提供。
// 并且可以省略new int[]
int[] array1 = new int[] { 1, 3, 5, 7, 9 };
int[] array2 = { 1, 3, 5, 7, 9 };


// 可以在不初始化的情况下声明数组变量，但必须使用 new 运算符向此变量分配数组。
int[] array3;
array3 = new int[] { 1, 3, 5, 7, 9 };   // OK
//array3 = {1, 3, 5, 7, 9};   // Error

// 以下声明创建一个具有四行两列的二维数组。
// 也可以
int[,] array = new int[4, 2];

// 三维数组
int[, ,] array1 = new int[4, 2, 3];

// Two-dimensional array.
int[,] array2D = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
// The same array with dimensions specified.
int[,] array2Da = new int[4, 2] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
// A similar array with string elements.
string[,] array2Db = new string[3, 2] { { "one", "two" }, { "three", "four" },
                                        { "five", "six" } };

// 可以简化写法
int[,] array4 = { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
// 如果选择在不初始化的情况下声明数组变量，则必须使用 new 运算符将数组赋予变量。
int[,] array5;
array5 = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };   // OK
//array5 = {{1,2}, {3,4}, {5,6}, {7,8}};   // Error


// 以下代码示例将数组元素初始化为默认值（交错数组除外）
int[,] array6 = new int[10, 10];

// 声明三个元素,每个元素都是一维整数数组
int[][] jaggedArray = new int[3][];


// 必须初始化 jaggedArray 的元素后才可使用它。
jaggedArray[0] = new int[5];
jaggedArray[1] = new int[4];
jaggedArray[2] = new int[2];

// 也可使用初始化表达式通过值来填充数组元素，这种情况下不需要数组大小
jaggedArray[0] = new int[] { 1, 3, 5, 7, 9 };
jaggedArray[1] = new int[] { 0, 2, 4, 6 };
jaggedArray[2] = new int[] { 11, 22 };

// 不能从元素初始化中省略 new 运算符，因为不存在元素的默认初始化：
// 可以省略 new int[][]
int[][] jaggedArray3 = // new int[][]
{
    new int[] { 1, 3, 5, 7, 9 },
    new int[] { 0, 2, 4, 6 },
    new int[] { 11, 22 }
};

// 混合使用多维数组和交错数组
int[][,] jaggedArray4 = new int[3][,]
{
    new int[,] { {1,3}, {5,7} },
    new int[,] { {0,2}, {4,6}, {8,10} },
    new int[,] { {11,22}, {99,88}, {0,9} }
};
// 访问个别元素，示例显示第一个数组的元素 [1,0] 的值
System.Console.Write("{0}", jaggedArray4[0][1, 0]);// 5
// 方法 Length 返回包含在交错数组中的数组的数目
System.Console.WriteLine(jaggedArray4.Length); // 3

// 一维数组的foreach
int[] numbers = { 4, 5, 6, 1, 2, 3, -2, -1, 0 };
foreach (int i in numbers)
{
    System.Console.Write("{0} ", i);
}
// Output: 4 5 6 1 2 3 -2 -1 0


// 多维数组的foreach
int[,] numbers2D = new int[3, 2] { { 9, 99 }, { 3, 33 }, { 5, 55 } };
//省略 new int[3, 2]写法
//int[,] numbers2D = { { 9, 99 }, { 3, 33 }, { 5, 55 } };

foreach (int i in numbers2D)
{
    System.Console.Write("{0} ", i);
}
// Output: 9 99 3 33 5 55

String[] names = new String[] { "Aidan", "Grant" };

// 用var代替String
var names = new String[] { "Aidan", "Grant" };

// 省略了new和[]之间的类型
// 选择所有数组元素最接近的共同基类来作为数组的类型
// 本例中,2个string和一个null , 因为null可以隐式转型为任意盈余类型,所以编译器创建为String数组
var names = new[] { "Aidan", "Grant", null};

// 错误的, 因为这样编译器只能推断为共同基类Object
// 这会造成123数值类型进行隐式装箱, 这个操作代价高昂,所以要在编译时报错
// var names = new[] { "Aidan", "Grant", 123};

// 额外语法,还可以这么写, 省略new 和[] 和类型.
// 但是这种写法不允许使用var
String[] names = { "Aidan", "Grant" };

// 两个匿名类具有一致的结构, 表示有一个string类型的Name字段的类.
// 所以编译器知道这两个对象具有相同的类型
var kids = new[] { new { Name = "Aidan" }, new { Name = "Grant" }};

foreach(var kid in kids)
 Console.WriteLine(kid.Name);

// 创建一个二维FileStream数组
FileStream[,] fs2dim = new FileStream[5, 10];

// 隐式转型为一个二维Object数组
Object[,] o2dim = fs2dim;

// 不能从二维数组转型为一维数组
//Stream[] s1dim = (Stream[]) o2dim;

// 显式转型为二维Stream数组
Stream[,] s2dim = (Stream[,]) o2dim;

// 显式转型为二维String数组
// 能通过编译，但在运行时会抛出异常,InvalidCastException
// String[,] st2dim = (String[,]) o2dim;

// 创建一个意味Int32数组(元素是值类型)
Int32[] i1dim = new Int32[5];

// 不能将值类型的数组转型为其他任何类型
// Object[] o1dim = (Object[]) i1dim;

// 创建一个新数组，使用Array.Copy将元数组中的每一个元素
// 转型为目标数组中的元素类型，并把它们复制过去
// 下面的代码创建一个元素为引用类型的数组，
// 每个元素都是对已装箱的Int32的引用   ←-------------------重点
Object[] o1dim = new Object[i1dim.Length];
Array.Copy(i1dim, o1dim, 0);

// 定义实现了一个接口的值类型
internal struct MyValueType : IComparable
{
    public int CompareTo(object obj)
    {
        throw new NotImplementedException();
    }
}

public static void Main(string[] args)
{
    // 创建包含值类型的数组
    var src = new MyValueType[100];
    // 创建接口引用数组
    var comparables = new IComparable[src.Length];
    // 使他们引用src数组元素的已装箱版本
    Array.Copy(src,comparables,src.Length);
}

// 性能损失
String[] sa = new String[100];
Object[] oa = sa;  // oa引用了一个String数组

oa[5] = "Jeff"; // 性能损失,CLR检查oa元素类型是不是String类型,检查通过
// 运行时抛出ArraryTypeMismatchException
// 因为CLR要保证赋值的合法性
oa[3] = 5;      // 性能损失,CLR检查oa元素类型是不是Int32; 发现有错,会抛出异常

void M1(IList<FileStream> fsList){...}
void M2(ICollection<Stream> sCollection){...}
void M3(IEnumerable<Object> oEnumerable){...}

// 创建一个二维数组{2005...2009} {1...4}
Int32[] lowerBounds = {2005, 1};
Int32[] lengths     = {5, 4};
// 传入元素的类型, 5行4列
Decimal[,] quarterlyRevenue = (Decimal[,])
    Array.CreateInstance(typeof(Decimal), lengths, lowerBounds);

// Array的Rank 属性：得到Array的秩（维数）  quarterlyRevenue.Rank等于2;
// GetUpperBound(int dimension) 用于获取 Array 的指定维度的上限。
// GetLowerBound(int dimension) 用于获取 Array 的指定维度的下限。

// 取得第一维的下限 , 如果传入1, 则表示取得第二维的下限
Int32 firstYear = quarterlyRevenue.GetLowerBound(0);
Int32 lastYear  = quarterlyRevenue.GetUpperBound(0);
Console.WriteLine("{0,4}  {1,9}  {2,9}  {3,9}  {4,9}", "Year", "Q1", "Q2", "Q3", "Q4");

Random r = new Random();
for (Int32 year = firstYear; year <= lastYear; year++)
{
    Console.Write(year + "  ");

    // 把二维数组看成表格,从(1,1)开始, 小于第二维的个数,横向遍历
    for (Int32 quarter = quarterlyRevenue.GetLowerBound(1);
        quarter <= quarterlyRevenue.GetUpperBound(1);
        quarter++)
    {
        quarterlyRevenue[year, quarter] = r.Next(10000);
        // C 表示格式化为货币
        Console.Write("{0,9:C}  ", quarterlyRevenue[year, quarter]);
    }
    Console.WriteLine();
}

// Year         Q1         Q2         Q3         Q4
// 2005  ￥2,102.00  ￥7,295.00    ￥105.00  ￥5,846.00
// 2006  ￥6,331.00  ￥1,955.00    ￥879.00  ￥8,752.00
// 2007    ￥912.00  ￥1,105.00  ￥6,960.00  ￥7,205.00
// 2008  ￥6,479.00  ￥6,034.00  ￥6,182.00  ￥3,565.00
// 2009    ￥558.00  ￥8,291.00  ￥4,028.00  ￥1,740.00

Array a;

// 定义一维的0基数组,不包含任何元素
a = new String[0];
Console.WriteLine(a.GetType()); // System.String[]

// 定义一维的0基数组,不包含任何元素
a = Array.CreateInstance(typeof(String), new Int32[] {0}, new Int32[] {0});
Console.WriteLine(a.GetType()); // System.String[]

// 定义一维的1基数组,不包含任何元素
// 1基数组显示的类型是System.String[*], *号表示CLR知道该数组不是0基的.
// C#不允许声明String[*]类型的变量,因此不能使用C#语法来访问一维非0基数组.
// 可以用Array的GetValue和SetValue来访问,但是速度较慢,调用方法有开销.
a = Array.CreateInstance(typeof(String), new Int32[] {0}, new Int32[] {1});
Console.WriteLine(a.GetType()); // System.String[*]  <-- INTERESTING!


// 定义二维的0基数组,不包含任何元素
a = new String[0, 0];
Console.WriteLine(a.GetType()); // System.String[,]

// 定义二维的0基数组,不包含任何元素
a = Array.CreateInstance(typeof(String), new Int32[] {0, 0}, new Int32[] {0, 0});
Console.WriteLine(a.GetType()); // System.String[,]

// 定义二维的1基数组,不包含任何元素
// CLR会将多维数组都视为非0基数组,CLR决定对多维数组不使用*号
a = Array.CreateInstance(typeof(String), new Int32[] {0, 0}, new Int32[] {1, 1});
Console.WriteLine(a.GetType()); // System.String[,]

var ints = new Int32[5];
// ints.Length调用属性方法
for (int i = 0; i < ints.Length; i++)
{
    // 对ints[i]操作
}

private const Int32 c_numElements = 10000;

public static void Go()
{
    // 声明二维数组
    Int32[,] a2Dim = new Int32[c_numElements, c_numElements];

    // 将二维数组声明为交错数组
    Int32[][] aJagged = new Int32[c_numElements][];
    for (Int32 x = 0; x < c_numElements; x++)
        aJagged[x] = new Int32[c_numElements];


    // 1: 用普通的安全技术访问数组中的所有元素
    // 二维数组对象 a[x, y];
    Safe2DimArrayAccess(a2Dim);

    // 2: 用交错数组技术访问数组中的所有元素
    // 交错数组对象 a[x][y]
    SafeJaggedArrayAccess(aJagged);

    // 3: 用unsafe技术访问数组中的所有元素
    Unsafe2DimArrayAccess(a2Dim);
}

private static Int32 Safe2DimArrayAccess(Int32[,] a)
{
    Int32 sum = 0;
    for (Int32 x = 0; x < c_numElements; x++)
    {
        for (Int32 y = 0; y < c_numElements; y++)
        {
            sum += a[x, y];
        }
    }
    return sum;
}

private static Int32 SafeJaggedArrayAccess(Int32[][] a)
{
    Int32 sum = 0;
    for (Int32 x = 0; x < c_numElements; x++)
    {
        for (Int32 y = 0; y < c_numElements; y++)
        {
            sum += a[x][y];
        }
    }
    return sum;
}

// fixed 语句必须要用unsafe方法修饰符
private static unsafe Int32 Unsafe2DimArrayAccess(Int32[,] a)
{
    Int32 sum = 0, numElements = c_numElements * c_numElements;
    fixed (Int32* pi = a)
    {
        for (Int32 x = 0; x < numElements; x++)
        {
            sum += pi[x];
        }
    }
    return sum;
}

private static void StackallocDemo()
{
    unsafe
    {
        const Int32 width = 20;
        // 在栈上分配数组
        Char*       pc    = stackalloc Char[width];
        // 15 个字符
        String s = "Jeffrey Richter";

        for (Int32 index = 0; index < width; index++)
        {
            pc[width - index - 1] =
                (index < s.Length) ? s[index] : '.';
        }
        // 输出 ".....rethciR yerffeJ"
        Console.WriteLine(new String(pc, 0, width));
    }
}

private static void InlineArrayDemo()
{
    unsafe
    {
        // 在栈上分配数组
        CharArray ca;
        Int32     widthInBytes = sizeof(CharArray);
        Int32     width        = widthInBytes / 2;
        // 15 个字符
        String s = "Jeffrey Richter";

        for (Int32 index = 0; index < width; index++)
        {
            ca.Characters[width - index - 1] =
                (index < s.Length) ? s[index] : '.';
        }
        // 输出 ".....rethciR yerffeJ"
        Console.WriteLine(new String(ca.Characters, 0, width));
    }
}

private unsafe struct CharArray
{
    // 这个数组内联嵌入到结构中
    public fixed Char Characters[20];
}