CA2020: Prevenir mudanças comportamentais causadas por operadores integrados de IntPtr/UIntPtr

Motivo

Esta regra é acionada quando deteta uma alteração comportamental entre o .NET 6 e o .NET 7 introduzida pelos novos operadores internos de IntPtr e UIntPtr.

Descrição da regra

Com a funcionalidade numérica IntPtr, IntPtr e UIntPtr ganharam operadores internos para conversões, operações unárias e operações binárias. Esses operadores podem lançar uma exceção quando ocorre overflow no contexto verificado ou podem não lançar exceção no contexto não verificado, em comparação com os operadores definidos pelo utilizador nas versões do .NET 6 e anteriores. Você pode encontrar essa alteração comportamental ao atualizar para o .NET 7.

Lista de APIs afetadas

Como corrigir violações

Examine seu código para determinar se a expressão sinalizada pode causar uma alteração comportamental e escolha uma maneira apropriada de corrigir o diagnóstico a partir das seguintes opções:

Opções de correção:

• Se a expressão não causar uma mudança comportamental:
  • Se o IntPtr ou tipo UIntPtr for usado como nativo int ou uint, altere o tipo para nint ou nuint.
  • Se o tipo IntPtr ou UIntPtr for usado como um ponteiro nativo, altere o tipo para o tipo de ponteiro nativo correspondente.
  • Se não for possível alterar o tipo da variável, suprima o aviso.
• Se a expressão puder causar uma mudança comportamental, envolva-a com uma instrução checked ou unchecked para preservar o comportamento anterior.

Exemplo

Violação:

using System;

public unsafe class IntPtrTest
{
    IntPtr intPtrVariable;
    long longVariable;

    void Test ()
    {
        checked
        {
            IntPtr result = intPtrVariable + 2; // Warns: Starting with .NET 7 the operator '+' will throw when overflowing in a checked context. Wrap the expression with an 'unchecked' statement to restore the .NET 6 behavior.

            result = intPtrVariable - 2; // Starting with .NET 7 the operator '-' will throw when overflowing in a checked context. Wrap the expression with an 'unchecked' statement to restore the .NET 6 behavior.

            void* voidPtrVariable = (void*)intPtrVariable; // Starting with .NET 7 the explicit conversion '(void*)IntPtr' will throw when overflowing in a checked context. Wrap the expression with an 'unchecked' statement to restore the .NET 6 behavior.

            result = (IntPtr)voidPtrVariable; // Starting with .NET 7 the explicit conversion '(IntPtr)void*' will throw when overflowing in a checked context. Wrap the expression with an 'unchecked' statement to restore the .NET 6 behavior.
        }

        intPtrVariable = (IntPtr)longVariable; // Starting with .NET 7 the explicit conversion '(IntPtr)Int64' will not throw when overflowing in an unchecked context. Wrap the expression with a 'checked' statement to restore the .NET 6 behavior.

        int a = (int)intPtrVariable; // Starting with .NET 7 the explicit conversion '(Int32)IntPtr' will not throw when overflowing in an unchecked context. Wrap the expression with a 'checked' statement to restore the .NET 6 behavior.
    }
}

Correção:

• Se a expressão não causar uma mudança comportamental e o tipo IntPtr ou UIntPtr forem usados como nativo int ou uint, altere o tipo para nint ou nuint.

using System;

public unsafe class IntPtrTest
{
    nint intPtrVariable; // type changed to nint
    long longVariable;

    void Test ()
    {
        checked
        {
            nint result = intPtrVariable + 2; // no warning

            result = intPtrVariable - 2;

            void* voidPtrVariable = (void*)intPtrVariable;

            result = (nint)voidPtrVariable;
        }

        intPtrVariable = (nint)longVariable;

        int a = (int)intPtrVariable;
    }
}

• Se a expressão puder causar uma mudança comportamental, envolva-a com uma declaração checked ou uma declaração unchecked para preservar o comportamento anterior.

using System;

public unsafe class IntPtrTest
{
    IntPtr intPtrVariable;
    long longVariable;

    void Test ()
    {
        checked
        {
            IntPtr result = unchecked(intPtrVariable + 2); // wrap with unchecked

            result = unchecked(intPtrVariable - 2);

            void* voidPtrVariable = unchecked((void*)intPtrVariable);

            result = unchecked((IntPtr)voidPtrVariable);
        }

        intPtrVariable = checked((IntPtr)longVariable); // wrap with checked

        int a = checked((int)intPtrVariable);
    }
}

Quando suprimir avisos

Se a expressão não causar uma alteração de comportamento, é seguro suprimir um aviso desta regra.

Consulte também

• Regras de fiabilidade
• recurso numérico IntPtr