Passando parâmetros de tipo de referência (guia de programação do C#)

Artigo
02/25/2013

Uma variável de um tipo de referência não contém seus dados diretamente. Ele contém uma referência a seus dados.Quando você passa um parâmetro de tipo de referência por valor, é possível alterar os dados apontados por referência, como, por exemplo, o valor de um membro da classe.No entanto, você não pode alterar o valor da referência propriamente dito; ou seja, você não pode usar a mesma referência alocar memória para uma nova classe e ainda persistem fora do bloco.Para isso, passe o parâmetro usando o ref ou check-out palavra-chave.Para simplificar, os exemplos seguintes usam ref.

Tipos de referência de passagem por valor

O exemplo a seguir demonstra a passar um parâmetro de tipo de referência, arr, por valor, para um método, Change.Porque o parâmetro é uma referência a arr, é possível alterar os valores dos elementos de matriz.No entanto, a tentativa de reatribuir o parâmetro para um local de memória diferentes só funciona dentro do método e não afeta a variável original, arr.

class PassingRefByVal 
{
    static void Change(int[] pArray)
    {
        pArray[0] = 888;  // This change affects the original element.
        pArray = new int[5] {-3, -1, -2, -3, -4};   // This change is local.
        System.Console.WriteLine("Inside the method, the first element is: {0}", pArray[0]);
    }

    static void Main() 
    {
        int[] arr = {1, 4, 5};
        System.Console.WriteLine("Inside Main, before calling the method, the first element is: {0}", arr [0]);

        Change(arr);
        System.Console.WriteLine("Inside Main, after calling the method, the first element is: {0}", arr [0]);
    }
}
/* Output:
    Inside Main, before calling the method, the first element is: 1
    Inside the method, the first element is: -3
    Inside Main, after calling the method, the first element is: 888
*/

No exemplo anterior, a matriz, arr, que é um tipo de referência é passado para o método sem o ref parâmetro.Nesse caso, uma cópia da referência, que aponta para arr, é passado para o método.A saída mostra que é possível para o método alterar o conteúdo de um elemento de matriz, nesse caso, de 1 para 888.No entanto, alocar uma nova parte da memória usando o nova operador dentro a Change método torna a variável pArray fazer referência a uma nova matriz.Portanto, quaisquer alterações depois que isso não afetará a matriz original, arr, que é criado dentro de Main.Na verdade, duas matrizes são criadas neste exemplo, um interno Main e um dentro do Change método.

Tipos de referência de passagem por referência

O exemplo a seguir é o mesmo do exemplo anterior, exceto que o ref palavra-chave é adicionada ao cabeçalho do método e chamada.Quaisquer alterações que ocorrem no método afetam a variável original no programa de chamada.

class PassingRefByRef 
{
    static void Change(ref int[] pArray)
    {
        // Both of the following changes will affect the original variables:
        pArray[0] = 888;
        pArray = new int[5] {-3, -1, -2, -3, -4};
        System.Console.WriteLine("Inside the method, the first element is: {0}", pArray[0]);
    }

    static void Main() 
    {
        int[] arr = {1, 4, 5};
        System.Console.WriteLine("Inside Main, before calling the method, the first element is: {0}", arr[0]);

        Change(ref arr);
        System.Console.WriteLine("Inside Main, after calling the method, the first element is: {0}", arr[0]);
    }
}
/* Output:
    Inside Main, before calling the method, the first element is: 1
    Inside the method, the first element is: -3
    Inside Main, after calling the method, the first element is: -3
*/

Todas as alterações que ocorrem dentro do método afetam a matriz original em Main.Na verdade, a matriz original é realocada em usando o new operador.Assim, depois de chamar o Change método, qualquer referência aos arr aponta para a matriz de cinco elementos, o que é criada na Change método.

Trocando duas seqüências de caracteres

Troca de seqüências de caracteres é um bom exemplo de passar os parâmetros de tipo de referência por referência.No exemplo, duas seqüências de caracteres, str1 e str2, são inicializados em Main e passado para o SwapStrings o método como parâmetros modificado pela ref palavra-chave.As duas seqüências são trocadas dentro do método e interior Main também.

 class SwappingStrings
 {
     static void SwapStrings(ref string s1, ref string s2)
     // The string parameter is passed by reference.
     // Any changes on parameters will affect the original variables.
     {
         string temp = s1;
         s1 = s2;
         s2 = temp;
         System.Console.WriteLine("Inside the method: {0} {1}", s1, s2);
     }

     static void Main()
     {
         string str1 = "John";
         string str2 = "Smith";
         System.Console.WriteLine("Inside Main, before swapping: {0} {1}", str1, str2);

         SwapStrings(ref str1, ref str2);   // Passing strings by reference
         System.Console.WriteLine("Inside Main, after swapping: {0} {1}", str1, str2);
     }
 }
 /* Output:
     Inside Main, before swapping: John Smith
     Inside the method: Smith John
     Inside Main, after swapping: Smith John
*/

Neste exemplo, os parâmetros precisam ser passados por referência para afetar as variáveis no programa de chamada.Se você remover o ref palavra-chave do cabeçalho do método e a chamada do método, nenhuma alteração ocorrerá no programa de chamada.

Para obter mais informações sobre seqüências de caracteres, consulte seqüência de caracteres.