Todas as syntaxs de boot de matriz possíveis

Quais são todas as syntaxs de boot de matriz que são possíveis com c #?

Estes são os methods atuais de declaração e boot de um array simples.

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 

Observe que outras técnicas de obtenção de matrizes existem, como as extensões Linq ToArray() em IEnumerable .

Observe também que nas declarações acima, as duas primeiras poderiam replace a string[] à esquerda com var (C # 3+), já que as informações à direita são suficientes para inferir o tipo apropriado. A terceira linha deve ser escrita como exibida, já que a syntax de boot do array sozinha não é suficiente para satisfazer as demandas do compilador. O quarto também poderia usar inferência. Então, se você está em toda a brevidade, o acima poderia ser escrito 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 

As syntaxs de criação de array em C # que são expressões são:

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

No primeiro, o tamanho pode ser qualquer valor integral não negativo e os elementos do array são inicializados com os valores padrão.

No segundo, o tamanho deve ser uma constante e o número de elementos dados deve corresponder. Deve haver uma conversão implícita dos elementos fornecidos para o tipo de elemento de matriz fornecido.

No terceiro, os elementos devem ser implicitamente conversíveis para o tipo de elemento, e o tamanho é determinado a partir do número de elementos fornecidos.

Na quarta, o tipo do elemento da matriz é inferido ao computar o melhor tipo, se houver, de todos os elementos dados que possuem tipos. Todos os elementos devem ser implicitamente conversíveis para esse tipo. O tamanho é determinado pelo número de elementos fornecidos. Essa syntax foi introduzida no C # 3.0.

Há também uma syntax que só pode ser usada em uma declaração:

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

Os elementos devem ser implicitamente conversíveis no tipo de elemento. O tamanho é determinado pelo número de elementos fornecidos.

não há um guia completo

Eu o encaminho para a especificação C # 4.0, seção 7.6.10.4 “Expressões de Criação de Matriz”.

Matrizes não vazias

  • 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 } não é compilável. Use int[] data5 = { 1, 2, 3 } lugar.

Matrizes vazias

  • var data6 = new int[0]
  • var data7 = new int[] { }
  • var data8 = new [] { } e int[] data9 = new [] { } não são compiláveis.

  • var data10 = { } não é compilável. Use int[] data11 = { } .

Como um argumento de um método

Somente expressões que podem ser designadas com a palavra-chave var podem ser passadas como argumentos.

  • Foo(new int[2])
  • Foo(new int[2] { 1, 2 })
  • Foo(new int[] { 1, 2 })
  • Foo(new[] { 1, 2 })
  • Foo({ 1, 2 }) não é compilável
  • Foo(new int[0])
  • Foo(new int[] { })
  • Foo({}) não é compilável
 Enumerable.Repeat(String.Empty, count).ToArray() 

Irá criar um array de strings vazias repetidas vezes ‘count’. Caso você deseje inicializar o array com o mesmo valor de elemento padrão especial. Cuidado com os tipos de referência, todos os elementos irão se referir ao mesmo object.

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

Caso você queira inicializar uma matriz fixa de elementos iguais (não null ou diferentes do default ) pré-inicializados, use isto:

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

Por favor, também participe desta discussão.

Exemplo para criar uma matriz de uma class personalizada

Abaixo está a definição da class.

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

É assim que você pode inicializar o array:

 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; 

ou

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

ou

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

e em multidimensional array

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

Repetir sem o 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 }; 

Você também pode criar matrizes dinâmicas, ou seja, você pode primeiro perguntar o tamanho da matriz do usuário antes de criá-lo.

 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 

Solução trivial com expressões. Note que com NewArrayInit você pode criar apenas uma 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 

Outra maneira de criar e inicializar uma matriz de objects. Isso é semelhante ao exemplo que @Amol postou acima , exceto que este usa construtores. Uma pitada de polymorphism espalhado, eu não pude resistir.

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

Classes para 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