Exportar (0) Imprimir
Expandir todo

Delegate (Clase)

Representa un delegado, que es una estructura de datos que hace referencia a un método estático o a una instancia de clase y a un método de instancia de dicha clase.

Espacio de nombres: System
Ensamblado: mscorlib (en mscorlib.dll)

[SerializableAttribute] 
[ClassInterfaceAttribute(ClassInterfaceType.AutoDual)] 
[ComVisibleAttribute(true)] 
public abstract class Delegate : ICloneable, ISerializable
/** @attribute SerializableAttribute() */ 
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.AutoDual) */ 
/** @attribute ComVisibleAttribute(true) */ 
public abstract class Delegate implements ICloneable, ISerializable
SerializableAttribute 
ClassInterfaceAttribute(ClassInterfaceType.AutoDual) 
ComVisibleAttribute(true) 
public abstract class Delegate implements ICloneable, ISerializable

La clase Delegate es la clase base para los tipos de delegado. No obstante, el sistema y los compiladores son los únicos que pueden derivar explícitamente a partir de la clase Delegate o de la clase MulticastDelegate. Tampoco está permitido derivar un tipo nuevo a partir de un tipo de delegado. La clase Delegate no se considera un tipo de delegado; es una clase que se utiliza para derivar tipos de delegado.

La mayoría de los lenguajes implementan una palabra clave delegate y los compiladores de dichos lenguajes pueden derivar a partir de la clase MulticastDelegate; por lo tanto, los usuarios deben emplear la palabra clave delegate que proporciona el lenguaje.

La declaración de un tipo de delegado establece un contrato que especifica la firma de uno o varios métodos. Un delegado es una instancia de un tipo de delegado que contiene referencias a:

  • Un método de instancia de un tipo y un objeto de destino asignable a ese tipo.

  • Un método de instancia de un tipo, con el parámetro this oculto expuesto en la lista de parámetros formales. Se dice que el delegado es un delegado de instancia abierto.

  • Un método estático.

  • Un método estático y un objeto de destino asignable al primer parámetro del método. Se dice que el delegado se cierra en su primer argumento.

Para obtener más información sobre el enlace de delegados, vea Delegados del sistema de tipos común y CreateDelegate(Type,Object,MethodInfo,Boolean).

NotaNota

En las versiones 1.0 y 1.1 de .NET Framework, un delegado sólo puede representar un método si la firma del método coincide exactamente con la firma que especifica el tipo de delegado. Por tanto, sólo se admiten los puntos primero y tercero de la anterior lista y, en el caso del primero, es necesaria una coincidencia exacta de tipos.

Cuando un delegado representa un método de instancia cerrado en su primer argumento (el caso más habitual), el delegado almacena una referencia al punto de entrada del método y una referencia a un objeto, el objeto de destino, que es de un tipo asignable al tipo que define el método. Cuando un delegado representa un método de instancia abierto, almacena una referencia al punto de entrada del método. La firma del delegado debe incluir el parámetro this oculto en su lista de parámetros formales; en este caso, el delegado no tiene una referencia a un objeto de destino, por lo que se debe proporcionar un objeto de destino al invocar al delegado.

Cuando un delegado representa un método estático, el delegado almacena una referencia al punto de entrada del método. Cuando un delegado representa un método estático cerrado en su primer argumento, el delegado almacena una referencia al punto de entrada del método y una referencia a un objeto de destino asignable al tipo del primer argumento del método. Al invocar al delegado, el primer argumento del método estático recibe el objeto de destino.

La lista de invocaciones de un delegado es un conjunto ordenado de delegados donde cada elemento de la lista invoca exactamente a uno de los métodos representados por el delegado. Una lista de invocaciones puede contener métodos duplicados. Durante una invocación, los métodos se llaman en el orden en que aparecen en la lista de invocaciones. Un delegado intenta invocar a todos los métodos de la lista de invocaciones; se invoca a los duplicados una vez por cada aparición en la lista de invocaciones. Los delegados son inmutables; una vez creados, la lista de invocaciones de un delegado no cambia.

Se dice que los delegados son de multidifusión y combinables, porque un delegado puede invocar uno o varios métodos y se puede utilizar para combinar operaciones.

Las operaciones de combinación, como Combine y Remove, no modifican los delegados existentes. En lugar de ello, una operación de este tipo devuelve un nuevo delegado que contiene los resultados de la operación, un delegado sin modificar o referencia de objeto null (Nothing en Visual Basic). Una operación de combinación devuelve referencia de objeto null (Nothing en Visual Basic) cuando el resultado de la operación es un delegado que no hace referencia a un método como mínimo. Una operación de combinación devuelve un delegado sin modificar cuando la operación solicitada no tiene efecto.

Si un método invocado produce una excepción, el método deja de ejecutarse, la excepción se pasa de nuevo al llamador del delegado y no se invoca al resto de los métodos de la lista de invocaciones. Aunque la excepción se detecte en el llamador, este comportamiento no cambia.

Cuando la firma de los métodos invocados por un delegado incluye un valor devuelto, el delegado devuelve el valor devuelto del último elemento de la lista de invocaciones. Cuando la firma incluye un parámetro que se pasa por referencia, el valor final del parámetro es el resultado que se obtiene después de que cada método de la lista de invocaciones se ejecute secuencialmente y actualice el valor del parámetro.

Los compiladores suministran dos métodos adicionales al delegado: BeginInvoke y EndInvoke. Para obtener más información sobre estos métodos, vea Llamar a métodos sincrónicos de forma asincrónica.

El equivalente que más se asemeja a un delegado en C o C++ es un puntero a una función. Un delegado puede representar un método estático o un método de instancia. Cuando representa un método de instancia, el delegado no sólo almacena una referencia al punto de entrada del método, sino que también almacena una referencia a la instancia de clase. A diferencia de los punteros a funciones, los delegados están orientados a objetos y presentan seguridad de tipos.

En el siguiente ejemplo se muestra la forma de definir un delegado estándar.

using System;
public class SamplesDelegate  {

   // Declares a delegate for a method that takes in an int and returns a String.
   public delegate String myMethodDelegate( int myInt );

   // Defines some methods to which the delegate can point.
   public class mySampleClass  {

      // Defines an instance method.
      public String myStringMethod ( int myInt )  {
         if ( myInt > 0 )
            return( "positive" );
         if ( myInt < 0 )
            return( "negative" );
         return ( "zero" );
      }

      // Defines a static method.
      public static String mySignMethod ( int myInt )  {
         if ( myInt > 0 )
            return( "+" );
         if ( myInt < 0 )
            return( "-" );
         return ( "" );
      }
   }

   public static void Main()  {

      // Creates one delegate for each method.
      mySampleClass mySC = new mySampleClass();
      myMethodDelegate myD1 = new myMethodDelegate( mySC.myStringMethod );
      myMethodDelegate myD2 = new myMethodDelegate( mySampleClass.mySignMethod );

      // Invokes the delegates.
      Console.WriteLine( "{0} is {1}; use the sign \"{2}\".", 5, myD1( 5 ), myD2( 5 ) );
      Console.WriteLine( "{0} is {1}; use the sign \"{2}\".", -3, myD1( -3 ), myD2( -3 ) );
      Console.WriteLine( "{0} is {1}; use the sign \"{2}\".", 0, myD1( 0 ), myD2( 0 ) );
   }

}


/*
This code produces the following output:
 
5 is positive; use the sign "+".
-3 is negative; use the sign "-".
0 is zero; use the sign "".
*/ 


import System.*;

public class SamplesDelegate
{
    /** @delegate 
     */
    // Declares a delegate for a method that takes in an int and returns
    // a String.
    public delegate String MyMethodDelegate(int myInt);

    // Defines some methods to which the delegate can point.
    public static class MySampleClass
    {
        // Defines an instance method.
        public String MyStringMethod(int myInt)
        {
            if (myInt > 0)  {
                return "positive";
            }
            if (myInt < 0) {
                return "negative";
            }
            return "zero";
        } //myStringMethod

        // Defines a static method.
        public static String MySignMethod(int myInt)
        {
            if (myInt > 0) {
                return "+";
            }
            if (myInt < 0) {
                return "-";
            }
            return "";
        } //MySignMethod
    } //MySampleClass

    public static void main(String[] args)
    {
        // Creates one delegate for each method.
        MySampleClass mySC = new MySampleClass();
        MyMethodDelegate myD1 = new MyMethodDelegate(mySC.MyStringMethod);
        MyMethodDelegate myD2 = new MyMethodDelegate(MySampleClass.MySignMethod);
        // Invokes the delegates.
        Console.WriteLine("{0} is {1}; use the sign \"{2}\".", 
            (Int32)(5), System.Convert.ToString(myD1.Invoke(5)), 
            System.Convert.ToString(myD2.Invoke(5)));
        Console.WriteLine("{0} is {1}; use the sign \"{2}\".",
            System.Convert.ToString(-3), System.Convert.ToString(myD1.Invoke(-3)),
            System.Convert.ToString(myD2.Invoke(-3)));
        Console.WriteLine("{0} is {1}; use the sign \"{2}\".", (Int32)(0),
            System.Convert.ToString(myD1.Invoke(0)), System.Convert.ToString(
            myD2.Invoke(0)));
    } //main
} //SamplesDelegate 

/*
This code produces the following output:
 
5 is positive; use the sign "+".
-3 is negative; use the sign "-".
0 is zero; use the sign "".
*/


Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 2.0, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft