Métodos (Guia de Programação em C#)

Artigo
06/10/2015

Um método é um bloco de código que contém uma série de instruções. Um programa faz com que as instruções sejam executados chamando o método e especificando todos os argumentos necessários do método. Em C#, cada declaração executado é executada no contexto de um método. O método principal é o ponto de entrada para cada aplicativo C# e é chamado pelo common language runtime (CLR) quando o programa for iniciado.

Dica

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

Assinaturas de método

Os métodos são declarados em classe ou estrutura 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 todos os parâmetros do método. Essas partes são junto a assinatura de método.

Dica

Um tipo de retorno de um método não é parte da assinatura do método para fins de sobrecarga do método.Em o entanto, é parte da assinatura do método para determinar a compatibilidade entre um representante e que aponta para o método.

Os parâmetros do método são incluídos entre parênteses e separados por vírgulas. Os parênteses vazios indicam que o método não requer nenhum parâmetro. Essa 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 é como acessar um campo. Após o nome do objeto, adicione um período, o nome do método, e parênteses. Os argumentos são listados dentro dos parênteses, e separados por vírgulas. Os métodos da classe de Motorcycle portanto podem ser chamados 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 de método CONTRA. argumentos

A definição do método especifica os nomes e tipos de todos os parâmetros que são necessários. ao chamar o código chama o método, ele fornece os valores concretos chamados argumentos para cada parâmetro. Os argumentos devem ser compatíveis com o tipo de parâmetro mas o nome do argumento (se houver) usados no código de chamada não precisa ser o mesmo que o parâmetro chamado definiu 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;
}

Passagem por referência CONTRA. passagem por valor

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

Quando um objeto de um tipo de referência é passado ao método, uma referência ao objeto é passada. Isto é, o método não recebe o próprio objeto mas um argumento que indica o local do objeto. Se você alterar um membro objeto usando essa referência, a alteração é refletida no argumento o método de chamada, mesmo se você passar o objeto por valor.

Você cria um tipo de referência de class usando a palavra-chave, como mostra o exemplo a seguir.

public class SampleRefType
{
    public int value;
}

Agora, se você passar um objeto que é baseado em esse tipo em um método, uma referência ao objeto é passada. O exemplo passa um objeto do tipo SampleRefType para o método ModifyObject.

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;
}

O exemplo faz essencialmente a mesma coisa que o exemplo anterior que passa um argumento por valor a um método. Mas, como um tipo de referência é usado, o resultado é diferente. A alteração que é feita em ModifyObject para o campo de value de parâmetro, obj, também altera o campo de value do argumento, rt, no método de TestRefType . O método de TestRefType exibe 33 como a saída.

Para obter mais informações sobre como passar tipos de referência por valor e por referência, consulte Passando parâmetros de tipo de referência (Guia de Programação em C#) e Tipos de referência (Referência de C#).

valores de retorno

Os 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 a palavra-chave de return . Uma instrução com a palavra-chave de return seguido por um valor que corresponde ao tipo de retorno retornará o valor para o chamador do método. A palavra-chave de return também para a execução do método. Se o tipo de retorno é void, uma instrução de return sem um valor ainda é útil interromper a execução do método. Sem a palavra-chave de return , o método irá parar de executar quando atingir o final do bloco de código. Os métodos com um tipo de retorno não vago são necessários para usar a palavra-chave de return para retornar um valor. Por exemplo, esses dois métodos usam a palavra-chave de return para retornar 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 o próprio chamada de método em qualquer lugar que um valor do mesmo tipo deve ser suficiente. Você também pode atribuir o valor de retorno para uma variável. Por exemplo, os seguintes exemplos de código realizam o mesmo metas:

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 um variável local, em esse caso, result, para armazenar o valor é opcional. Pode ajudar a legibilidade do código, ou pode ser necessário se você precisa armazenar o valor original do argumento para o escopo para o método.

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

métodos de Async

Usando o recurso de async, você pode chamar métodos assíncronos sem usar retornos de chamada explícita ou manualmente dividir seu código entre vários métodos ou expressões lambda. O recurso de async foi introduzido Visual Studio 2012.

Se você marcar um método com o modificador de async , você pode usar o operador de espere no método. Quando o controle atingir uma expressão de espera no método de async, o controle retorna para o chamador, e o estado o método é suspenso até que a tarefa deve terminar. Quando a tarefa estiver concluída, a execução pode continuar no método.

Dica

Um método de async retorna para o chamador quando qualquer ele localiza o primeiro objeto esperado que ainda não está completo ou obtém ao final do método de async, qualquer surge principalmente.

Um método de async pode ter um tipo de retorno de Task, de Task, ou de vácuo. O tipo de retorno vago é basicamente usado para definir os manipuladores de eventos, onde um tipo de retorno vago é necessário. Um método de async que retorna vagos não podem ser esperado, e o chamador de um método vago- retornando não pode capturar exceções que o gera o método.

Em o exemplo, DelayAsync é um método de async que tenha um tipo de retorno de Task. DelayAsync tem uma instrução de return que retorna um número inteiro. Portanto a declaração de método de DelayAsync deve ter um tipo de retorno de Task<int>. Porque o tipo de retorno é Task<int>, a avaliação da expressão de await em DoSomethingAsync gera um inteiro como a instrução a seguir demonstra: int result = await delayTask.

O método de startButton_Click é um exemplo de um método de async que tenha um tipo de retorno de vácuo. Porque DoSomethingAsync é um método de async, a tarefa para a chamada a DoSomethingAsync deve ser esperada, porque a instrução a seguir mostra: await DoSomethingAsync();. o método de startButton_Click deve ser definido com o modificador de async porque o método tem uma expressão de await .

// using System.Diagnostics; 
// using System.Threading.Tasks; 

// This Click event is marked with the async modifier. 
private async void startButton_Click(object sender, RoutedEventArgs e)
{
    await DoSomethingAsync();
}

private async Task DoSomethingAsync()
{
    Task<int> delayTask = DelayAsync();
    int result = await delayTask;

    // The previous two statements may be combined into 
    // the following statement. 
    //int result = await DelayAsync();

    Debug.WriteLine("Result: " + result);
}

private async Task<int> DelayAsync()
{
    await Task.Delay(100);
    return 5;
}

// Output: 
//  Result: 5

Um método de async não pode declarar nenhum parâmetro de referência ou de out , mas pode chamar métodos que têm esses parâmetros.

Para obter mais informações sobre métodos de async, consulte Programação assíncrona com Async e Await (C# e Visual Basic), Fluxo de controle em programas assíncronos (C# e Visual Basic), e Tipos de retorno assíncronos (C# e Visual Basic).

Iteradores

Um iterador executa uma iteração personalizado em uma coleção, como uma lista ou uma matriz. Um iterador usa a declaração de retorno de produzir para retornar um de cada vez a cada elemento. Quando uma declaração de retorno de produzir é alcançada, o local atual no código está recordado. A execução é reiniciada de aquele local quando o iterador é chamado na próxima vez.

Você chama um iterador código do cliente usando uma instrução de foreach .

o tipo de retorno de um iterador pode ser IEnumerable, IEnumerable, IEnumerator, ou IEnumerator.

Para obter mais informações, consulte Iteradores (C# e Visual Basic).

Especificação da linguagem C#

Para obter mais informações, consulte a Especificação da linguagem C#. A especificação da linguagem é a fonte definitiva para a sintaxe e o uso de C#.