Todas las syntax posibles de inicialización de matriz

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

Estos son los métodos actuales de statement 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() Linq ToArray() en IEnumerable .

También tenga en cuenta que en las declaraciones anteriores, los dos primeros podrían reemplazar la string[] a la izquierda con var (C # 3+), ya que la información de la derecha es suficiente para inferir el tipo correcto. La tercera línea debe escribirse tal como se muestra, ya que la syntax de inicialización de matriz por sí sola no es suficiente para satisfacer las demandas del comstackdor. El cuarto también podría usar la inferencia. Entonces, si te interesa todo lo breve, 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 syntax de creación de matriz 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 del elemento de matriz se deduce 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 de la cantidad de elementos proporcionados. Esta syntax se introdujo en C # 3.0.

También hay una syntax que solo se puede usar en una statement:

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

Los elementos deben ser implícitamente convertibles al tipo de elemento. El tamaño se determina a partir de la cantidad de elementos proporcionados.

no hay una guía todo en uno

Lo remito a la especificación C # 4.0, sección 7.6.10.4 “Expresiones de creación de matriz”.

Arrays no vacíos

  • 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 comstackble. Use int[] data5 = { 1, 2, 3 } lugar.

Matrices vacías

  • var data6 = new int[0]
  • var data7 = new int[] { }
  • var data8 = new [] { } e int[] data9 = new [] { } no son comstackbles.

  • var data10 = { } no es comstackble. Use int[] data11 = { } lugar.

Como argumento de un método

Solo las expresiones que se pueden asignar con la palabra clave var 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 comstackble
  • Foo(new int[0])
  • Foo(new int[] { })
  • Foo({}) no es comstackble
 Enumerable.Repeat(String.Empty, count).ToArray() 

Creará una serie de cadenas vacías repetidas veces de ‘conteo’. En caso de que quiera inicializar una matriz con el mismo valor de elemento por defecto pero especial. Cuidado con los tipos de referencia, todos los elementos referirán el 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 null o que no sean los default ), utilice esto:

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

También por favor participe en esta discusión.

Ejemplo para crear una matriz de una clase personalizada

A continuación está la definición de la clase.

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

Así es como puedes inicializar la matriz:

 private DummyUser[] arrDummyUser = new DummyUser[] { new DummyUser{ email = "abc.xyz@email.com", language = "English" }, new DummyUser{ email = "def@email.com", language = "Spanish" } }; 
 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)" 

Repita sin LINQ :

 float[] floats = System.Array.ConvertAll(new float[16], v => 1.0f); 
 For Class initialization: var page1 = new Class1(); var page2 = new Class2(); var pages = new UIViewController[] { page1, page2 }; 

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 

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>(expr).Compile()(); // compile and call callback 

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

 IUser[] userArray = new IUser[] { new DummyUser("abc@cde.edu", "Gibberish"), new SmartyUser("pga@lna.it", "Italian", "Engineer") }; 

Clases por 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; } 
    Intereting Posts