Métodos anônimos e análise de código

Um método anônimo é um método que não tem nome. Métodos anônimos são usados com mais freqüência para passar um trecho de código como um parâmetro delegate.

Este tópico explica como a análise de código trata avisos e métricas que estão associadas a métodos anônimos.

Métodos anônimos declarados em um membro.

Avisos e métricas para um método anônimo que é declarado em um membro, como um método ou o acessador, estão associadas com o membro que declara o método. Elas não são associadas ao membro que chama o método.

Por exemplo, na classe seguinte, quaisquer avisos encontrados na declaração de anonymousMethod deve ser elevado contra Method1 e não Method2.

Delegate Function ADelegate(ByVal value As Integer) As Boolean
Class AClass

    Sub Method1()
        Dim anonymousMethod As ADelegate = Function(ByVal value As 
  Integer) value > 5
        Method2(anonymousMethod)
    End Sub

    Sub Method2(ByVal anonymousMethod As ADelegate)
        anonymousMethod(10)
    End Sub
End Class

delegate void Delegate();
class Class
{
    void Method1()
    {
        Delegate anonymousMethod = delegate() 
        { 
          Console.WriteLine(""); 
        }
        Method2(anonymousMethod);
    }

    void Method2(Delegate anonymousMethod)
    {
        anonymousMethod();
    }
}

Inline métodos anônimos

Avisos e métricas para um método anônimo, é declarada como uma atribuição in-line a um campo estão associadas com o construtor. Se o campo for declarado como static (Shared na Visual Basic), os avisos e métricas associadas com o construtor de classe; Caso contrário, eles são associados com o construtor de instância.

Por exemplo, na classe seguinte, quaisquer avisos encontrados na declaração de anonymousMethod1 serão gerados contra o construtor padrão gerado implicitamente da classe. Enquanto os erros encontrados em anonymousMethod2 será abatido do construtor da classe gerada implicitamente.

Delegate Function ADelegate(ByVal value As Integer) As Boolean
Class AClass
    Dim anonymousMethod1 As ADelegate = Function(ByVal value As
    Integer) value > 5
    Shared anonymousMethod2 As ADelegate = Function(ByVal value As 
    Integer) value > 5

    Sub Method1()
        anonymousMethod1(10)
        anonymousMethod2(10)
    End Sub
End Class

delegate void Delegate();
class Class
{
    Delegate anonymousMethod1 = delegate() 
    { 
       Console.WriteLine(""); 
    }

    static Delegate anonymousMethod2 = delegate() 
    { 
       Console.WriteLine(""); 
    }

    void Method()
    {
       anonymousMethod1();
       anonymousMethod2();
    }
}

Uma classe pode conter um método anônimo embutido que atribui um valor a um campo que possui vários construtores. Nesse caso, métricas e avisos estão associadas a todos os construtores, a menos que esse construtor encadeia para outro construtor na mesma classe.

Por exemplo, na classe seguinte, quaisquer avisos encontrados na declaração de anonymousMethod deve ser elevado contra Class(int) e Class(string) mas não contra Class ().

Delegate Function ADelegate(ByVal value As Integer) As Boolean
Class AClass

    Dim anonymousMethod As ADelegate = Function(ByVal value As Integer) 
    value > 5

    Sub New()
        New(CStr(Nothing))
    End Sub

    Sub New(ByVal a As Integer)
    End Sub

    Sub New(ByVal a As String)
    End Sub
End Class

delegate void Delegate();
class Class
{
    Delegate anonymousMethod = delegate() 
    { 
       Console.WriteLine(""); 
    }

    Class() : this((string)null)
    {
    }

    Class(int a)
    {
    }

    Class(string a)
    {
    }
}

Embora isso pareça inesperado, isso ocorre porque o compilador gera um método exclusivo para cada construtor que não está encadeado para outro construtor. Devido a esse comportamento, de qualquer violação ocorre em anonymousMethod deve ser suprimida separadamente. Isso também significa que se um novo construtor é introduzido, avisos anteriormente foram suprimidos contra Class(int) e Class(string) também deve ser suprimida contra o construtor new.

Você pode contornar esse problema em uma das duas maneiras. Você poderia declarar anonymousMethod em um construtor comuns que cadeia de todos os construtores. Ou você pode declará-lo em um método de inicialização é chamado de todos os construtores.

Consulte também

Conceitos

Analisando qualidade de código gerenciado usando a análise de código