Comment écarter explicitement un argument sortant?

Question

Je passe un appel:

myResult = MakeMyCall(inputParams, out messages);

mais je ne me soucie pas vraiment des messages. Si c'était un paramètre d'entrée qui ne m'intéressait pas, je passerais simplement un null. Si c'était le retour dont je me fichais, je le laisserais simplement.

Y a-t-il un moyen de faire quelque chose de similaire avec un out ou dois-je déclarer une variable que j'ignorerai alors?

Answer 1

À partir de C # 7.0, il est possible d'éviter de pré-déclarer des paramètres et de les ignorer.

public void PrintCoordinates(Point p)
{
    p.GetCoordinates(out int x, out int y);
    WriteLine(<*>quot;({x}, {y})");
}

public void PrintXCoordinate(Point p)
{
    p.GetCoordinates(out int x, out _); // I only care about x
    WriteLine(<*>quot;{x}");
}

Source: https : //blogs.msdn.microsoft.com/dotnet/2017/03/09/new-features-in-c-7-0/

Answer 2

Vous devez déclarer une variable que vous ignorerez ensuite. C’est le cas le plus fréquent avec le modèle TryParse (ou TryW Whatever), lorsqu’il est utilisé pour tester la validité des entrées utilisateur (par exemple, peut-il être analysé sous forme de nombre?) Sans se soucier de la valeur réellement analysée.

Vous avez utilisé le mot "disposer". dans la question, ce qui, je le soupçonne, était simplement regrettable - mais si le paramètre out est d'un type implémentant IDisposable, vous devez certainement appeler Dispose à moins que la documentation de la méthode n'indique explicitement que la réception de la valeur ne confère pas la propriété. Cependant, je ne me souviens pas d’avoir jamais vu une méthode avec un paramètre out à usage unique, donc j’espère que c’est un choix de mots malchanceux.

Answer 3

Malheureusement, vous devez passer quelque chose car la méthode est nécessaire pour le définir. Donc, vous ne pouvez pas envoyer null car la méthode, obligée de la définir, exploserait.

Une approche pour masquer la laideur consiste à envelopper la méthode dans une autre méthode faisant le paramètre out pour vous comme si:

String Other_MakeMyCall(String inputParams)
{
    String messages;

    return MakeMyCall(inputParams, out messages);
}

Vous pouvez ensuite appeler Other_MakeMyCall sans devoir manipuler les paramètres out dont vous n'avez pas besoin.

Answer 4

Si la fonction d'origine est déclarée comme ceci:

class C
{
    public Result MakeMyCall(Object arg, out List<String> messages);
}

Vous pouvez déclarer une méthode d'extension comme celle-ci:

static class CExtension
{
    public static Result MakeMyCall(this C obj, Object arg)
    {
        List<String> unused;
        return obj.MakeMyCall(arg, out unused);
    }
}

La méthode d'extension se comportera comme une surcharge qui rend le paramètre out facultatif.

Answer 5

Pour ce faire, le compilateur Visual Basic crée une variable factice. C # pourrait le faire, si vous pouvez convaincre Microsoft que c'est une bonne idée.

Answer 6

Si la classe de messages implémente IDisposable , vous ne devez pas l'ignorer. Considérez quelque chose comme l’approche suivante (la syntaxe n’est peut-être pas correcte car je n’ai pas écrit C # depuis un moment):

using (FooClass messages) {
    myResult = MakeMyCall(inputParams, messages);
}

Une fois hors du bloc utilisant le bloc , les messages seront automatiquement supprimés.

Answer 7

Vous devez transmettre une variable pour le paramètre out. Il n'est pas nécessaire d'initialiser la variable avant de la transmettre:

MyMessagesType messages;
myResult = MakeMyCall(inputParams, out messages); 

En règle générale, vous pouvez simplement ignorer les "messages" après l'appel - sauf si les "messages" doivent être éliminés pour une raison quelconque, telle que l'utilisation de ressources système limitées, auquel cas vous devez appeler Dispose ():

messages.Dispose();

S'il peut utiliser une quantité importante de mémoire et qu'il reste dans la portée pendant un certain temps, il doit probablement être défini sur null s'il s'agit d'un type de référence ou sur une nouvelle instance par défaut s'il s'agit d'un type de valeur. que le ramasse-miettes peut récupérer la mémoire:

messages = null; // Allow GC to reclaim memory for reference type.

messages = new MyMessageType(); // Allow GC to reclaim memory for value type.

Answer 8

Dans ce cas, j'ai créé une méthode d'extension générique pour ConcurrentDictionary sans méthode de suppression ou de suppression.

//Remove item from list and ignore reference to removed item
public static void TryRemoveIgnore<K,T>(this ConcurrentDictionary<K,T> dictionary, K key)
{
    T CompletelyIgnored;
    dictionary.TryRemove(key, out CompletelyIgnored);
}

Appelé à partir d'une instance de ConcurrentDictionary:

ClientList.TryRemoveIgnore(client.ClientId);