How to define arrays in C #

One or one dimensions:
int[] numbers = new int[]{1,2,3,4,5,6}; Indefinite length
int[] numbers = new int[3]{1,2,3};//fixed length
Second, multidimensional
int[,] numbers = new int[,]{{1,2,3},{1,2,3}}; Indefinite length
int[,] numbers = new int[2,2]{{1,2},{1,2}}; Fixed length

Iii. examples
A:int[] Mf1=new int[6];
Note the scope of the initialized array, or specify the initial value; An array of one-dimensional integers containing 6 elements, initial 1,2,3,4,5,6
Int[] Mf2=new int[6]{1,2,3,4,5,6};

b://a one-dimensional array of strings, and if an initializer is provided, you can also omit the new operator
String[] mf3={"C", "C + +", "C #"};

c://array of one-dimensional objects
object[] Mf4 = new Object[5] {26, 27, 28, 29, 30};

d://Two-dimensional integer array, initial value mf5[0,0]=1,mf5[0,1]=2,mf5[1,0]=3,mf5[1,1]=4
int[,] mf5=new int[,]{{1,2},{3,4}};

E://6*6 array of two-dimensional integers
int[,] mf6=new mf[6,6];

Iv. get the number of array elements:
int b;
b = sizeof (a)/sizeof (*a);

C # string and array manipulation
2007-12-12 17:53 string operation (fetch current time)
String time=convert.tostring (Datetime.today). Split (new char []{'}); TEXTBOX1.TEXT=TIME[0]; A space is used as the dividing point;

Array Overview
The C # array is indexed from zero, that is, the array index is zero-based. Arrays in C # work similar to how they work in most other popular languages. But there are some differences that should be brought to the attention. When the
declares an array, the square brackets ([]) must follow the type, not behind the identifier. In C #, placing square brackets after an identifier is not a valid syntax.
int[] table;//not int table[];
Another detail is that the size of the array is not part of its type, but in C it is part of the array type. This allows you to declare an array and assign it an arbitrary array of int objects, regardless of the length of the array.
int[] numbers;//declare numbers as an int array of any size
numbers = new INT[10];//numbers is a 10-element arr ay
numbers = new INT[20];//Now it ' s a 20-element array

Declaring an array
C # supports arrays of one-dimensional arrays, multidimensional arrays (rectangular arrays) and arrays (jagged arrays). The following example shows how to declare arrays of different types:
One-dimensional array: int[] numbers;
Multidimensional array: string[,] names;
Array of arrays (interlaced): byte[][] scores;
declaring arrays (as shown above) does not actually create them. In C #, arrays are objects (discussed later in this tutorial) and must be instantiated. The following example shows how to create an array:
One-dimensional array: int[] numbers = new INT[5];
Multidimensional array: string[,] names = new string[5,4];
Array of arrays (interleaved): byte[][] scores = new byte[5][]; for (int x = 0; x < scores. Length; X + +) {Scores[x] = new BYT[4];
}
You can also have larger arrays. For example, you can have a three-dimensional rectangular array: int[,,] buttons = new int[4,5,3];
You can even mix a rectangular array with a jagged array. For example, the following code declares a one-dimensional array of three-dimensional arrays of two-dimensional arrays of type int int[][,,][,] numbers;

Initializing an array
C # provides a simple and straightforward way to initialize an array at declaration time by enclosing the initial value in curly braces ({}). The following example shows various methods for initializing arrays of different types.
Note If the array is not initialized at the time of declaration, the array member is automatically initialized to the default initial value of the array type. Also, if an array is declared as a field of a type, it is set to the default value NULL when the type is instantiated.

One-dimensional arrays
int[] numbers = new Int[5] {1, 2, 3, 4, 5};
string[] names = new String[3] {"Matt", "Joanne", "Robert"};
You can omit the size of the array, as follows:
int[] numbers = new int[] {1, 2, 3, 4, 5};
string[] names = new string[] {"Matt", "Joanne", "Robert"};
If you provide an initializer, you can also omit the new operator, as follows:
int[] numbers = {1, 2, 3, 4, 5};
String[] names = {"Matt", "Joanne", "Robert"};

Multidimensional arrays
int[,] numbers = new int[3, 2] {{1, 2}, {3, 4}, {5, 6}};
string[,] siblings = new string[2, 2] {"Mike", "Amy"}, {"Mary", "Albert"};
You can omit the size of the array, as follows:
int[,] numbers = new int[,] {{1, 2}, {3, 4}, {5, 6}};
string[,] siblings = new string[,] {{"Mike", "Amy"}, {"Mary", "Albert"};
If you provide an initializer, you can also omit the new operator, as follows:
int[,] numbers = {{1, 2}, {3, 4}, {5, 6}};
string[,] siblings = {"Mike", "Amy"}, {"Mary", "Albert"};

Jagged Array (array of arrays)
You can initialize a jagged array as shown in the following example:
int[][] numbers = new int[2][] {new int[] {2,3,4}, new int[] {5,6,7,8,9}};
The size of the first array can be omitted, as follows:
int[][] numbers = new int[][] {new int[] {2,3,4}, new int[] {5,6,7,8,9}};-or-
int[][] numbers = {new int[] {2,3,4}, new int[] {5,6,7,8,9}};
Note that there is no initialization syntax for elements of a jagged array.

Accessing array members
Access to an array member can be done directly, similar to accessing an array member in C + +. For example, the following code creates an array named numbers, and then assigns a 5 to the fifth element of the array:
int[] numbers = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
NUMBERS[4] = 5;
The following code declares a multidimensional array and assigns 5 to the member at [1, 1]:
int[,] numbers = {{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}};
Numbers[1, 1] = 5;
The following declares a one-dimensional jagged array that contains two elements. The first element is an array of two integers, and the second element is an array of three integers:
int[][] numbers = new int[][] {new int[] {1, 2}, new int[] {3, 4, 5}};
The following statement assigns 58 to the first element of the first array and 667 to the second element of the second array:
Numbers[0][0] = 58;
NUMBERS[1][1] = 667;

An array is an object
In C #, an array is actually an object. System.Array is an abstract base type for all array types. You can use the properties that System.Array has and other class members. An example of this usage is to get the length of the array using the Length property. The following code assigns the length of the numbers array (5) to a variable named lengthofnumbers:
int[] numbers = {1, 2, 3, 4, 5};
int lengthofnumbers = numbers. Length;
The System.Array class provides a number of useful other methods/properties, such as methods for sorting, searching, and copying arrays.

Using foreach with arrays
C # also provides a foreach statement. This statement provides a simple, straightforward way to iterate through the elements of an array. For example, the following code creates an array named numbers and iterates through the array with a foreach statement:
int[] Numbers = {4, 5, 6, 1, 2, 3,-2,-1, 0};
foreach (int i in numbers) {System.Console.WriteLine (i);}
Because of the multidimensional array, you can iterate through the elements using the same method, for example:
int[,] numbers = new int[3, 2] {{9, 99}, {3, 33}, {5, 55}};
foreach (int i in numbers) {Console.Write ("{0}", i);}
The output of this example is: 9 99 3 33 5 55
However, because of the multidimensional array, using a nested for loop will give you more control over the array elements