数组

static void Main(string[] args)
        {
            //数组是引用类型，除了数组元素，还包含一个类型对象指针，一个同步索引块，和一些开销字段
            //创建一个值类型数组，会在托管堆上分配容纳100个未装箱值类型所需的内存块。
            //引用类型只创建了一组引用，没有实际对象
            #region 数组隐试实现IList，ICollection，IEnumerable
            //FileStream[] fsArray;//CLR会自动使数组实现IList<T>，ICollection<T>，IEnumerable<T>接口
            ////值类型因为内存布局不同，不会实现上面的接口
            //fsArray = new FileStream[3];
            //M1(fsArray);
            //M2(fsArray);
            //M3(fsArray);
            #endregion

            // DynamicArrays();

            ArrayTypes();



        }

        static void M1(IList<FileStream> f1)
        {

        }

        static void M2(ICollection<Stream> f2)
        {

        }

        static void M3(IEnumerable<object> f3)
        {

        }

        #region 创建下限非0数组

        static void DynamicArrays()
        {
            Int32[] lowerBounds = { 2005, 1 };
            Int32[] lengths = { 5, 4 };
            Decimal[,] quarterlyRevenue = (Decimal[,])Array.CreateInstance(typeof(Decimal), lengths, lowerBounds);
            quarterlyRevenue[2005, 1] = 10;
        }
        #endregion

        #region 数组访问性能

        static void ArrayTypes()
        {
            Array a;

            // Create a 1-dim, 0-based array, with no elements in it
            a = new String[0];
            Console.WriteLine(a.GetType()); // System.String[]

            // Create a 1-dim, 0-based array, with no elements in it
            a = Array.CreateInstance(typeof(String), new Int32[] { 0 }, new Int32[] { 0 });
            Console.WriteLine(a.GetType()); // System.String[]

            // Create a 1-dim, 1-based array, with no elements in it
            a = Array.CreateInstance(typeof(String), new Int32[] { 0 }, new Int32[] { 1 });
            Console.WriteLine(a.GetType()); // System.String[*]  <-- INTERESTING!下限非0数组

            Console.WriteLine();

            //将所有多维数组都视为下限非0数组

            // Create a 2-dim, 0-based array, with no elements in it
            a = new String[0, 0];
            Console.WriteLine(a.GetType()); // System.String[,]

            // Create a 2-dim, 0-based array, with no elements in it
            a = Array.CreateInstance(typeof(String), new Int32[] { 0, 0 }, new Int32[] { 0, 0 });
            Console.WriteLine(a.GetType()); // System.String[,]

            // Create a 2-dim, 1-based array, with no elements in it
            a = Array.CreateInstance(typeof(String), new Int32[] { 0, 0 }, new Int32[] { 1, 1 });
            Console.WriteLine(a.GetType()); // System.String[,]
        }

        private const Int32 c_numElements = 10000;
        public static void MultiDimArrayPerformance()
        {

            const Int32 testCount = 10;
            Stopwatch sw;

            // Declare a 2-dimensional array
            Int32[,] a2Dim = new Int32[c_numElements, c_numElements];

            // Declare a 2-dimensional array as a jagged array (a vector of vectors)
            Int32[][] aJagged = new Int32[c_numElements][];
            for (Int32 x = 0; x < c_numElements; x++)
                aJagged[x] = new Int32[c_numElements];


            // 1: Access all elements of the array using the usual, safe technique
            sw = Stopwatch.StartNew();
            for (Int32 test = 0; test < testCount; test++)
                Safe2DimArrayAccess(a2Dim);
            Console.WriteLine("{0}: Safe2DimArrayAccess", sw.Elapsed);

            // 2: Access all elements of the array using the jagged array technique
            sw = Stopwatch.StartNew();
            for (Int32 test = 0; test < testCount; test++)
                SafeJaggedArrayAccess(aJagged);
            Console.WriteLine("{0}: SafeJaggedArrayAccess", sw.Elapsed);

            // 3: Access all elements of the array using the unsafe technique
            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;
        }

        #endregion

        #region 使用stackalloc创建值类型数组

        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] : '.';
                }
                Console.WriteLine(new String(pc, 0, width));    // ".....rethciR yerffeJ"
            }
        }

        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] : '.';
                }
                Console.WriteLine(new String(ca.Characters, 0, width)); // ".....rethciR yerffeJ"
            }
            #endregion

        }
        private unsafe struct CharArray
        {
            // 数组内联欠入
            public fixed Char Characters[20];
        }