¿Es int [] un tipo de referencia o un tipo de valor?

Sé que un int es un tipo de valor, pero ¿qué son las matrices de tipos de valor? Tipos de referencia Tipos de valor? Quiero pasar una matriz a una función para verificar algo. ¿Debo pasar la matriz, ya que solo pasará la referencia de ella, o debería pasarla como referencia?

Las matrices son mecanismos que le permiten tratar varios elementos como una sola colección. Microsoft® .NET Common Language Runtime (CLR) admite matrices unidimensionales, matrices multidimensionales y matrices irregulares (matrices de matrices). Todos los tipos de matriz se derivan implícitamente de System.Array, que se deriva de System.Object. Esto significa que todas las matrices son siempre tipos de referencia que se asignan en el montón administrado, y la variable de su aplicación contiene una referencia a la matriz y no a la matriz misma.

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

La prueba más simple para el tipo de referencia frente al tipo de valor es que los tipos de referencia pueden ser null, pero los tipos de valores no.

Las matrices (incluso de tipos de valor como int) son tipos de referencia en C #.

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

En C #, las matrices son en realidad objetos. System.Array es el tipo base abstracto de todos los tipos de matriz.

Primero quiero decirte que Array es un tipo de referencia. ¿Por qué? Les explico lanzar un ejemplo por aquí.

Ejemplo:

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.

También los tipos de referencia pueden ser nulos, mientras que los tipos de valores no pueden.

tipo de valor almacenado en la pila y tipo de referencia almacenado en el montón

Puede pasar la matriz a la función usando o ref. Solo los métodos de inicialización son diferentes.

más..

Pruebe para verificar si es una referencia o un tipo de 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!
//**************************

Puede probarlo en línea: https://dotnetfiddle.net/UWFP45

La matriz en sí es un tipo de referencia. Los valores de esa matriz son valores o tipos de referencia determinados por el tipo de datos de la matriz. En su ejemplo, la matriz es un tipo de referencia y los valores son tipos de valores.

Todos los arreglos unidimensionales implementan implícitamente IList<T> , donde <T>está el tipo de datos del arreglo. En su lugar, puede usar esa interfaz como el tipo de datos de su parámetro de método. También podría usar IEnumerable<T>para el tipo de datos. En cualquier caso (o incluso si solo lo usa int[]) no debería necesitar pasarlo explícitamente como refparámetro.

// La referencia a la matriz se pasa por valor. Esta es la fuente de la confusión :-) ...

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

Las matrices siempre son tipos de referencia. No importa que la matriz contenga un tipo de valor como int o un tipo de referencia como una cadena. Cuando declara la matriz, por ejemplo

int[] integers=new int[10];

La variable entera en sí misma solo contiene referencias a la matriz que residirá en el montón.

También hay muchas personas que mencionan que podría diferir el tipo de valor del tipo de referencia, solo depende del hecho de que la variable podría ser nula o no. Me gustaría mencionar que en c # los tipos de valores actuales también pueden ser nulos

por ejemplo

int? integer=null

y no es una buena manera de identificar que el tipo es referencia o valor solo depende de que la variable de hecho pueda ser nula o no.

Solo un poco de una idea:

Por ejemplo, intrepresenta un solo entero, int[]representa una matriz de enteros.

Para inicializar la matriz con dimensiones específicas, puede usar la newpalabra clave, dando el tamaño entre corchetes después del nombre del tipo:

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

Todas las matrices son tipos de referencia y siguen la semántica de referencia. Por lo tanto, en este código, aunque los elementos individuales son tipos de valores primitivos, la integersmatriz es un tipo de referencia. Entonces si luego escribes:

int[] copy = integers;

esto simplemente asignará la copia variable completa para referirse a la misma matriz, no creará una nueva matriz.

La sintaxis de matriz de C # es flexible, le permite declarar matrices sin inicializarlas para que la matriz se pueda dimensionar dinámicamente más adelante en el programa. Con esta técnica, básicamente está creando una referencia nula y luego apuntando esa referencia a un tramo de ubicaciones de memoria asignadas dinámicamente solicitadas con una newpalabra clave:

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

Gracias.