Argumentos in C#

A definição do método especifica os nomes e tipos de quaisquer parâmetros obrigatórios. Quando o código de chamada chama o método, ele fornece valores concretos, chamados argumentos, para cada parâmetro. Com isso podemos dizer que argumentos são os valores passado ao método.

Mostrando em exemplos.

Argumentos nomeados

Este tipo de argumento te livra da necessidade de lembrar a ordem dos parâmetros de um método. Cada argumento pode ser especificado pelo seu nome no momento em que for passado.

O método a seguir recebe como parâmetros o nome e sobrenome e exibe no console uma saudação. Neste caso os Argumentos são o nome do personagem “John McClane”

Exemplo:

using System;
namespace MethodArguments
{
    public class Program
    {
        public static void Main()
        {
            var fName = "John";
            var lName = "McClane";

            // => last name as first argument
            var greeting1 = Greeting(lastName: lName, firstName: fName);
            Console.WriteLine(greeting1);

            // => first name as first argument
            var greeting2 = Greeting(firstName: fName, lastName: lName);
            Console.WriteLine(greeting2);
        }
        public static string Greeting(string firstName, string lastName)
        {
            return "Hello, " + firstName + " " + lastName;
        }
    }
}
/*This will print
Hello, John McClane
Hello, John McClane
 */

Argumentos opcionais

Quando um método é definido é possível especificar um valor padrão para os parâmetros que são opcionais. É importante deixar claro que os parâmetros opcionais devem sempre vir após os parâmetros obrigatórios e se for fornecido um argumento para qualquer um de uma sucessão de parâmetros opcionais, deverá também fornecer argumentos para todos os parâmetros opcionais anteriores.

Cada parâmetro opcional tem um valor padrão como parte de sua definição. Se nenhum argumento é enviado para esse parâmetro, o valor padrão é usado.

Exemplo:

using System;
namespace MethodArguments
{
    public class Program
    {
		public static void Main()
		{
			var fName = "John";
			var lName = "McClane";
			
			var greeting1 = Greeting(lName, fName);
			Console.WriteLine(greeting1);

			var nGreeding = "Good night";
			var greeting2 = Greeting(fName, lName, nGreeding);
			Console.WriteLine(greeting2);
		}
		
		/// <summary>
		/// The greeding is optional. 
		/// </summary>
		/// <param name="firstName"></param>
		/// <param name="lastName"></param>
		/// <param name="greeding"></param>
		/// <returns></returns>
		public static string Greeting(string firstName, string lastName, string greeding = "Good morning")
		{
			return greeding + " " + firstName + " " + lastName;
		}
	}
}
/*This will print
Good morning McClane John
Good night John McClane
 */

Argumentos passados por referência ref

Argumentos passados por referência, copia o endereço de memória. Dentro do método o endereço é usado para acessar o valor do argumento. Isso significa que qualquer mudança feita no valor, afeta o argumento.

O efeito de passar por referência é que qualquer alteração no argumento do método chamado será aplicado ao valor da variável.

Para passar o parâmetro por referência use a palavra “ref” na chamada e na assinatura do método.

Exemplo

using System;
namespace MethodArguments
{
    public class Program
    {
        public static void Main()
        {
            var name = "John McClane";
            Console.WriteLine(name);
            // => The 'Greeting'' function is going to alter the value of the name
            Greeting(ref name);
            Console.WriteLine(name);
        }
        public static void Greeting(ref string name)
        {
            // => Altering the value od name here alter the value in the 'main' function
            name = "Good morning" + ", " + name;
        }
    }
}
/*This will print
John McClane
Good morning, John McClane
 */

Argumentos passados por referência out

Argumentos passados por Output são similares ao de referência, exceto que eles transferem dados para fora do método ao invés de aceitar dados na entrada.

Este parâmetro é definido usando a palavra ‘out‘ na assinatura do método.

Variáveis passadas como ‘out‘ não precisam ser inicializadas antes de serem passadas em uma chamada de método. No entanto, o método que foi chamado deve necessariamente atribuir um valor antes que seja retornado.

Exemplo:

using System;
namespace MethodArguments
{
    public class Program
    {
        public static void Main()
        {
            string fName;
            string lName;
            Greeting(out fName, out lName);
            Console.WriteLine(fName + lName);
        }
        /// <summary>
        /// This method is required to assign a value before the method returns
        /// </summary>
        /// <param name="firstName"></param>
        /// <param name="lastName"></param>
        public static void Greeting(out string firstName, out string lastName)
        {
            firstName = "Hello, John";
            lastName = " McClane.";
        }
    }
}
/*This will print
Hello, John McClane.
*/			

Métodos com número variável de argumentos

Usando a palavra-chave ‘params‘, você pode especificar um parâmetro do método que aceita um número variável de argumentos. O tipo de parâmetro deve ser uma matriz unidimensional.

Argumentos marcados com a palavra-chave ‘params‘ pode ser processada se na chamada enviarmos uma matriz fortemente tipada ou uma lista de itens delimitada por vírgulas.

using System;
namespace MethodArguments
{
    public class Program
    {
        public static void Main()
        {
            string fName = "John";
            string lName = "McClane";
            Console.WriteLine(Greeting(fName, lName));
            Console.WriteLine(Greeting(new[] { fName, lName }));
        }
        /// <summary>
        /// This method has been defined to take a parameter array of string.
        /// </summary>
        public static string Greeting(params string[] values)
        {
            return "Hello, " + values[0] + " " + values[1];
        }
    }
}
/*This will print
Hello, John McClane
Hello, John McClane
*/

Qualquer dúvida ou dicas, entre em contato: leandrolt@gmail.com

Leave a Reply

Your email address will not be published. Required fields are marked *