Méthodes (guide de programmation C#)

Une méthode est un bloc de code qui contient une série d'instructions. Un programme provoque l'exécution des instructions en appelant la méthode et en spécifiant les arguments de méthode requis. En C#, chaque instruction exécutée est effectuée dans le contexte d'une méthode. La méthode Main est le point d'entrée pour chaque application C# ; elle est appelée par le Common Language Runtime (CLR) lorsque le programme est démarré.

Signatures de méthode

Les méthodes sont déclarées dans une classe ou un struct en spécifiant le niveau d'accès tel que public ou private, des modificateurs facultatifs tels que abstract ou sealed, la valeur de retour, le nom de la méthode et les éventuels paramètres de méthode. Ces parties forment ensemble la signature de la méthode.

Les paramètres de méthode figurent entre parenthèses et sont séparés par des virgules. Les parenthèses vides indiquent que la méthode ne nécessite pas de paramètres. Cette classe contient trois méthodes :

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

Accès aux méthodes

L'appel d'une méthode sur un objet est semblable à l'accès à un champ. Après le nom d'objet, ajoutez un point, le nom de la méthode et les parenthèses. Les arguments sont répertoriés dans les parenthèses et sont séparés par des virgules. Les méthodes de la classe Motorcycle peuvent donc être appelées comme dans l'exemple suivant :

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

Paramètres de méthode VS. des arguments

La définition de méthode spécifie les noms et types des paramètres requis. Lorsque le code appelant appelle la méthode, il fournit des valeurs concrètes appelées arguments pour chaque paramètre. Les arguments doivent être compatibles avec le type de paramètre mais le nom de l'argument (le cas échéant) utilisé dans le code appelant ne doit pas obligatoirement être identique au paramètre nommé défini dans la méthode. Par exemple :

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

Passage par référence VS. passage par valeur

Par défaut, lorsqu'un type valeur est passé à une méthode, une copie est passée plutôt que l'objet lui-même. Par conséquent, les modifications apportées à l'argument n'ont aucun effet sur la copie d'origine dans la méthode d'appel. Vous pouvez passer un type valeur par référence en utilisant le mot clé ref. Pour plus d’informations, consultez Passage de paramètres de type valeur (Guide de programmation C#). Pour obtenir une liste des types valeur intégrés, consultez Tableau des types valeur (référence C#).

Lorsqu'un objet d'un type référence est passé à une méthode, une référence à l'objet est passée. Autrement dit, la méthode reçoit pas l'objet lui-même mais un argument qui indique l'emplacement de l'objet. Si vous modifiez un membre de l'objet à l'aide de cette référence, la modification est répercutée dans l'argument de la méthode d'appel, même si vous passez l'objet par valeur.

Vous créez un type référence en utilisant le mot clé d' class , comme indiqué dans l'exemple suivant.

public class SampleRefType
{
    public int value;
}

Maintenant, si vous passez un objet basé sur ce type à une méthode, une référence à l'objet est passée. L'exemple suivant obtient un objet de type SampleRefType à la méthode 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;
}

L'exemple est essentiellement le même que l'exemple précédent car il passe un argument par valeur à une méthode. Toutefois, car un type référence est utilisé, le résultat est différent. La modification qui est effectuée dans ModifyObject au champ d' value du paramètre, obj, modifie également le champ d' value de l'argument, rt, dans la méthode d' TestRefType . La méthode d' TestRefType affiche 33 comme sortie.

Pour plus d'informations sur la façon de passer des types référence par référence ou par valeur, consultez Passage de paramètres de type référence (Guide de programmation C#) et le Types référence (référence C#).

Valeurs de retour

Les méthodes peuvent retourner une valeur à l'appelant. Si le type de retour, le type répertorié avant le nom de la méthode, n'est pas void, la méthode peut retourner la valeur à l'aide du mot clé return. Une instruction avec le mot clé return suivi d'une valeur qui correspond au type de retour retournera cette valeur à l'appelant de la méthode. Le mot clé return arrête également l'exécution de la méthode. Si le type de retour est void, une instruction return sans valeur reste utile pour arrêter l'exécution de la méthode. Sans le mot clé return, la méthode cessera son exécution lorsqu'elle atteindra la fin du bloc de code. Les méthodes avec un type de retour non void doivent utiliser le mot clé return pour retourner une valeur. Par exemple, ces deux méthodes utilisent le mot clé return pour retourner des entiers :

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

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

Pour utiliser une valeur retournée par une méthode, la méthode d'appel peut utiliser l'appel de méthode partout où une valeur du même type suffirait. Vous pouvez également assigner la valeur de retour à une variable. Par exemple, les deux exemples de code suivants produisent le même résultat :

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

Utilisation d'une variable locale, dans ce cas, result, pour stocker une valeur est facultative. Cela peut contribuer à la lisibilité du code ou peut être nécessaire si vous devez stocker la valeur d'origine de l'argument pour la portée entière de la méthode.

Pour plus d’informations, consultez return (référence C#).

Méthodes Async

À l'aide de la fonctionnalité async, vous pouvez appeler des méthodes asynchrones sans utiliser des rappels explicites ou fractionner manuellement votre code sur plusieurs méthodes ou expressions lambda. La fonctionnalité async Visual Studio 2012a été introduit.

Si vous marquez une méthode avec le modificateur d' async , vous pouvez utiliser l'opérateur d' attendez dans la méthode. Lorsque le contrôle atteint une expression d'attente dans la méthode async, le contrôle retourne à l'appelant, et la progression de la méthode est interrompue jusqu'à ce que la tâche se termine attendue. Lorsque la tâche est terminée, l'opération peut continuer dans la méthode.

Une méthode async peut avoir un type de retour d' Task, d' Task, ou de void. Le type de retour void est utilisé principalement pour définir des gestionnaires d'événements, où un type de retour void est requis. Une méthode async qui retourne void ne peut pas être attendue, et l'appel d'une méthode void- se retournante ne peut pas intercepter des exceptions que la méthode lève une.

Dans l'exemple suivant, DelayAsync est une méthode async dont le type de retour d' Task. DelayAsync a une instruction d' return qui retourne un entier. Par conséquent la déclaration de méthode d' DelayAsync doit avoir un type de retour d' Task<int>. Étant donné que le type de retour est Task<int>, l'évaluation de l'expression d' await dans DoSomethingAsync produit un entier comme l'instruction suivante montre : int result = await delayTask.

La méthode d' startButton_Click est un exemple d'une méthode async qui possède un type de retour void. Étant donné qu' DoSomethingAsync est une méthode async, la tâche de l'appel à DoSomethingAsync doit être attendue, comme l'instruction suivante : await DoSomethingAsync();. La méthode d' startButton_Click doit être définie avec le modificateur d' async parce que la méthode a une expression d' 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

Une méthode async ne peut déclarer des paramètres de référence ou de, mais elle peut appeler les méthodes qui ont de ces paramètres.

Pour plus d'informations sur les méthodes async, consultez Programmation asynchrone avec Async et Await (C# et Visual Basic), Flux de contrôle dans les programmes Async (C# et Visual Basic), et l' Types de retour Async (C# et Visual Basic).

Itérateurs

Un itérateur effectue une itération au sein d'une collection, telle qu'une liste ou un tableau. Un itérateur utilise l'instruction de retour yield pour retourner les éléments un par un. Lorsqu'une instruction de retour yield est atteinte, la position actuelle dans le code est retrouvée. L'exécution est redémarrée de cet emplacement lorsque l'itérateur s'agit de la prochaine fois.

Vous appelez un itérateur de code client à l'aide d'une instruction de foreach .

Le type de retour d'un itérateur peut être IEnumerable, IEnumerable, IEnumerator, ou IEnumerator.

Pour plus d’informations, consultez Itérateurs (C# et Visual Basic).

Spécification du langage C#

Pour plus d'informations, voir la Spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Voir aussi

Référence

Classes et structs (Guide de programmation C#)

Modificateurs d'accès (Guide de programmation C#)

Classes statiques et membres de classe statique (Guide de programmation C#)

Héritage (Guide de programmation C#)

Classes abstract et sealed et membres de classe (Guide de programmation C#)

params (référence C#)

return (référence C#)

out (référence C#)

ref (référence C#)

Passage de paramètres (Guide de programmation C#)

Concepts

Guide de programmation C#