Pasar matrices como argumentos (Guía de programación de C#)

Artículo
06/10/2015

Las matrices se pueden pasar como argumentos a los parámetros de método. Dado que las matrices son tipos de referencia, el método puede cambiar el valor de los elementos.

Pasar matrices unidimensionales como argumentos

Una matriz unidimensional inicializada se puede pasar a un método. Por ejemplo, la siguiente instrucción envía una matriz a un método de impresión.

int[] theArray = { 1, 3, 5, 7, 9 };
PrintArray(theArray);

El código siguiente muestra una implementación parcial del método de impresión.

void PrintArray(int[] arr)
{
    // Method code.
}

Puede inicializar y pasar una nueva matriz en un solo paso, como se muestra en el siguiente ejemplo.

PrintArray(new int[] { 1, 3, 5, 7, 9 });

Ejemplo

Descripción

En el ejemplo siguiente, se inicializa una matriz de cadenas y se pasa como argumento a un método PrintArray para las cadenas. El método muestra los elementos de la matriz. A continuación, se invocan los métodos ChangeArray y ChangeArrayElement para mostrar que el envío de un argumento de matriz por valor no evita que se realicen cambios en los elementos de la matriz.

Código

class ArrayClass
{
    static void PrintArray(string[] arr)
    {
        for (int i = 0; i < arr.Length; i++)
        {
            System.Console.Write(arr[i] + "{0}", i < arr.Length - 1 ? " " : "");
        }
        System.Console.WriteLine();
    }

    static void ChangeArray(string[] arr)
    {
        // The following attempt to reverse the array does not persist when 
        // the method returns, because arr is a value parameter.
        arr = (arr.Reverse()).ToArray();
        // The following statement displays Sat as the first element in the array.
        System.Console.WriteLine("arr[0] is {0} in ChangeArray.", arr[0]);
    }

    static void ChangeArrayElements(string[] arr)
    {
        // The following assignments change the value of individual array  
        // elements. 
        arr[0] = "Sat";
        arr[1] = "Fri";
        arr[2] = "Thu";
        // The following statement again displays Sat as the first element 
        // in the array arr, inside the called method.
        System.Console.WriteLine("arr[0] is {0} in ChangeArrayElements.", arr[0]);
    }

    static void Main()
    {
        // Declare and initialize an array. 
        string[] weekDays = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };

        // Pass the array as an argument to PrintArray.
        PrintArray(weekDays);

        // ChangeArray tries to change the array by assigning something new 
        // to the array in the method. 
        ChangeArray(weekDays);

        // Print the array again, to verify that it has not been changed.
        System.Console.WriteLine("Array weekDays after the call to ChangeArray:");
        PrintArray(weekDays);
        System.Console.WriteLine();

        // ChangeArrayElements assigns new values to individual array 
        // elements.
        ChangeArrayElements(weekDays);

        // The changes to individual elements persist after the method returns. 
        // Print the array, to verify that it has been changed.
        System.Console.WriteLine("Array weekDays after the call to ChangeArrayElements:");
        PrintArray(weekDays);
    }
}
// Output:  
// Sun Mon Tue Wed Thu Fri Sat 
// arr[0] is Sat in ChangeArray. 
// Array weekDays after the call to ChangeArray: 
// Sun Mon Tue Wed Thu Fri Sat 
//  
// arr[0] is Sat in ChangeArrayElements. 
// Array weekDays after the call to ChangeArrayElements: 
// Sat Fri Thu Wed Thu Fri Sat

Pasar matrices multidimensionales como argumentos

Una matriz multidimensional inicializada se pasa a un método del mismo modo que una matriz unidimensional.

int[,] theArray = { { 1, 2 }, { 2, 3 }, { 3, 4 } };
Print2DArray(theArray);

En el código siguiente se muestra una declaración parcial de un método de impresión que acepta una matriz bidimensional como argumento.

void Print2DArray(int[,] arr)
{
    // Method code.
}

Puede inicializar y pasar una nueva matriz en un solo paso, como se muestra en el siguiente ejemplo.

Print2DArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } });

Ejemplo

Descripción

En el ejemplo siguiente, se inicializa una matriz de enteros bidimensional y se pasa al método Print2DArray. El método muestra los elementos de la matriz.

Código

class ArrayClass2D
{
    static void Print2DArray(int[,] arr)
    {
        // Display the array elements. 
        for (int i = 0; i < arr.GetLength(0); i++)
        {
            for (int j = 0; j < arr.GetLength(1); j++)
            {
                System.Console.WriteLine("Element({0},{1})={2}", i, j, arr[i, j]);
            }
        }
    }
    static void Main()
    {
        // Pass the array as an argument.
        Print2DArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } });

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
    /* Output:
        Element(0,0)=1
        Element(0,1)=2
        Element(1,0)=3
        Element(1,1)=4
        Element(2,0)=5
        Element(2,1)=6
        Element(3,0)=7
        Element(3,1)=8
    */