Todas las sintaxis de inicialización de matriz posibles

Respuestas:

779

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 
Anthony Pegram
fuente
1
Por curiosidad, ¿podría alguien explicar por qué la expresión de inicialización en la tercera línea no se puede usar sola (por ejemplo, pasar a un método) o asignarse a una varvariable?
Ruben9922
1
@ Ruben9922: Pregunta interesante. Tendría sentido que var x = {}no funcione si el inicializador de matriz podría producir algo más que matrices, pero no sabría qué es eso. Así que supongo que el inicializador de matriz es una característica del lenguaje. Si lo usa con new List<string> {"A", "B"}él, también produce algo diferente.
TvdH
442

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".

Eric Lippert
fuente
8
@BoltClock: la primera sintaxis que menciona es una "expresión de creación de matriz escrita implícitamente". El segundo es una "expresión de creación de objeto anónimo". No enumera las otras dos sintaxis similares; son "inicializador de objeto" y "inicializador de colección".
Eric Lippert
11
No es exactamente la "sintaxis" de C #, ¡pero no lo olvidemos (mi favorito personal) Array.CreateInstance(typeof(int), 3)!
Jeffrey L Whitledge
17
@ Jeffrey: Si vamos por ese camino, comienza a ponerse tonto. Ej "1,2,3,4".split(',').
Brian
11
Luego de matrices multidimensionales, existen notaciones "anidados" les gusta new int[,] { { 3, 7 }, { 103, 107 }, { 10003, 10007 }, };, y así sucesivamente para int[,,], int[,,,], ...
Jeppe Stig Nielsen
66
@ Learning-Overthinker-Confused: tienes dos caballos. Desea saber cuál es más rápido. ¿(1) compite con los caballos, o (2) le pregunta a un extraño en Internet que nunca ha visto a los caballos cuál cree que es más rápido? Compite con tus caballos . ¿Quieres saber cuál es más "eficiente"? Primero cree un estándar medible para la eficiencia; recuerde, la eficiencia es el valor producido por costo unitario , por lo tanto, defina su valor y costo con cuidado. Luego escriba el código en ambos sentidos y mida su eficiencia. Usa la ciencia para responder preguntas científicas, no preguntes a extraños al azar por conjeturas.
Eric Lippert
111

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
besa mi axila
fuente
14
Sería bueno separar más claramente las sintaxis inválidas de las válidas.
jpmc26
¿Están completos los ejemplos dados? ¿Hay algún otro caso?
Programador orientado al dinero el
49
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.

Atomosk
fuente
55
Sí, var arr1 = Enumerable.Repeat(new object(), 10).ToArray();obtienes 10 referencias al mismo objeto. Para crear 10 objetos distintos, puede usar var arr2 = Enumerable.Repeat(/* dummy: */ false, 10).Select(x => new object()).ToArray();o similar.
Jeppe Stig Nielsen
20
var contacts = new[]
{
    new 
    {
        Name = " Eugene Zabokritski",
        PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
    },
    new 
    {
        Name = " Hanying Feng",
        PhoneNumbers = new[] { "650-555-0199" }
    }
};
Nahid Camalli
fuente
¿Cómo se supone que debes usar esta estructura? ¿Es como un diccionario?
R. Navega
1
@ R.Navega es una serie ordinaria :)
grooveplex
17

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.

Shimmy Weitzhandler
fuente
13

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"
    }
};
Amol
fuente
7

Repita sin LINQ :

float[] floats = System.Array.ConvertAll(new float[16], v => 1.0f);
Nick Shalimov
fuente
6
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)"
Brad Larson
fuente
55
Hola, el último bloque de ejemplos parece ser Visual Basic, la pregunta pide ejemplos de c #.
Alex KeySmith
4
For Class initialization:
var page1 = new Class1();
var page2 = new Class2();
var pages = new UIViewController[] { page1, page2 };
Sanjay Shrivastava
fuente
2

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;
}
Nick Alexeev
fuente
1

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.

pmh
fuente
0

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();
Pushpendra7974
fuente
0

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
inseguroPtr
fuente
0

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"
};
Yousha Aleayoub
fuente