Olá pessoal. Estou aqui para falar um pouco sobre Parameter Modifiers.
No dia a dia do projeto nós temos a necessidade de criar métodos que recebem diversos parâmetros. Diferente de outras linguagens, o C# fornece um conjunto de parameter modifiers que controla como os argumentos serão passados para este método. Podemos considerar que temos 4 parameter modifier :
1. Nenhum – Se o parâmetro foi passado simplesmente pelo seu nome, o compilador considera que este tenha sido passado por valor.(ou seja, o método chamador recebe uma cópia do dado original).
2. out
3. params
4. ref
Quando nós criamos uma função que recebe dois parâmetros inteiros, eles são passados por valor. Isto significa que, caso na função criada eu modifique os valores destes parâmetros, o valor original dele não será alterado. Para exemplificar, crie uma função static que receba dois inteiros como parâmetros e retorno um outro inteiro, que será a soma deles. Em seguida, no método Main(), crie duas variáveis inteiras, assumindo um valor qualquer e imprima estas 2 variáveis antes de chamar a função soma, e depois de chamar a função. O seu código deve estar igual ao abaixo:
static void Main(string[] args)
{
int a, b, soma;
a = 1;
b = 2;
Console.WriteLine("Valor de a : {0}\nValor de b : {1}", a, b);
soma = SomaParameterDefault(a, b);
Console.WriteLine("Valor da soma : {0}", soma);
Console.WriteLine("Valor de a : {0}\nValor de b : {1}", a, b);
Console.ReadKey();
}
public static int SomaParameterDefault(int a, int b)
{
int soma = a + b;
//Vamos mudar os valores das variáveis recebidas como parâmetros.
a = 20;
b = 10;
return soma;
}
Veja que os valores das variáveis não foram alteradas na função Main().
Vamos entender agora o parameter modifier out.
Um parâmetro “out” significa que este valor será “retornado” para a função original. Ele pode ser passado para a função como “null”, mas dentro da função esta variável tem que ser assinada com algum valor, caso contrário o compilador exibe uma mensagem de erro. O interessante deste parameter modifier, é que você pode passar vários parâmetros “out”, o que seria praticamente a mesma coisa de dizer que esta função retorna vários valores.
Crie uma nova função que também realiza a soma de dois números inteiros. Veja que antes de você colocar uma atribuição para a variável “out” o visual studio já apresenta um erro, veja na imagem :
Bem, a sua nova função deve ficar que nem a função abaixo :
public static int SomaParameterDefault(int a, int b)
{
int soma = a + b;
//Vamos mudar os valores das variáveis recebidas como parâmetros.
a = 20;
b = 10;
return soma;
}
public static void SomaParameterOut(int a, int b, out int soma)
{
soma = a + b;
}
Mude o código da função Main() para conferir o resultado :
static void Main(string[] args)
{
int a, b, somaDefault, somaOut;
a = 1;
b = 2;
Console.WriteLine("/////Parameter Modifier Default/////");
Console.WriteLine("/////Valores Iniciais : a = 1, b = 2./////");
Console.WriteLine("Valor de a : {0}\nValor de b : {1}", a, b);
somaDefault = SomaParameterDefault(a, b);
Console.WriteLine("Valor da soma : {0}", somaDefault);
Console.WriteLine("Valor de a : {0}\nValor de b : {1}", a, b);
Console.ReadKey();
Console.Clear();
Console.WriteLine("/////Parameter Modifier Out/////");
Console.WriteLine("/////Valores Iniciais : a = 5, b = 10./////");
a = 5;
b = 10;
Console.WriteLine("Valor de a : {0}\nValor de b : {1}", a, b);
SomaParameterOut(a, b, out somaOut);
Console.WriteLine("Valor da soma : {0}", somaOut);
Console.WriteLine("Valor de a : {0}\nValor de b : {1}", a, b);
Console.ReadKey();
}
Repare que nesta nova função, que usa o parameter modifier OUT, nenhum valor é retornado, e mesmo assim a variável somaOut é preenchida com valor da soma de a e b.
Agora vamos ver o parameter modifier REF. Se você leu os meus posts anteriores, já sabe o que significa passar um parâmetro por referencia. Para você passar um parâmetro “ref”, necessitamos assinar o objeto com algum valor antes de chamar a função. Ou seja, ref é praticamente o contrário do out. Enquanto o “out” requer que você assine o objeto dentro da função, o “ref” requer que você assine o objeto antes de chamar a função.
Sua nova função deverá ser assim :
public static void SomaParameterRef(int a, int b, ref int soma)
{
//Vamos apenas atribuir o valor para a variável soma.
soma = a + b;
}
Agora vamos inserir o seguinte código no final da função Main() :
Console.Clear();
Console.WriteLine("/////Parameter Modifier Ref/////");
Console.WriteLine("/////Valores Iniciais : a = 50, b = 30./////");
a = 50;
b = 30;
somaRef = 0;
Console.WriteLine("Valor de a : {0}\nValor de b : {1}", a, b);
SomaParameterRef(a, b, ref somaRef);
Console.WriteLine("Valor da soma : {0}", somaRef);
Console.WriteLine("Valor de a : {0}\nValor de b : {1}", a, b);
Console.ReadKey();
Veja que nós temos que assinar o número inteiro somaRef(lembre-se de declarar esta variável no início da função main). Experimente tirar a atribuição (somaRef = 0), e veja que o compilador vai apresentar um erro.
Bem, agora vamos ao parameter modifier “params”. Este é bem interessante.
Este parameter modifier permite que você crie um método que recebe um conjunto de parâmetros do mesmo tipo, como se fosse um array. Ou seja, se você quiser realizar a soma entre 2 números, você chama a função passando dois parâmetros. Se quiser somar 5 números, você passa 5 parâmetros. Está um pouco confuso? Então vamos para a prática.
Crie uma nova função conforme listado abaixo :
public static int SomaParameterParams(params int[] values)
{
int soma = 0;
for (int i = 0; i < values.Length; i++)
soma += values[i];
return soma;
}
Repare na declaração dos parâmetros recebidos. Ele declara que vai receber um array de números inteiros. Seria o mesmo do que dizer : “Me envie uma quantidade qualquer de números inteiros e eu te retornarei a soma deles”. Agora vamos criar a parte do código que chama esta função. Insira ao final da função Main(), o seguinte código :
Console.Clear();
Console.WriteLine("/////Parameter Modifier Params/////");
Console.WriteLine("/////Valores Iniciais : a = 5000, b = 1000, c=3000./////");
a = 5000;
b = 1000;
int c = 3000;
int somaParams;
Console.WriteLine("Valor de a : {0}\nValor de b : {1}\nValor de c : {2}", a, b,c);
somaParams = SomaParameterParams(a, b, c);
Console.WriteLine("Valor da soma : {0}", somaParams);
Console.WriteLine("Valor de a : {0}\nValor de b : {1}\nValor de c : {2}", a, b, c);
Console.ReadKey();
Repare que quando declaramos a função, falamos que ela receberia um array de inteiros. Mas quando chamamos a função no método Main, estamos passando 3 números inteiros. Para isto existe o parameter modifier Params. Ele junta os 3 números inteiros passados como parâmetros e monta um array de inteiro. Assim nós poderíamos passar uma quantidade x de parâmetros para a função, que ela reconheceria como um array da mesma forma.
Bem, espero que tenham gostado dessa “jogada”. Os parameters modifiers são muito importante no dia a dia do projeto. Temos que saber qual usar na hora certa e a definição deles, para não termos problemas.
Fiquem com Deus, e até a próxima.
