Todas las sintaxis de inicialización de matriz posibles

¿Cuáles son todas las sintaxis de inicialización de matriz que son posibles con C #?

Estos son los métodos actuales de declaración e inicialización para una matriz simple.

string[] array = new string[2]; // creates array of length 2, default values
string[] array = new string[] { "A", "B" }; // creates populated array of length 2
string[] array = { "A" , "B" }; // creates populated array of length 2
string[] array = new[] { "A", "B" }; // created populated array of length 2

Tenga en cuenta que existen otras técnicas para obtener matrices, como las ToArray()extensiones de Linq en IEnumerable<T>.

También tenga en cuenta que en las declaraciones anteriores, los dos primeros podrían reemplazar el string[]de la izquierda con var(C # 3+), ya que la información de la derecha es suficiente para inferir el tipo adecuado. La tercera línea debe escribirse como se muestra, ya que la sintaxis de inicialización de la matriz por sí sola no es suficiente para satisfacer las demandas del compilador. El cuarto también podría usar inferencia. Entonces, si te gusta la brevedad, lo anterior podría escribirse como

var array = new string[2]; // creates array of length 2, default values
var array = new string[] { "A", "B" }; // creates populated array of length 2
string[] array = { "A" , "B" }; // creates populated array of length 2
var array = new[] { "A", "B" }; // created populated array of length 2 

Las sintaxis de creación de matrices en C # que son expresiones son:

new int[3]
new int[3] { 10, 20, 30 }
new int[] { 10, 20, 30 }
new[] { 10, 20, 30 }

En el primero, el tamaño puede ser cualquier valor integral no negativo y los elementos de la matriz se inicializan a los valores predeterminados.

En el segundo, el tamaño debe ser constante y la cantidad de elementos debe coincidir. Debe haber una conversión implícita de los elementos dados al tipo de elemento de matriz dado.

En el tercero, los elementos deben ser implícitamente convertibles al tipo de elemento, y el tamaño se determina a partir del número de elementos dados.

En el cuarto, el tipo de elemento de matriz se infiere calculando el mejor tipo, si hay uno, de todos los elementos dados que tienen tipos. Todos los elementos deben ser implícitamente convertibles a ese tipo. El tamaño se determina a partir del número de elementos dados. Esta sintaxis se introdujo en C # 3.0.

También hay una sintaxis que solo puede usarse en una declaración:

int[] x = { 10, 20, 30 };

Los elementos deben ser implícitamente convertibles al tipo de elemento. El tamaño se determina a partir del número de elementos dados.

no hay una guía todo en uno

Le remito a la especificación C # 4.0, sección 7.6.10.4 "Expresiones de creación de matriz".

Matrices no vacías

• var data0 = new int[3]

• var data1 = new int[3] { 1, 2, 3 }

• var data2 = new int[] { 1, 2, 3 }

• var data3 = new[] { 1, 2, 3 }

• var data4 = { 1, 2, 3 }no es compilable Usar en su int[] data5 = { 1, 2, 3 }lugar.

Matrices vacías

• var data6 = new int[0]
• var data7 = new int[] { }

• var data8 = new [] { } y int[] data9 = new [] { }no son compilables

• var data10 = { }no es compilable Usar en su int[] data11 = { } lugar.

Como argumento de un método

Solo las expresiones que se pueden asignar con la varpalabra clave se pueden pasar como argumentos.

• Foo(new int[2])
• Foo(new int[2] { 1, 2 })
• Foo(new int[] { 1, 2 })
• Foo(new[] { 1, 2 })
• Foo({ 1, 2 }) no es compilable
• Foo(new int[0])
• Foo(new int[] { })
• Foo({}) no es compilable

Enumerable.Repeat(String.Empty, count).ToArray()

Creará una serie de cadenas vacías repetidas veces 'contar'. En caso de que desee inicializar la matriz con el mismo valor de elemento predeterminado pero especial. Cuidado con los tipos de referencia, todos los elementos harán referencia al mismo objeto.

var contacts = new[]
{
    new 
    {
        Name = " Eugene Zabokritski",
        PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
    },
    new 
    {
        Name = " Hanying Feng",
        PhoneNumbers = new[] { "650-555-0199" }
    }
};

En caso de que desee inicializar una matriz fija de elementos iguales preinicializados (no nullu otros default), use esto:

var array = Enumerable.Repeat(string.Empty, 37).ToArray();

También participe en esta discusión.

Ejemplo para crear una matriz de una clase personalizada

A continuación se muestra la definición de clase.

public class DummyUser
{
    public string email { get; set; }
    public string language { get; set; }
}

Así es como puede inicializar la matriz:

private DummyUser[] arrDummyUser = new DummyUser[]
{
    new DummyUser{
       email = "[email protected]",
       language = "English"
    },
    new DummyUser{
       email = "[email protected]",
       language = "Spanish"
    }
};

Repita sin LINQ :

float[] floats = System.Array.ConvertAll(new float[16], v => 1.0f);

int[] array = new int[4]; 
array[0] = 10;
array[1] = 20;
array[2] = 30;

o

string[] week = new string[] {"Sunday","Monday","Tuesday"};

o

string[] array = { "Sunday" , "Monday" };

y en matriz multidimensional

    Dim i, j As Integer
    Dim strArr(1, 2) As String

    strArr(0, 0) = "First (0,0)"
    strArr(0, 1) = "Second (0,1)"

    strArr(1, 0) = "Third (1,0)"
    strArr(1, 1) = "Fourth (1,1)"

For Class initialization:
var page1 = new Class1();
var page2 = new Class2();
var pages = new UIViewController[] { page1, page2 };

Otra forma de crear e inicializar una matriz de objetos. Esto es similar al ejemplo que @Amol ha publicado anteriormente , excepto que este usa constructores. Una pizca de polimorfismo roció, no pude resistirme.

IUser[] userArray = new IUser[]
{
    new DummyUser("[email protected]", "Gibberish"),
    new SmartyUser("[email protected]", "Italian", "Engineer")
};

Clases para el contexto:

interface IUser
{
    string EMail { get; }       // immutable, so get only an no set
    string Language { get; }
}

public class DummyUser : IUser
{
    public DummyUser(string email, string language)
    {
        m_email = email;
        m_language = language;
    }

    private string m_email;
    public string EMail
    {
        get { return m_email; }
    }

    private string m_language;
    public string Language
    {
        get { return m_language; }
    }
}

public class SmartyUser : IUser
{
    public SmartyUser(string email, string language, string occupation)
    {
        m_email = email;
        m_language = language;
        m_occupation = occupation;
    }

    private string m_email;
    public string EMail
    {
        get { return m_email; }
    }

    private string m_language;
    public string Language
    {
        get { return m_language; }
    }

    private string m_occupation;
}

Para la clase a continuación:

public class Page
{

    private string data;

    public Page()
    {
    }

    public Page(string data)
    {
        this.Data = data;
    }

    public string Data
    {
        get
        {
            return this.data;
        }
        set
        {
            this.data = value;
        }
    }
}

Puede inicializar la matriz del objeto anterior como se muestra a continuación.

Pages = new Page[] { new Page("a string") };

Espero que esto ayude.

También puede crear matrices dinámicas, es decir, primero puede preguntar el tamaño de la matriz al usuario antes de crearla.

Console.Write("Enter size of array");
int n = Convert.ToInt16(Console.ReadLine());

int[] dynamicSizedArray= new int[n]; // Here we have created an array of size n
Console.WriteLine("Input Elements");
for(int i=0;i<n;i++)
{
     dynamicSizedArray[i] = Convert.ToInt32(Console.ReadLine());
}

Console.WriteLine("Elements of array are :");
foreach (int i in dynamicSizedArray)
{
    Console.WriteLine(i);
}
Console.ReadKey();

Solución trivial con expresiones. Tenga en cuenta que con NewArrayInit puede crear una matriz unidimensional.

NewArrayExpression expr = Expression.NewArrayInit(typeof(int), new[] { Expression.Constant(2), Expression.Constant(3) });
int[] array = Expression.Lambda<Func<int[]>>(expr).Compile()(); // compile and call callback

Solo una nota

Las siguientes matrices:

string[] array = new string[2];
string[] array2 = new string[] { "A", "B" };
string[] array3 = { "A" , "B" };
string[] array4 = new[] { "A", "B" };

Se compilará para:

string[] array = new string[2];
string[] array2 = new string[]
{
   "A",
   "B"
};
string[] array3 = new string[]
{
   "A",
   "B"
};
string[] array4 = new string[]
{
   "A",
   "B"
};