Int [] é um tipo de referência ou um tipo de valor?

Eu sei que int é um tipo de valor, mas o que são matrizes de tipos de valor? Tipos de referência? Tipos de valor? Eu quero passar uma matriz para uma função para verificar alguma coisa. Devo apenas passar a matriz, pois passará apenas a referência, ou devo passar como ref?

Matrizes são mecanismos que permitem tratar vários itens como uma única coleção. O Microsoft® .NET Common Language Runtime (CLR) suporta matrizes unidimensionais, matrizes multidimensionais e matrizes irregulares (matrizes de matrizes). Todos os tipos de matriz são derivados implicitamente de System.Array, que é derivado de System.Object. Isso significa que todas as matrizes são sempre tipos de referência alocadas no heap gerenciado e a variável do seu aplicativo contém uma referência à matriz e não à própria matriz.

https://msdn.microsoft.com/en-us/library/bb985948.aspx

O teste mais simples para o tipo de referência versus o tipo de valor é que os tipos de referência podem ser null, mas os tipos de valor não.

Matrizes (mesmo de tipos de valor como int) são tipos de referência em C #.

http://msdn.microsoft.com/en-us/library/aa288453(VS.71).aspx :

Em C #, matrizes são realmente objetos. System.Array é o tipo base abstrato de todos os tipos de matriz.

Primeiro, quero lhe dizer que a matriz é um tipo de referência. Por quê? Eu explico dar um exemplo aqui.

Exemplo:

int val = 0; // this is a value type ok
int[] val1 = new int[20] // this is a reference type because space required to store 20 integer value that make array allocated on the heap.

Os tipos de referência também podem ser nulos, enquanto os tipos de valor não podem.

tipo de valor armazenado em Stack e tipo de referência armazenado em Heap

Você pode passar o array para funcionar usando out ou ref. Apenas os métodos de inicialização são diferentes.

Mais..

Teste para verificar se é um tipo de referência ou valor:

// we create a simple array of int
var a1 = new int[]{1,2,3};
// copy the array a1 to a2
var a2 = a1;
// modify the first element of a1
a1[0]=2;
// output the first element of a1 and a2
Console.WriteLine("a1:"+a1[0]); // 2
Console.WriteLine("a2:"+a2[0]); // 2
//**************************
// all the two variable point to the same array
// it's reference type!
//**************************

Você pode testá-lo on-line: https://dotnetfiddle.net/UWFP45

A matriz em si é um tipo de referência. Os valores dessa matriz são tipos de valor ou referência, conforme determinado pelo tipo de dados da matriz. No seu exemplo, a matriz é um tipo de referência e os valores são tipos de valores.

Todas as matrizes de dimensão única são implementadas implicitamente IList<T>, onde <T>é o tipo de dados da matriz. Você pode usar essa interface como o tipo de dados do seu parâmetro de método. Você também pode usar IEnumerable<T>para o tipo de dados. Em qualquer um dos casos (ou mesmo se você acabou de usar int[]), você não precisa passá-lo explicitamente como refparâmetro.

// A referência à matriz é passada por valor. Esta é a fonte da confusão :-) ...

        int[] test = { 1, 2, 3, 4 };

        modifContenuSansRef(test);
        Console.WriteLine(test[0]); // OK --> 99 le contenu du tableau est modifié

        modifTailleSansRef(test);
        Console.WriteLine(test.Length); // KO --> 4 La taille n'est pas modifiée

    }

    static void modifContenuSansRef(int[] t)
    {
        t[0] = 99;
    }

    static void modifTailleSansRef(int[] t)
    {
        Array.Resize(ref t, 8);
    }

As matrizes sempre são tipos de referência. Não importa que a matriz contenha um tipo de valor como int ou um tipo de referência como string. Quando você declara a matriz por exemplo

int[] integers=new int[10];

A própria variável de inteiros contém apenas referência à matriz que residirá na pilha.

Também existem muitas pessoas que mencionam que você pode diferir o tipo de valor do tipo de referência, dependendo apenas do fato de a variável ser nula ou não. Eu gostaria de mencionar que no c # atualmente os tipos de valor também podem ser nulos

por exemplo

int? integer=null

e não é uma boa maneira de identificar que o tipo é referência ou valor depende apenas do fato de a variável poder ser nula ou não.

Apenas um pouco de uma visão:

Por exemplo, intrepresenta um único número inteiro,int[] representa uma matriz de números inteiros.

Para inicializar a matriz com dimensões específicas, você pode usar a newpalavra - chave, fornecendo o tamanho entre colchetes após o nome do tipo:

//create a new array of 32 ints.
int[] integers = new int[32];

Todas as matrizes são tipos de referência e seguem a semântica de referência. Portanto, nesse código, mesmo que os elementos individuais sejam tipos de valores primitivos, a integersmatriz é um tipo de referência. Então, se você escrever mais tarde:

int[] copy = integers;

isso simplesmente atribuirá toda a cópia da variável para se referir à mesma matriz, não criará uma nova matriz.

A sintaxe da matriz do C # é flexível, permite declarar matrizes sem inicializá-las, para que a matriz possa ser dimensionada dinamicamente posteriormente no programa. Com essa técnica, você basicamente cria uma referência nula e depois aponta essa referência em um trecho de locais de memória alocado dinamicamente, solicitado com umnew palavra-chave:

int[] integers;
integers = new int[32];

Obrigado.