Como descartar explicitamente um argumento fora?

Question

Eu estou fazendo uma chamada:

myResult = MakeMyCall(inputParams, out messages);

mas eu realmente não se preocupam com as mensagens. Se fosse um parâmetro de entrada Eu não me importava se eu tivesse acabado de passar em um nulo. Se fosse o retorno Eu não me importava se eu tinha acabado de deixá-lo fora.

Existe uma maneira de fazer algo semelhante com um fora, ou eu preciso para declarar uma variável que eu, então, ignorar?

Answer 1

Começando com C # 7.0, é possível evitar predeclaring os parâmetros, bem como ignorá-los.

public void PrintCoordinates(Point p)
{
    p.GetCoordinates(out int x, out int y);
    WriteLine($"({x}, {y})");
}

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

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

Answer 2

Você tem que declarar uma variável que então você vai ignorar. Isto é o mais vulgarmente o caso com o padrão TryParse (ou TryWhatever), quando ele é usado para testar a validade da entrada do utilizador (por exemplo, ela pode ser analisada como um número?) Sem se preocupar com o valor real analisado.

Você usou a palavra "dispor" na pergunta, que eu suspeito que foi apenas infeliz - mas se o parâmetro de saída é de um tipo que implementa IDisposable, certamente você deve chamar Dispose menos que a documentação método afirma explicitamente que receber o valor doesn 'propriedade conferem t. Não me lembro de alguma vez ter visto um método com um parâmetro out descartável, então eu estou esperando que isso era apenas uma escolha infeliz de palavras.

Answer 3

Infelizmente você são obrigados a passar alguma coisa, porque o método é necessário para configurá-lo. Então você não pode enviar null porque o método, sendo necessário para configurá-lo, iria explodir.

Uma abordagem para esconder a feiúra seria para embrulhar o método em outro método que faz o parâmetro out para você assim:

String Other_MakeMyCall(String inputParams)
{
    String messages;

    return MakeMyCall(inputParams, out messages);
}

Em seguida, você pode chamar Other_MakeMyCall sem ter que mexer com parâmetros out você não precisa.

Answer 4

Se a função original é declarada como este:

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

Você pode declarar um método de extensão como este:

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

O método de extensão vai se comportar como uma sobrecarga que faz com que o parâmetro opcional para fora.

Answer 5

O compilador Visual Basic faz isso criando uma variável dummy. C # pode fazê-lo, se você pode convencer Microsoft é uma boa idéia.

Answer 6

Se a classe de implementos messages IDisposable, você não deve ignorá-lo. Considere algo como a seguinte abordagem (não pode ser sintaticamente correto desde que eu não tenho escrito C # em quando):

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

Uma vez fora do bloco using, messages serão eliminados automaticamente.

Answer 7

Você deve passar uma variável para o parâmetro de saída. Você não tem que inicializar a variável antes de passá-lo:

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

Normalmente, você pode simplesmente ignorar 'mensagens' após a chamada - a menos necessidades 'mensagens' eliminação por algum motivo, como o uso de recursos de sistema limitados, caso em que você deve chamar Dispose ():

messages.Dispose();

Se ele pode usar uma quantidade significativa de memória e ele vai permanecer no escopo para um tempo, ele provavelmente deve ser definido como NULL se ele é um tipo de referência ou para uma nova instância padrão se é um tipo de valor, de modo que o coletor de lixo pode recuperar a memória:

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

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

Answer 8

Neste caso eu fiz um método de extensão genérica para ConcurrentDictionary que não tem nenhum método Eliminar ou remover.

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

Quando chamado de uma instância do ConcurrentDictionary:

ClientList.TryRemoveIgnore(client.ClientId);