Anonyme Methoden und Codeanalyse

Aktualisiert: November 2007

Eine anonyme Methode ist einfach eine Methode ohne Namen. Anonyme Methoden werden am häufigsten verwendet, um einen Codeblock als Delegatparameter zu übergeben.

In diesem Thema wird erläutert, wie Warnungen und Metriken in Zusammenhang mit anonymen Methoden von der Codeanalyse behandelt werden.

Innerhalb eines Members deklarierte anonyme Methoden

Warnungen und Metriken für eine anonyme Methode, die in einem Member deklariert ist, z. B. als Methode oder Accessor, sind mit dem Member verknüpft, durch den die Methode deklariert wird. Mit dem Member, der die Methode aufruft, sind sie nicht verknüpft.

Beispiel

Beschreibung

In der folgenden Klasse sollte beispielsweise jede Warnung in der Deklaration von anonymousMethod für Method1 und nicht für Method2 ausgelöst werden.

Code

Imports System

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

using System;

delegate void Delegate();

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

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

Anonyme Inlinemethoden

Warnungen und Metriken für eine anonyme Methode, die als Inlinezuweisung für ein Feld deklariert sind, sind mit dem Konstruktor verknüpft. Wenn das Feld als static (Shared in Visual Basic) deklariert ist, sind Warnungen und Metrikdaten mit dem Klassenkonstruktor verknüpft, andernfalls sind sie mit dem Instanzenkonstruktor verknüpft.

Beispiel

Beschreibung

In der folgenden Klasse sollte beispielsweise jede Warnung in der Deklaration von anonymousMethod1 für den implizit generierten Standardkonstruktor von Class ausgelöst werden. Warnungen in anonymousMethod2 werden jedoch auf den implizit generierten Klassenkonstruktor angewendet.

Code

Imports System

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

using System;

namespace Sample
{
    delegate void Delegate();
    class Class2
    {
        Delegate anonymousMethod1 = delegate()
        {
            Console.WriteLine("");
        };

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

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

Eine Klasse könnte beispielsweise eine anonyme Inlinemethode enthalten, durch die einem Feld, das über mehrere Konstruktoren verfügt, ein Wert zugewiesen wird. In diesem Fall sind Warnungen und Metriken mit allen Konstruktoren verknüpft, sofern der Konstruktor nicht mit einem anderen Konstruktor in derselben Klasse verknüpft ist.

Beispiel

Beschreibung

In der folgenden Klasse sollte beispielsweise jede Warnung in der Deklaration von anonymousMethod für Class(int) und Class(string), aber nicht für Class() ausgelöst werden.

Code

Imports System

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

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

    Sub New()
    End Sub

    Sub New(ByVal a As Integer)
    End Sub

    Sub New(ByVal a As String)
    End Sub

End Class

using System;

delegate void Delegate();

class Class
{
    Delegate anonymousMethod = delegate()
    {
        Console.WriteLine("");
    };
    Class()
        : this((string)null)
    {
    }

    Class(int a)
    {
    }

    Class(string a)
    {
    }
}

Obwohl dieses Verhalten vielleicht unerwartet ist, tritt es auf, weil der Compiler eine eindeutige Methode für jeden Konstruktor ausgibt, der nicht mit einem anderen Konstruktor verkettet ist. Aufgrund dieses Verhaltens muss eine Verletzung, die innerhalb von anonymousMethod auftritt, getrennt unterdrückt werden. Dies bedeutet auch, dass Warnungen, die zuvor für Class(int) und Class(string) unterdrückt wurden, bei Einführung eines neuen Konstruktors auch für den neuen Konstruktor unterdrückt werden müssen.

Sie können dieses Problem auf zwei Weisen umgehen. Sie könnten anonymousMethod in einem allgemeinen Konstruktor deklarieren, durch den alle Konstruktoren verkettet werden. Alternativ können Sie die Methode in einer Initialisierungsmethode deklarieren, die von allen Konstruktoren aufgerufen wird.

Siehe auch

Weitere Ressourcen

Erkennen und Korrigieren von Fehlern in verwaltetem Code