Todas as possíveis sintaxes de inicialização da matriz


Respostas:


779

Estes são os métodos atuais de declaração e inicialização para uma matriz 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 existem outras técnicas para obter matrizes, como as ToArray()extensões Linq ativadas IEnumerable<T>.

Observe também que nas declarações acima, as duas primeiras podem substituir a string[]da esquerda por var(C # 3+), pois as informações à direita são suficientes para inferir o tipo apropriado. A terceira linha deve ser escrita como exibida, pois a sintaxe de inicialização do array por si só não é suficiente para satisfazer as demandas do compilador. O quarto também pode usar inferência. Portanto, se você gosta de toda a brevidade, o acima pode 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 

1
Por curiosidade, alguém poderia explicar por que a expressão de inicialização na terceira linha não pode ser usada por si só (por exemplo, passada para um método) ou atribuída a uma varvariável?
Ruben9922

1
@ Ruben9922: Pergunta interessante. Faria sentido que var x = {}não funcionasse se o inicializador de matriz pudesse produzir algo além de matrizes, mas eu não saberia o que é isso. Então eu acho que o inicializador de array é um recurso de linguagem. Se você usá-lo com new List<string> {"A", "B"}isso, também produz algo diferente.
TvdH 06/11/19

441

As sintaxes de criação da matriz 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 da matriz são inicializados com os valores padrão.

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

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

No quarto, o tipo do elemento da matriz é inferido calculando o melhor tipo, se houver um, de todos os elementos fornecidos que possuem tipos. Todos os elementos devem ser implicitamente conversíveis nesse tipo. O tamanho é determinado a partir do número de elementos fornecidos. Essa sintaxe foi introduzida no C # 3.0.

Há também uma sintaxe que pode ser usada apenas em uma declaração:

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

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

não há um guia tudo em um

Eu o refiro à especificação do C # 4.0, seção 7.6.10.4 "Expressões de criação de matrizes".


8
@BoltClock: A primeira sintaxe mencionada é uma "expressão de criação de matriz digitada implicitamente". O segundo é uma "expressão de criação de objeto anônimo". Você não lista as outras duas sintaxes semelhantes; eles são "inicializador de objetos" e "inicializador de coleção".
precisa

11
Não é exatamente a sintaxe do C #, mas não vamos esquecer (o meu favorito) Array.CreateInstance(typeof(int), 3)!
perfil completo de Jeffrey L

17
@ Jeffrey: Se estamos indo por esse caminho, começa a ficar bobo. Por exemplo "1,2,3,4".split(','),.
Brian

11
Então para arrays multidimensionais, existem notações "aninhados" gosto new int[,] { { 3, 7 }, { 103, 107 }, { 10003, 10007 }, };, e assim por diante para int[,,], int[,,,]...
Jeppe Stig Nielsen

6
@ Learning-Overthinker-Confused: Você tem dois cavalos. Você deseja saber qual é mais rápido. Você (1) corre com os cavalos ou (2) pergunta a um estranho na Internet que nunca viu os cavalos qual ele acha que é mais rápido? Corra com seus cavalos . Você quer saber qual é mais "eficiente"? Primeiro, crie um padrão mensurável para eficiência; lembre-se, a eficiência é o valor produzido por custo unitário ; portanto, defina seu valor e custo com cuidado. Em seguida, escreva o código nos dois sentidos e meça sua eficiência. Use a ciência para responder perguntas científicas, sem pedir palpites a estranhos aleatórios.
Eric Lippert

111

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 em int[] data5 = { 1, 2, 3 }vez disso.

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 em int[] data11 = { } vez disso.

Como argumento de um método

Somente expressões que podem ser atribuídas com a varpalavra - chave 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

14
Seria bom separar mais claramente as sintaxes inválidas das válidas.
jpmc26

Os exemplos apresentados estão completos? Existe algum outro caso?
Programador orientado a dinheiro

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

Criará uma matriz de cadeias vazias repetidas vezes 'count'. Caso você queira inicializar a matriz com o mesmo valor de elemento padrão ainda especial. Cuidado com os tipos de referência, todos os elementos referenciarão o mesmo objeto.


5
Sim, var arr1 = Enumerable.Repeat(new object(), 10).ToArray();você recebe 10 referências para o mesmo objeto. Para criar 10 objetos distintos, você pode usar var arr2 = Enumerable.Repeat(/* dummy: */ false, 10).Select(x => new object()).ToArray();ou semelhante.
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" }
    }
};

Como você deve usar essa estrutura? É como um dicionário?
R. Navega

1
@ R.Navega é um conjunto comum :)
grooveplex

17

Caso deseje inicializar uma matriz fixa de elementos iguais pré-inicializados ( nulldiferentes ou não default), use o seguinte:

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

Também participe desta discussão.


13

Exemplo para criar uma matriz de uma classe personalizada

Abaixo está a definição de classe.

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

É assim que você pode inicializar a matriz:

private DummyUser[] arrDummyUser = new DummyUser[]
{
    new DummyUser{
       email = "abc.xyz@email.com",
       language = "English"
    },
    new DummyUser{
       email = "def@email.com",
       language = "Spanish"
    }
};


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

5
Olá, o último bloco de exemplos parece ser o Visual Basic, a pergunta pede exemplos de c #.
precisa saber é o seguinte

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

2

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

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

Classes para o 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;
}

1

Para a turma abaixo:

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;
        }
    }
}

você pode inicializar a matriz do objeto acima como abaixo.

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

Espero que isto ajude.


0

Você também pode criar matrizes dinâmicas, ou seja, pode primeiro solicitar o tamanho da matriz ao usuário antes de criá-la.

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();

0

Solução trivial com expressões. Observe 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<Func<int[]>>(expr).Compile()(); // compile and call callback

0

Apenas uma nota

As seguintes matrizes:

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

Será compilado para:

string[] array = new string[2];
string[] array2 = new string[]
{
   "A",
   "B"
};
string[] array3 = new string[]
{
   "A",
   "B"
};
string[] array4 = new string[]
{
   "A",
   "B"
};
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.