Arguments optionnels de sortie / référence C # 4.0

C # 4.0 autorise-t-il des arguments facultatifs outou ref?

Comme déjà mentionné, ce n'est tout simplement pas autorisé et je pense que c'est très logique. Cependant, pour ajouter plus de détails, voici une citation de la spécification C # 4.0 , section 21.1:

Les paramètres formels des constructeurs, méthodes, indexeurs et types délégués peuvent être déclarés facultatifs:

fixe paramètres:
    attributs _opt paramètre modificateur _opt de type identifiant par défaut argument _opt
par défaut argument:
    = expression

• Un paramètre fixe avec un argument par défaut est un paramètre facultatif , tandis qu'un paramètre fixe sans argument par défaut est un paramètre obligatoire .
• Un paramètre obligatoire ne peut pas apparaître après un paramètre facultatif dans une liste de paramètres formels .
• Un paramètre refou outne peut pas avoir d' argument par défaut .

Non.

Une solution de contournement consiste à surcharger une autre méthode qui n'a pas de paramètres out / ref et qui appelle simplement votre méthode actuelle.

public bool SomeMethod(out string input)
{
    ...
}

// new overload
public bool SomeMethod()
{
    string temp;
    return SomeMethod(out temp);
}

Mise à jour: si vous avez C # 7.0 , vous pouvez simplifier:

// new overload
public bool SomeMethod()
{
    return SomeMethod(out _);    // declare out as an inline discard variable
}

(Merci @Oskar / @Reiner de l'avoir signalé.)

Non, mais une autre excellente alternative consiste à faire en sorte que la méthode utilise une classe de modèle générique pour les paramètres facultatifs comme suit:

public class OptionalOut<Type>
{
    public Type Result { get; set; }
}

Ensuite, vous pouvez l'utiliser comme suit:

public string foo(string value, OptionalOut<int> outResult = null)
{
    // .. do something

    if (outResult != null) {
        outResult.Result = 100;
    }

    return value;
}

public void bar ()
{
    string str = "bar";

    string result;
    OptionalOut<int> optional = new OptionalOut<int> ();

    // example: call without the optional out parameter
    result = foo (str);
    Console.WriteLine ("Output was {0} with no optional value used", result);

    // example: call it with optional parameter
    result = foo (str, optional);
    Console.WriteLine ("Output was {0} with optional value of {1}", result, optional.Result);

    // example: call it with named optional parameter
    foo (str, outResult: optional);
    Console.WriteLine ("Output was {0} with optional value of {1}", result, optional.Result);
}

Il existe en fait un moyen de le faire qui est autorisé par C #. Cela revient au C ++, et viole plutôt la belle structure orientée objet de C #.

UTILISEZ CETTE MÉTHODE AVEC ATTENTION!

Voici la façon dont vous déclarez et écrivez votre fonction avec un paramètre facultatif:

unsafe public void OptionalOutParameter(int* pOutParam = null)
{
    int lInteger = 5;
    // If the parameter is NULL, the caller doesn't care about this value.
    if (pOutParam != null) 
    { 
        // If it isn't null, the caller has provided the address of an integer.
        *pOutParam = lInteger; // Dereference the pointer and assign the return value.
    }
}

Appelez ensuite la fonction comme ceci:

unsafe { OptionalOutParameter(); } // does nothing
int MyInteger = 0;
unsafe { OptionalOutParameter(&MyInteger); } // pass in the address of MyInteger.

Pour que cela soit compilé, vous devrez activer le code non sécurisé dans les options du projet. C'est une solution vraiment hacky qui ne devrait généralement pas être utilisée, mais si vous avez une décision étrange, mystérieuse et mystérieuse inspirée par la gestion, vous avez VRAIMENT besoin d'un paramètre de sortie facultatif en C #, cela vous permettra de faire exactement cela.

ICYMI: Inclus dans les nouvelles fonctionnalités de C # 7.0 énumérées ici , "discards" est désormais autorisé en tant que paramètres de sortie sous la forme d'un _, pour vous permettre d'ignorer les paramètres qui ne vous intéressent pas:

p.GetCoordinates(out var x, out _); // I only care about x

PS si vous êtes également confondu avec la partie "out var x", lisez également la nouvelle fonctionnalité sur "Out Variables" sur le lien.

Non, mais vous pouvez utiliser un délégué (par exemple Action) comme alternative.

Inspiré en partie par la réponse de Robin R face à une situation où je pensais que je voulais un paramètre de sortie facultatif, j'ai plutôt utilisé un Actiondélégué. J'ai emprunté son exemple de code à modifier pour l'utiliser Action<int>afin de montrer les différences et les similitudes:

public string foo(string value, Action<int> outResult = null)
{
    // .. do something

    outResult?.Invoke(100);

    return value;
}

public void bar ()
{
    string str = "bar";

    string result;
    int optional = 0;

    // example: call without the optional out parameter
    result = foo (str);
    Console.WriteLine ("Output was {0} with no optional value used", result);

    // example: call it with optional parameter
    result = foo (str, x => optional = x);
    Console.WriteLine ("Output was {0} with optional value of {1}", result, optional);

    // example: call it with named optional parameter
    foo (str, outResult: x => optional = x);
    Console.WriteLine ("Output was {0} with optional value of {1}", result, optional);
}

Cela a l'avantage que la variable facultative apparaît dans la source comme un entier normal (le compilateur l'enveloppe dans une classe de fermeture, plutôt que nous l'enveloppons explicitement dans une classe définie par l'utilisateur).

La variable a besoin d'une initialisation explicite car le compilateur ne peut pas supposer que le Actionsera appelé avant la fin de l'appel de fonction.

Il ne convient pas à tous les cas d'utilisation, mais a bien fonctionné pour mon cas d'utilisation réel (une fonction qui fournit des données pour un test unitaire et où un nouveau test unitaire devait accéder à un état interne non présent dans la valeur de retour).

Utilisez une méthode surchargée sans le paramètre out pour appeler celle avec le paramètre out pour C # 6.0 et inférieur. Je ne sais pas pourquoi un C # 7.0 pour .NET Core est même la bonne réponse pour ce fil quand il a été spécifiquement demandé si C # 4.0 peut avoir un paramètre de sortie facultatif. La réponse est non!

Et comme ça?

public bool OptionalOutParamMethod([Optional] ref string pOutParam)
{
    return true;
}

Vous devez toujours passer une valeur au paramètre à partir de C #, mais c'est un paramètre ref facultatif.

void foo(ref int? n)
{
    return null;
}