Methods (C# Programming Guide)

Artigo
08/04/2011

A método é um bloco de código que contém uma série de instruções. Um programa faz com que as instruções a serem executadas por chamando o método e especificar qualquer necessários argumentos do método. Em C#, todas instruções são executadas por métodos. O método Main é o ponto de entrada para cada aplicativo C# e ele é chamado pelo CLR (Common Languege Runtime) quando o programa é iniciado.

Observação
Este tópico discute métodos nomeados. Para obter mais informações sobre funções anônimas, consulte Funções anônimas (guia de programação de C#).

Assinaturas de método

Métodos declarados em uma classe ou struct , especificando o nível de acesso, como public ou private, modificadores opcionais, como abstract ou sealed, o valor de retorno, o nome do método e quaisquer parâmetros de método. Essas partes juntos são o assinatura do método.

Observação
Um tipo de retorno de um método não é parte da assinatura do método para fins de sobrecarga de método. No entanto, ele é parte da assinatura do método ao determinar a compatibilidade entre um delegate e o método que ele aponta.

Os parâmetros do método são colocados entre parênteses e são separados por vírgulas. Parênteses vazios indicam que o método requer sem parâmetros. No exemplo abaixo a classe contém três métodos:

abstract class Motorcycle
{
    // Anyone can call this.
    public void StartEngine() {/* Method statements here */ }

    // Only derived classes can call this.
    protected void AddGas(int gallons) { /* Method statements here */ }

    // Derived classes can override the base class implementation.
    public virtual int Drive(int miles, int speed) { /* Method statements here */ return 1; }

    // Derived classes must implement this.
    public abstract double GetTopSpeed(); 
}

Acesso de método

Chamar um método em um objeto é semelhante a acessar um campo. Após o nome do objeto, adcione um período, o nome do método e parênteses. Argumentos são listados dentro dos parênteses e são separados por vírgulas. Os métodos de Motorcycle classe, portanto, pode ser chamado como no exemplo a seguir:

class TestMotorcycle : Motorcycle
{

    public override double GetTopSpeed()
    {
        return 108.4;
    }

    static void Main()
    {

        TestMotorcycle moto = new TestMotorcycle();

        moto.StartEngine();
        moto.AddGas(15);
        moto.Drive(5, 20);
        double speed = moto.GetTopSpeed();
        Console.WriteLine("My top speed is {0}", speed);            
    }
}

Parâmetros do método vs.Argumentos

A definição do método Especifica os nomes e tipos de qualquer parâmetros de que são necessários. Ao chamar o código chama o método, ele fornece valores de concretos chamados argumentos para cada parâmetro. Os argumentos devem ser compatíveis com o tipo de parâmetro, mas o nome de argumento (se houver) usado no código de chamada não precisa ser o mesmo parâmetro denominado definido no método. Por exemplo:

public void Caller()
{
    int numA = 4;
    // Call with an int variable.
    int productA = Square(numA);

    int numB = 32;
    // Call with another int variable.
    int productB = Square(numB);

    // Call with an integer literal.
    int productC = Square(12);

    // Call with an expression that evaulates to int.
    productC = Square(productA * 3);
}

int Square(int i)
{
    // Store input argument in a local variable.
    int input = i;
    return input * input;
}

Passando por referência vs.Passagem por valor

Por padrão, quando um tipo de valor é passado para um método, uma cópia é passada em vez do próprio objeto. Portanto, as alterações para o argumento não têm efeito na cópia do original no método de chamada. Você pode passar um tipo de valor por referência usando a palavra-chave ref. Para obter mais informações, consulte Passando parâmetros deTipo (C# guia de programação) para o Valor-. Para obter uma lista dos tipos de valor interno, consulte Valor Tabela de tipos (referência de C#).

Rtipos de eference são passados por referência. Quando um objeto de um tipo de referência é passado para um método, os pontos de referência ao objeto original, não é uma cópia. As alterações feitas através dessa referência, portanto, serão refletidas no método de chamada. Um tipo de referência é criado usando o class palavra-chave, como no exemplo a seguir:

public class SampleRefType
{
    public int value;
}

Agora, se um objeto que se baseia a esse tipo é passado para um método, o objeto será passado por referência. Por exemplo:

public static void TestRefType()
{
    SampleRefType rt = new SampleRefType();
    rt.value = 44;
    ModifyObject(rt);
    Console.WriteLine(rt.value);
}
static void ModifyObject(SampleRefType obj)
{
    obj.value = 33;
}

Essencialmente, este exemplo faz a mesma coisa que o exemplo anterior. Mas, como um tipo de referência é usado, a modificação feita por ModifyObject é feita para o objeto que é criado a TestRefType método. O TestRefType método portanto exibirá o valor 33.

Para obter mais informações, consulte Passando parâmetros deTipo (guia de programação de C#) a referência- e Reference Types (C# Reference).

Valores de retorno

Métodos podem retornar um valor para o chamador. Se o tipo de retorno, o tipo listado antes do nome do método, não é void, o método pode retornar o valor usando o return palavra-chave. Uma instrução com o return seguido de um valor que corresponde ao tipo de retorno de palavra-chave retornará o valor para o chamador do método. O return palavra-chave também interrompe a execução do método. Se o tipo de retorno é void, um return a instrução sem um valor ainda é útil para parar a execução do método. Sem o return palavra-chave, o método irá parar execução quando atingir o final do bloco de código. Métodos com um não-void retornam tipo são necessários para usar o return palavra-chave para retornar um valor. Por exemplo, esses dois métodos é usar o return palavra-chave para retornar os números inteiros:

class SimpleMath
{
    public int AddTwoNumbers(int number1, int number2)
    {
        return number1 + number2;
    }

    public int SquareANumber(int number)
    {
        return number * number;
    }
}

Para usar um valor retornado de um método, o método de chamada pode usar a chamada do método próprio em qualquer lugar que um valor do mesmo tipo seria suficiente. Você também pode atribuir o valor de retorno a uma variável. Por exemplo, os exemplos de dois código a seguir realizando o mesmo objetivo:

int result = obj.AddTwoNumbers(1, 2);
result = obj.SquareANumber(result);
// The result is 9.
Console.WriteLine(result);

result = obj.SquareANumber(obj.AddTwoNumbers(1, 2));
// The result is 9.
Console.WriteLine(result);

Usando uma variável local, nesse caso, result, para armazenar um valor é opcional. Ele pode ajudar a legibilidade do código, ou pode ser necessário se você precisar armazenar o valor original do argumento para todo o escopo do método.

Para obter mais informações, consulte retornar (referência de C#).