¿Cómo descartar explícitamente un argumento out?

Question

Estoy haciendo una llamada:

myResult = MakeMyCall(inputParams, out messages);

pero en realidad no me importan los mensajes. Si fuera un parámetro de entrada que no me importa, simplemente pasaría un valor nulo. Si fuera la devolución, no me importaba, simplemente la dejaría.

¿Hay alguna manera de hacer algo similar con un out, o necesito declarar una variable que luego ignoraré?

Answer 1

Comenzando con C # 7.0, es posible evitar predefinir parámetros e ignorarlos.

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

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

Answer 2

Debe declarar una variable que luego ignorará. Este suele ser el caso con el patrón TryParse (o TryWhatever), cuando se usa para probar la validez de la entrada del usuario (por ejemplo, ¿se puede analizar como un número?) Sin importar el valor analizado real.

Usaste la palabra " disponer " en la pregunta, que sospecho que fue desafortunada, pero si el parámetro out es de un tipo que implementa IDisposable, ciertamente debe llamar a Dispose a menos que la documentación del método indique explícitamente que recibir el valor no confiere propiedad. Sin embargo, no recuerdo haber visto nunca un método con un parámetro desechable out , así que espero que esta haya sido una elección desafortunada de palabras.

Answer 3

Lamentablemente, debe pasar algo porque se requiere el método para configurarlo. Por lo tanto, no puede enviar null porque el método, que se requiere para configurarlo, explotaría.

Un enfoque para ocultar la fealdad sería envolver el método en otro método que haga el parámetro out para usted así:

String Other_MakeMyCall(String inputParams)
{
    String messages;

    return MakeMyCall(inputParams, out messages);
}

Entonces puede llamar a Other_MakeMyCall sin tener que jugar con los parámetros out que no necesita.

Answer 4

Si la función original se declara así:

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

Puede declarar un método de extensión como este:

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

El método de extensión se comportará como una sobrecarga que hace que el parámetro out sea opcional.

Answer 5

El compilador de Visual Basic hace esto creando una variable ficticia. C # podría hacerlo, si puede convencer a Microsoft de que es una buena idea.

Answer 6

Si la clase de mensajes implementa IDisposable , no debe ignorarlo. Considere algo como el siguiente enfoque (puede que no sea sintácticamente correcto ya que no he escrito C # en mucho tiempo):

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

Una vez fuera del bloque usando , los mensajes se eliminarán automáticamente.

Answer 7

Debe pasar una variable para el parámetro out. No tiene que inicializar la variable antes de pasarla:

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

Normalmente, puede ignorar los 'mensajes' después de la llamada, a menos que sea necesario eliminar los 'mensajes' por alguna razón, como el uso de recursos limitados del sistema, en cuyo caso debe llamar a Dispose ():

messages.Dispose();

Si puede usar una cantidad significativa de memoria y va a permanecer dentro del alcance por un tiempo, probablemente debería establecerse en nulo si es un tipo de referencia o en una nueva instancia predeterminada si es un tipo de valor, entonces que el recolector de basura puede reclamar la memoria:

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

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

Answer 8

En este caso, hice un método de extensión genérico para ConcurrentDictionary que no tiene el método Eliminar o Eliminar.

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

Cuando se llama desde una instancia de ConcurrentDictionary:

ClientList.TryRemoveIgnore(client.ClientId);