Int32[] myIntegers; //声明一个数组引用
myIntegers = new int32[100] //创建含有100个Int32的数组

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

// 创建一个含有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]);
}

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

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

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

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

var names = { "Aidan", "Grant" };

// 使用C#的隐式类型的局部变量、隐式类型的数组和匿名类型
var kids = new[] {new { Name="Aidan" }, new { Name="Grant" }};
// 示例用法
foreach (var kid in kids)Console.WriteLine(kid.Name);

private static void ArrayCasting() {
// 创建一个二维FileStream数组
FileStream[,] fs2dim = new FileStream[5, 10];// 隐式转型为一个二维Object数组
Object[,] o2dim = fs2dim;// 不能从二维数组转型为一维数组
//Stream[] s1dim = (Stream[]) o2dim;// 显式转型为二维Stream数组
Stream[,] s2dim = (Stream[,]) o2dim;// 显式转型为二维String数组
// 能通过编译，但在运行时会抛出异常
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);
}

FileStream[] fsArray;

// 这段代码更容易写，更容易理解
Appointment[] app = GetAppointmentForToday();
for (Int32 a =0; a< app.Length; a++) {
// 对app[a]执行操作
}

// 写起来麻烦，不容易理解
Appointment[] app = GetAppointmentForToday();
if( app !=null ) {
for (Int32 a =0; a< app.Length; a++) {
// 对app[a]执行操作}
}

internal static class ArrayTypes {public static void Go() {
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基数组，其中不包含任何元素
a = Array.CreateInstance(typeof(String), new Int32[] { 0 }, new Int32[] { 1 });Console.WriteLine(a.GetType());    // System.String[*] <-- 注意!

Console.WriteLine();// 创建一个二维数组的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基数组，其中不包含任何元素
a = Array.CreateInstance(typeof(String), new Int32[] { 0, 0 }, new Int32[] { 1, 1 });Console.WriteLine(a.GetType());    // System.String[,]}
}

internal static class MultiDimArrayPerformance
{
private const Int32 c_numElements = 10000;public static void Go()
{
const Int32 testCount = 10;
Stopwatch sw;// 声明一个二维数组
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: 用普通的安全技术访问数组中的所有元素
sw = Stopwatch.StartNew();
for (Int32 test = 0; test < testCount; test++)
Safe2DimArrayAccess(a2Dim);
Console.WriteLine("{0}: Safe2DimArrayAccess", sw.Elapsed);// 2: 用交错数组技术访问数组中的所有元素
sw = Stopwatch.StartNew();
for (Int32 test = 0; test < testCount; test++)
SafeJaggedArrayAccess(aJagged);
Console.WriteLine("{0}: SafeJaggedArrayAccess", sw.Elapsed);// 3: 用unsafe访问数组中的所有元素
sw = Stopwatch.StartNew();
for (Int32 test = 0; test < testCount; test++)
Unsafe2DimArrayAccess(a2Dim);
Console.WriteLine("{0}: Unsafe2DimArrayAccess", sw.Elapsed);
Console.ReadLine();
}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;
}private static unsafe Int32 Unsafe2DimArrayAccess(Int32[,] a)
{Int32 sum = 0;fixed (Int32* pi = a){for (Int32 x = 0; x < c_numElements; x++){Int32 baseOfDim = x * c_numElements;for (Int32 y = 0; y < c_numElements; y++){sum += pi[baseOfDim + y];}}}return sum;
}
}

internal static class StackallocAndInlineArrays
{
public static void Go()
{
StackallocDemo();
InlineArrayDemo();
}private static void StackallocDemo()
{
unsafe
{
const Int32 width = 20;
Char* pc = stackalloc Char[width];    // 在栈上分配数组

String s = "Jeffrey Richter";    // 15 个字符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;String s = "Jeffrey Richter";    // 15 个字符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];
}
}