Méthodes (guide de programmation C#)

Article
08/10/2011

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é.

Notes

Cette rubrique traite des méthodes nommées. Pour plus d'informations sur les fonctions anonymes, consultez Fonctions anonymes (Guide de programmation C#).

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.

Notes

Un type de retour d'une méthode ne fait pas partie de la signature de la méthode pour les besoins de la surcharge de méthode. Toutefois, il fait partie de la signature de la méthode lors de la détermination de la compatibilité entre un délégué et la méthode vers laquelle il pointe.

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 contreArguments

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 etPassage 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#).

Les types référence sont passés par référence. Lorsqu'un objet d'un type référence est passé à une méthode, la référence pointe vers l'objet d'origine, et non vers une copie. Les modifications apportées par le biais de cette référence seront par conséquent répercutées dans la méthode d'appel. Un type référence est créé à l'aide du mot clé class comme dans l'exemple suivant :

public class SampleRefType
{
    public int value;
}

Maintenant, si un objet qui est basé sur ce type est passé à une méthode, cet objet sera passé par référence. Par exemple :

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

Cet exemple fait essentiellement la même chose que l'exemple précédent. Mais, parce qu'un type référence est utilisé, la modification apportée par ModifyObject est apportée à l'objet qui est créé dans la méthode TestRefType. La méthode TestRefType affichera par conséquent la valeur 33.

Pour plus d'informations, consultez Passage de paramètres de type référence (Guide de programmation C#) et 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);

L'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#).

Spécification du langage C#

Pour plus d'informations, consultez 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.