Suprimindo os avisos "nunca é usado" e "nunca é atribuído a" em C #

Eu tenho um arquivo HTTPSystemDefinitions.cs no projeto C # que basicamente descreve o ISAPI do Windows mais antigo para consumo por código gerenciado.

Isso inclui o conjunto completo de Estruturas relevantes para a ISAPI, não todas ou que são consumidas por código. Na compilação, todos os membros do campo dessas estruturas estão causando um aviso como o seguinte: -

O campo de aviso 'UnionSquare.ISAPI.HTTP_FILTER_PREPROC_HEADERS.SetHeader' nunca é atribuído e sempre terá seu valor padrão nulo

ou

Aviso O campo 'UnionSquare.ISAPI.HTTP_FILTER_PREPROC_HEADERS.HttpStatus' nunca é usado

Eles podem ser desativados com #pragma warning disable? Em caso afirmativo, quais seriam os números de erro correspondentes? Se não, posso fazer mais alguma coisa? Tenha em mente que eu apenas o que fazer para este arquivo, é importante que eu receba avisos como este vindo de outros arquivos.

Editar

Estrutura de exemplo: -

struct HTTP_FILTER_PREPROC_HEADERS
{
    //
    //  For SF_NOTIFY_PREPROC_HEADERS, retrieves the specified header value.
    //  Header names should include the trailing ':'.  The special values
    //  'method', 'url' and 'version' can be used to retrieve the individual
    //  portions of the request line
    //

    internal GetHeaderDelegate GetHeader;
    internal SetHeaderDelegate SetHeader;
    internal AddHeaderDelegate AddHeader;

    UInt32  HttpStatus;               // New in 4.0, status for SEND_RESPONSE
    UInt32  dwReserved;               // New in 4.0
}

Sim, eles podem ser suprimidos.

Normalmente, me oponho a suprimir avisos, mas, neste caso, structs usados ​​para interoperabilidade requerem absolutamente que alguns campos estejam presentes, mesmo que você nunca pretenda (ou possa) usá-los, então, neste caso, acho que deve ser justificado .

Normalmente, para suprimir esses dois avisos, você consertaria o código ofensivo. O primeiro ("... nunca é usado") é geralmente um cheiro de código de sobras de versões anteriores do código. Talvez o código tenha sido excluído, mas os campos deixados para trás.

O segundo é geralmente um cheiro de código para campos usados ​​incorretamente. Por exemplo, você pode escrever incorretamente o novo valor de uma propriedade de volta na própria propriedade, nunca gravando no campo de apoio.

Para suprimir avisos de "O campo XYZ nunca é usado ", faça o seguinte:

#pragma warning disable 0169
... field declaration
#pragma warning restore 0169

Para suprimir avisos para "O campo XYZ nunca é atribuído a e sempre terá seu valor padrão XX ", faça o seguinte:

#pragma warning disable 0649
... field declaration
#pragma warning restore 0649

Para encontrar você mesmo esses números de aviso (ou seja, como eu sabia usar 0169 e 0649), faça o seguinte:

• Compile o código normalmente, isso adicionará alguns avisos à sua lista de erros no Visual Studio
• Mude para a janela Output e Build output e procure os mesmos avisos

• Copie o código de aviso de 4 dígitos da mensagem relevante, que deve ser assim:

  C: \ Dev \ VS.NET \ ConsoleApplication19 \ ConsoleApplication19 \ Program.cs (10,28): aviso CS 0649 : O campo 'ConsoleApplication19.Program.dwReserved' nunca é atribuído e sempre terá seu valor padrão 0

Advertência : de acordo com o comentário de @Jon Hanna , talvez alguns avisos sejam necessários para isso, para futuros descobridores desta pergunta e resposta.

• Em primeiro lugar, o ato de suprimir um aviso é semelhante a engolir comprimidos para dor de cabeça. Claro, às vezes pode ser a coisa certa a fazer, mas não é uma solução abrangente. Às vezes, uma dor de cabeça é um sintoma real que você não deve mascarar, o mesmo com os avisos. É sempre melhor tentar tratar os avisos corrigindo sua causa, em vez de apenas removê-los cegamente da saída do build.
• Dito isso, se você precisar suprimir um aviso, siga o padrão que descrevi acima. A primeira linha de código #pragma warning disable XYZK,, desativa o aviso para o resto do arquivo ou pelo menos até que um correspondente #pragma warning restore XYZKseja encontrado. Minimize o número de linhas em que você desativa esses avisos. O padrão acima desativa o aviso para apenas uma linha.
• Além disso, como Jon menciona, um comentário explicando por que você está fazendo isso é uma boa ideia. Desativar um aviso é definitivamente um cheiro de código quando feito sem causa, e um comentário impedirá que futuros mantenedores percam tempo se perguntando por que você fez isso, ou mesmo removendo-o e tentando consertar os avisos.

Outra "solução" para corrigir esses avisos é criar a estrutura public. Os avisos não são emitidos porque o compilador não pode saber se os campos estão ou não sendo usados ​​(atribuídos) fora do assembly.

Dito isso, os componentes de "interoperabilidade" geralmente não devem ser públicos, mas sim internalou private.

Eu pedi ao VS para gerar o esqueleto de implementação para System.ComponentModel.INotifyPropertyChangede os eventos foram implementados como campos que acionaram os avisos CS0067.

Como alternativa à solução dada na resposta aceita , converti os campos em propriedades e o aviso desapareceu .

Isso faz sentido, uma vez que a sintaxe de declaração de propriedade sugar é compilada em um campo mais os métodos getter e / ou setter (adicionar / remover no meu caso) que fazem referência ao campo. Isso satisfaz o compilador e os avisos não são gerados:

struct HTTP_FILTER_PREPROC_HEADERS
{
    //
    //  For SF_NOTIFY_PREPROC_HEADERS, retrieves the specified header value.
    //  Header names should include the trailing ':'.  The special values
    //  'method', 'url' and 'version' can be used to retrieve the individual
    //  portions of the request line
    //

    internal GetHeaderDelegate GetHeader {get;set;}
    internal SetHeaderDelegate SetHeader { get; set; }
    internal AddHeaderDelegate AddHeader { get; set; }

    UInt32 HttpStatus { get; set; }               // New in 4.0, status for SEND_RESPONSE
    UInt32 dwReserved { get; set; }               // New in 4.0
}

Os usuários de C / C ++ devem (void)var;suprimir avisos de variáveis ​​não utilizadas. Acabei de descobrir que você também pode suprimir avisos de variáveis ​​não utilizadas em C # com operadores bit a bit:

        uint test1 = 12345;
        test1 |= 0; // test1 is still 12345

        bool test2 = true;
        test2 &= false; // test2 is now false

Ambas as expressões não produzem avisos de variáveis ​​não utilizadas nos compiladores VS2010 C # 4.0 e Mono 2.10.