Métodos anónimos y análisis de código

Actualización: noviembre 2007

Un método anónimo es simplemente un método que no tiene ningún nombre. Los métodos anónimos se utilizan con más frecuencia para pasar un bloque de código como parámetro delegado.

En este tema se explica el modo en que el análisis de código controla las advertencias y las métricas que están asociadas a los métodos anónimos.

Métodos anónimos declarados dentro de un miembro

Las advertencias y las métricas para un método anónimo declarado en un miembro, ya sea como método o como descriptor de acceso, se asocian al miembro que declara el método. No se asocian con el miembro que llama al método.

Código de

Descripción

Por ejemplo, en la clase siguiente, las advertencias que se encuentren en la declaración de anonymousMethod, se deberían generar para el Method1 y no para el Method2.

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

Métodos anónimos insertados

Las advertencias y métricas para un método anónimo declaradas como una asignación insertada en un campo están asociadas al constructor. Si el campo se declara como static (Shared en Visual Basic), las advertencias y métricas estarán asociadas al constructor de clase; de lo contrario, estarían asociados al constructor de instancia.

Código de

Descripción

Por ejemplo, en la clase siguiente, cualquier advertencia hallada en la declaración de anonymousMethod1, se generarán para el constructor predeterminado de Class generado implícitamente. Mientras que aquéllas halladas dentro de anonymousMethod2, se aplicarán al constructor de clase generado implícitamente.

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

Una clase podría contener un método anónimo insertado que asigna un valor a un campo que tiene varios constructores. En este caso, las advertencias y métricas están asociadas a todos los constructores a menos que un constructor se encadene a otro en la misma clase.

Código de

Descripción

Por ejemplo, en la clase siguiente, cualquier advertencia que se encuentre en la declaración de anonymousMethod, se debería generar para Class(int) y Class(string), pero no para Class().

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)
    {
    }
}

A pesar de que esto puede resultar inesperado, se produce debido a que el compilador da como resultado un método único para cada constructor que no se encadena a otro constructor. Debido a este comportamiento, cualquier infracción que se produce dentro de anonymousMethod, se debe suprimir de forma independiente. Esto también significa que si se introduce un nuevo constructor, las advertencias previamente suprimidas para Class(int) y Class(string) también se deben suprimir para el nuevo constructor.

Existen dos formas de solucionar este problema. Podría declarar anonymousMethod en un constructor común con el que se encadenen todos los constructores. O podría declararlo en un método de inicialización al que llaman todos los constructores.

Vea también

Otros recursos

Detectar y corregir defectos de código administrado