----------
20190505

using System;

public class SamplesArray2
{
    public static void Main()
    {
        // Creates and initializes a new three-dimensional Array of type Int32.
        Array myArr = Array.CreateInstance(typeof(Int32), 2, 3, 4);
        for (int i = myArr.GetLowerBound(0); i <= myArr.GetUpperBound(0); i++)
        {
            for (int j = myArr.GetLowerBound(1); j <= myArr.GetUpperBound(1); j++)
            {
                for (int k = myArr.GetLowerBound(2); k <= myArr.GetUpperBound(2); k++)
                {
                    myArr.SetValue((i * 100) + (j * 10) + k, i, j, k);
                }
            }
        }

        // Displays the properties of the Array.
        Console.WriteLine("The Array has {0} dimension(s) and a total of {1} elements.", myArr.Rank, myArr.Length);
        Console.WriteLine("\tLength\tLower\tUpper");
        for (int i = 0; i < myArr.Rank; i++)
        {
            Console.Write("{0}:\t{1}", i, myArr.GetLength(i));
            Console.WriteLine("\t{0}\t{1}", myArr.GetLowerBound(i), myArr.GetUpperBound(i));
        }

        // Displays the contents of the Array.
        Console.WriteLine("The Array contains the following values:");
        PrintValues(myArr);
    }


    public static void PrintValues(Array myArr)
    {
        System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
        int i = 0;
        int cols = myArr.GetLength(myArr.Rank - 1);
        while (myEnumerator.MoveNext())
        {
            if (i < cols)
            {
                i++;
            }
            else
            {
                Console.WriteLine();
                i = 1;
            }
            Console.Write("\t{0}", myEnumerator.Current);
        }
        Console.WriteLine();
    }
}
/* 
This code produces the following output.

The Array has 3 dimension(s) and a total of 24 elements.
    Length    Lower    Upper
0:    2    0    1
1:    3    0    2
2:    4    0    3
The Array contains the following values:
    0    1    2    3
    10    11    12    13
    20    21    22    23
    100    101    102    103
    110    111    112    113
    120    121    122    123
*/



----------
Before 20190505

// http://svc.luckstar.com.tw/CodeHelper/cs/index.html
// 2017-03-22, honda@luckstar.com.tw, Create.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
// add
using System.Collections;
using System.Drawing;

namespace ConsoleBase
{
    public class CArray
    {
        int[] mList1 = new int[5] { 1, 2, 3, 4, 5 };
        public void Run()
        {
            string[] sa1 = new string[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
            int[,] ia1 = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
            Array ia3d = Array.CreateInstance(typeof(Int32), 2, 3, 4);
            Object[] oa1 = new Object[5] { 26, "string", DateTime.Now , 999L, 123.456d };
            string[] saColumn = "column1,column2,column3".Split(',');

            // Create an array of five Point structures.
            Point[] pa1 = { new Point(100, 200),
                new Point(150, 250), new Point(250, 375),
                new Point(275, 395), new Point(295, 450) };

            Console.WriteLine("basic: ");
            PrintArray(mList1);
            mList1[1] = ia1[2, 1];
            PrintArray(mList1);
            PrintArrayInfo(mList1);


            // Prints the initial values of both arrays.
            PrintDashLine();
            Console.WriteLine("Initially,");
            Console.Write("integer array:");
            PrintArray(mList1);
            Console.Write("Object array: ");
            PrintArray(oa1);

            // Copies the first two elements from the integer array to the Object array.
            Array.Copy(mList1, oa1, 2);


            // Prints the values of the modified arrays.
            Console.WriteLine("\nAfter copying the first two elements of the integer array to the Object array,");
            Console.Write("integer array:");
            PrintArray(mList1);
            Console.Write("Object array: ");
            PrintArray(oa1);

            // Copies the last two elements from the Object array to the integer array.
            System.Array.Copy(mList1, mList1.GetUpperBound(0) - 1, oa1, oa1.GetUpperBound(0) - 1, 2);

            // Prints the values of the modified arrays.
            Console.WriteLine("\nAfter copying the last two elements of the Object array to the integer array,");
            Console.Write("integer array:");
            PrintArray(mList1);
            Console.Write("Object array: ");
            PrintArray(oa1);

            // Initializes three-dimensional Array of type Int32.
            for (int i = ia3d.GetLowerBound(0); i <= ia3d.GetUpperBound(0); i++)
                for (int j = ia3d.GetLowerBound(1); j <= ia3d.GetUpperBound(1); j++)
                    for (int k = ia3d.GetLowerBound(2); k <= ia3d.GetUpperBound(2); k++)
                    {
                        ia3d.SetValue((i * 100) + (j * 10) + k, i, j, k);
                    }

            PrintDashLine();
            Console.WriteLine("ia3D:");
            PrintArrayInfo(ia3d);
            PrintArray(ia3d);

            PrintDashLine();
            Console.WriteLine("saColumn:");
            PrintArrayInfo(saColumn);
            PrintArray(saColumn);

            PrintDashLine();
            Console.WriteLine("ia1:");
            PrintArrayInfo(mList1);
            PrintArray(mList1);

            PrintDashLine();
            Console.WriteLine("oa1: ");
            PrintArrayInfo(oa1);
            PrintArray(oa1);

            // To find the first Point structure for which X times Y 
            // is greater than 100000, pass the array and a delegate
            // that represents the ProductGT10 method to the Shared 
            // Find method of the Array class. 
            // Note that you do not need to create the delegate 
            // explicitly, or to specify the type parameter of the 
            // generic method, because the C# compiler has enough
            // context to determine that information for you.
            PrintDashLine();
            Console.WriteLine("Find with delegate or linq.");
            Console.WriteLine("ia1:");
            PrintArray(mList1);
            Console.WriteLine("ia1 LessThan3");
            int iFind = Array.Find(mList1, LessThan3);
            Console.WriteLine("iFind={0}.", iFind);
            int iFindLinq = Array.Find<int>(mList1, (t => t < 3));
            Console.WriteLine("FoundLinq={0}", iFindLinq);

            PrintDashLine();
            Console.WriteLine("pa1: by a anonymous delegate to find elements in array.");
            Point p1 = Array.Find(pa1, ProductGT10);
            Console.WriteLine("Found: X = {0}, Y = {1}", p1.X, p1.Y);
            Point pToFind = new Point(150, 250);
            Point p2 = Array.Find<Point>(pa1, (t => t == pToFind));
            Console.WriteLine("FoundLinq: X = {0}, Y = {1}", p1.X, p1.Y);

            PrintDashLine();
            Console.WriteLine("ia2: ");
            PrintArray(ia1);
            Console.WriteLine("ia2[3,1]={0}.", ia1[3, 1]);

            PrintDashLine();
            Console.WriteLine("ia1 sort: ");
            PrintArray(mList1);
            Array.Sort(mList1);
            PrintArray(mList1);
            int iBinarySearcha = Array.BinarySearch(mList1, 11);
            int iBinarySearchb = Array.BinarySearch(mList1, 33);
            Console.WriteLine("iBinarySearcha={0}, iBinarySearchb={1}.", iBinarySearcha, iBinarySearchb);
        }
        private void PrintDashLine()
        {
            Console.WriteLine();
            Console.WriteLine("----------");
        }
        private void PrintArray(int[] ia1)
        {
            Console.Write("PrintArray(int[]):");
            foreach (int i in ia1)
            {
                Console.Write("\t{0}", i);
            }
            Console.WriteLine();
        }
        private void PrintArray(Object[] oa1)
        {
            Console.Write("PrintArray(Object[]):");
            foreach (object o1 in oa1)
            {
                Console.Write("\t{0}", o1);
            }
            Console.WriteLine();
        }

        private void PrintArrayInfo(Array a1)
        {
            Console.WriteLine("{0} dimension(s) with total {1} elements:", a1.Rank, a1.Length);
            Console.WriteLine("\tLength\tLower\tUpper");
            for (int i = 0; i < a1.Rank; i++)
            {
                Console.WriteLine("{0}:\t{1}\t{2}\t{3}", i, a1.GetLength(i), a1.GetLowerBound(i), a1.GetUpperBound(i));
            }
        }


        private void PrintArray(Array a1)
        {
            Console.Write("PrintArray(Array):");
            IEnumerator myEnumerator = a1.GetEnumerator();
            int i = 0;
            // 3D 
            int cols = a1.GetLength(a1.Rank - 1);
            while (myEnumerator.MoveNext())
            {
                if (i < cols)
                {
                    i++;
                }
                else
                {
                    Console.WriteLine();
                    i = 1;
                }
                Console.Write("\t{0}", myEnumerator.Current);
            }
            Console.WriteLine();
        }
        private void PrintArray(int[,] ia2D)
        {
            Console.Write("PrintArray(int[,]):");
            foreach (int i in ia2D)
            {
                Console.Write("\t{0}", i);
            }
            Console.WriteLine();
        }

        private Boolean LessThan3(int i1)
        {
            if (i1 < 3)
                return true;
            return false;
        }
        private bool ProductGT10(Point p1)
        {
            if (p1.X * p1.Y > 100000)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }
}


result:

basic: 
PrintArray(int[]):	1	2	3	4	5
PrintArray(int[]):	1	6	3	4	5
1 dimension(s) with total 5 elements:
	Length	Lower	Upper
0:	5	0	4

----------
Initially,
integer array:PrintArray(int[]):	1	6	3	4	5
Object array: PrintArray(Object[]):	26	string	2017/3/22 下午 08:28:48	999	123.456

After copying the first two elements of the integer array to the Object array,
integer array:PrintArray(int[]):	1	6	3	4	5
Object array: PrintArray(Object[]):	1	6	2017/3/22 下午 08:28:48	999	123.456

After copying the last two elements of the Object array to the integer array,
integer array:PrintArray(int[]):	1	6	3	4	5
Object array: PrintArray(Object[]):	1	6	2017/3/22 下午 08:28:48	4	5

----------
ia3D:
3 dimension(s) with total 24 elements:
	Length	Lower	Upper
0:	2	0	1
1:	3	0	2
2:	4	0	3
PrintArray(Array):	0	1	2	3
	10	11	12	13
	20	21	22	23
	100	101	102	103
	110	111	112	113
	120	121	122	123

----------
saColumn:
1 dimension(s) with total 3 elements:
	Length	Lower	Upper
0:	3	0	2
PrintArray(Object[]):	column1	column2	column3

----------
ia1:
1 dimension(s) with total 5 elements:
	Length	Lower	Upper
0:	5	0	4
PrintArray(int[]):	1	6	3	4	5

----------
oa1: 
1 dimension(s) with total 5 elements:
	Length	Lower	Upper
0:	5	0	4
PrintArray(Object[]):	1	6	2017/3/22 下午 08:28:48	4	5

----------
Find with delegate or linq.
ia1:
PrintArray(int[]):	1	6	3	4	5
ia1 LessThan3
iFind=1.
FoundLinq=1

----------
pa1: by a anonymous delegate to find elements in array.
Found: X = 275, Y = 395
FoundLinq: X = 275, Y = 395

----------
ia2: 
PrintArray(int[,]):	1	2	3	4	5	6	7	8
ia2[3,1]=8.

----------
ia1 sort: 
PrintArray(int[]):	1	6	3	4	5
PrintArray(int[]):	1	3	4	5	6
iBinarySearcha=-6, iBinarySearchb=-6.