Delegate Osztály

Definíció

Névtér:: System

Szerelvények:: mscorlib.dll, System.Runtime.dll

Szerelvények:: netstandard.dll, System.Runtime.dll

Szerelvény:: System.Runtime.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Forrás:: Delegate.cs

Forrás:: Delegate.cs

Forrás:: Delegate.cs

Forrás:: Delegate.cs

Forrás:: Delegate.cs

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Egy delegáltat jelöl, amely egy statikus metódusra vagy egy osztálypéldányra és az osztály példánymetódusára hivatkozó adatstruktúra.

public ref class Delegate abstract

public ref class Delegate abstract : ICloneable, System::Runtime::Serialization::ISerializable

public abstract class Delegate

public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable

[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable

type Delegate = class

type Delegate = class
    interface ICloneable
    interface ISerializable

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
type Delegate = class
    interface ICloneable
    interface ISerializable

[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Delegate = class
    interface ICloneable
    interface ISerializable

Public MustInherit Class Delegate

Public MustInherit Class Delegate
Implements ICloneable, ISerializable

Öröklődés: Object
Delegate

Származtatott: Microsoft.Aspnet.Snapin.DialogProc

Microsoft.Aspnet.Snapin.PropSheetPageProc

Microsoft.Extensions.Caching.Memory.PostEvictionDelegate

Microsoft.Extensions.DependencyInjection.ObjectFactory

Microsoft.Extensions.DependencyInjection.ObjectFactory<T>

Tovább…

Attribútumok: ClassInterfaceAttribute SerializableAttribute ComVisibleAttribute

Megvalósítás: ICloneable ISerializable

Példák

Ez a szakasz két példakódot tartalmaz. Az első példa a metódus túlterhelésével létrehozható két típusú delegáltat mutatja be: amelyek példánymetódusokhoz rendelhetők és amelyek statikus metódusokhoz társíthatók.

A második példakód a kompatibilis paramétertípusokat és a visszatérési típusokat mutatja be.

1. példa

Az alábbi példakód bemutatja, hogy a delegált kétféleképpen hozható létre a CreateDelegate metódus ezen túlterhelése segítségével.

Note

A CreateDelegate metódusnak két túlterhelése van, amelyek meghatároznak egy MethodInfo-et, de nem rendelkeznek első argumentummal; a funkciójuk ugyanaz, azzal a különbséggel, hogy az egyik lehetővé teszi annak megadását, hogy sikertelen kötés esetén dobja-e a hibát, míg a másik mindig automatikusan dob hiba esetén. Ez a példakód mindkét túlterhelést használja.

A példa deklarál egy C osztályt egy statikus metódussal (M2), egy példánymetódussal (M1), és két delegált típust: D1 egy C példányt és egy karakterláncot vesz át, míg D2 egy karakterláncot vesz át.

Egy Example nevű másodosztály tartalmazza a meghatalmazottakat létrehozó kódot.

A D1példánymetódushoz létrejön egy M1típusú delegált, amely egy nyitott példánymetódust képvisel. A delegált meghívásakor egy példányt kell átadni.
A D2típusú delegált, amely egy nyitott statikus metódust jelöl, létrejön a statikus M2metódushoz.

using System;
using System.Reflection;

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
//
public delegate void D1(C c, string s);
public delegate void D2(string s);
public delegate void D3();

// A sample class with an instance method and a static method.
//
public class C
{
    private int id;
    public C(int id) { this.id = id; }

    public void M1(string s) =>
        Console.WriteLine($"Instance method M1 on C:  id = {this.id}, s = {s}");

    public static void M2(string s)
    {
        Console.WriteLine($"Static method M2 on C:  s = {s}");
    }
}

public class Example2
{
    public static void Main()
    {
        C c1 = new C(42);

        // Get a MethodInfo for each method.
        //
        MethodInfo mi1 = typeof(C).GetMethod("M1",
            BindingFlags.Public | BindingFlags.Instance);
        MethodInfo mi2 = typeof(C).GetMethod("M2",
            BindingFlags.Public | BindingFlags.Static);

        D1 d1;
        D2 d2;
        D3 d3;

        Console.WriteLine("\nAn instance method closed over C.");
        // In this case, the delegate and the
        // method must have the same list of argument types; use
        // delegate type D2 with instance method M1.
        //
        Delegate test =
            Delegate.CreateDelegate(typeof(D2), c1, mi1, false);

        // Because false was specified for throwOnBindFailure
        // in the call to CreateDelegate, the variable 'test'
        // contains null if the method fails to bind (for
        // example, if mi1 happened to represent a method of
        // some class other than C).
        //
        if (test != null)
        {
            d2 = (D2)test;

            // The same instance of C is used every time the
            // delegate is invoked.
            d2("Hello, World!");
            d2("Hi, Mom!");
        }

        Console.WriteLine("\nAn open instance method.");
        // In this case, the delegate has one more
        // argument than the instance method; this argument comes
        // at the beginning, and represents the hidden instance
        // argument of the instance method. Use delegate type D1
        // with instance method M1.
        //
        d1 = (D1)Delegate.CreateDelegate(typeof(D1), null, mi1);

        // An instance of C must be passed in each time the
        // delegate is invoked.
        //
        d1(c1, "Hello, World!");
        d1(new C(5280), "Hi, Mom!");

        Console.WriteLine("\nAn open static method.");
        // In this case, the delegate and the method must
        // have the same list of argument types; use delegate type
        // D2 with static method M2.
        //
        d2 = (D2)Delegate.CreateDelegate(typeof(D2), null, mi2);

        // No instances of C are involved, because this is a static
        // method.
        //
        d2("Hello, World!");
        d2("Hi, Mom!");

        Console.WriteLine("\nA static method closed over the first argument (String).");
        // The delegate must omit the first argument of the method.
        // A string is passed as the firstArgument parameter, and
        // the delegate is bound to this string. Use delegate type
        // D3 with static method M2.
        //
        d3 = (D3)Delegate.CreateDelegate(typeof(D3),
            "Hello, World!", mi2);

        // Each time the delegate is invoked, the same string is
        // used.
        d3();
    }
}

/* This code example produces the following output:

An instance method closed over C.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 42, s = Hi, Mom!

An open instance method.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 5280, s = Hi, Mom!

An open static method.
Static method M2 on C:  s = Hello, World!
Static method M2 on C:  s = Hi, Mom!

A static method closed over the first argument (String).
Static method M2 on C:  s = Hello, World!
 */

open System
open System.Reflection

// A sample class with an instance method and a static method.
type C(id) =
    member _.M1(s) =
        printfn $"Instance method M1 on C:  id = %i{id}, s = %s{s}"

    static member M2(s) =
        printfn $"Static method M2 on C:  s = %s{s}"
    
// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
type D1 = delegate of C * string -> unit
type D2 = delegate of string -> unit
type D3 = delegate of unit -> unit

let c1 = C 42

// Get a MethodInfo for each method.
//
let mi1 = typeof<C>.GetMethod("M1", BindingFlags.Public ||| BindingFlags.Instance)
let mi2 = typeof<C>.GetMethod("M2", BindingFlags.Public ||| BindingFlags.Static)

printfn "\nAn instance method closed over C."

// In this case, the delegate and the
// method must have the same list of argument types use
// delegate type D2 with instance method M1.
let test = Delegate.CreateDelegate(typeof<D2>, c1, mi1, false)

// Because false was specified for throwOnBindFailure
// in the call to CreateDelegate, the variable 'test'
// contains null if the method fails to bind (for
// example, if mi1 happened to represent a method of
// some class other than C).
if test <> null then
    let d2 = test :?> D2

    // The same instance of C is used every time the
    // delegate is invoked.
    d2.Invoke "Hello, World!"
    d2.Invoke "Hi, Mom!"

printfn "\nAn open instance method."

// In this case, the delegate has one more
// argument than the instance method this argument comes
// at the beginning, and represents the hidden instance
// argument of the instance method. Use delegate type D1
// with instance method M1.
let d1 = Delegate.CreateDelegate(typeof<D1>, null, mi1) :?> D1

// An instance of C must be passed in each time the
// delegate is invoked.
d1.Invoke(c1, "Hello, World!")
d1.Invoke(C 5280, "Hi, Mom!")

printfn "\nAn open static method."
// In this case, the delegate and the method must
// have the same list of argument types use delegate type
// D2 with static method M2.
let d2 = Delegate.CreateDelegate(typeof<D2>, null, mi2) :?> D2

// No instances of C are involved, because this is a static
// method.
d2.Invoke "Hello, World!"
d2.Invoke "Hi, Mom!"

printfn "\nA static method closed over the first argument (String)."
// The delegate must omit the first argument of the method.
// A string is passed as the firstArgument parameter, and
// the delegate is bound to this string. Use delegate type
// D3 with static method M2.
let d3 = Delegate.CreateDelegate(typeof<D3>, "Hello, World!", mi2) :?> D3

// Each time the delegate is invoked, the same string is used.
d3.Invoke()

// This code example produces the following output:
//     An instance method closed over C.
//     Instance method M1 on C:  id = 42, s = Hello, World!
//     Instance method M1 on C:  id = 42, s = Hi, Mom!
//     
//     An open instance method.
//     Instance method M1 on C:  id = 42, s = Hello, World!
//     Instance method M1 on C:  id = 5280, s = Hi, Mom!
//     
//     An open static method.
//     Static method M2 on C:  s = Hello, World!
//     Static method M2 on C:  s = Hi, Mom!
//     
//     A static method closed over the first argument (String).
//     Static method M2 on C:  s = Hello, World!

Imports System.Reflection
Imports System.Security.Permissions

' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C2, ByVal s As String)
Public Delegate Sub D2(ByVal s As String)
Public Delegate Sub D3()

' A sample class with an instance method and a Shared method.
'
Public Class C2
    Private id As Integer
    Public Sub New(ByVal id As Integer)
        Me.id = id
    End Sub

    Public Sub M1(ByVal s As String)
        Console.WriteLine("Instance method M1 on C2:  id = {0}, s = {1}",
            Me.id, s)
    End Sub

    Public Shared Sub M2(ByVal s As String)
        Console.WriteLine("Shared method M2 on C2:  s = {0}", s)
    End Sub
End Class

Public Class Example2

    Public Shared Sub Main()

        Dim c1 As New C2(42)

        ' Get a MethodInfo for each method.
        '
        Dim mi1 As MethodInfo = GetType(C2).GetMethod("M1",
            BindingFlags.Public Or BindingFlags.Instance)
        Dim mi2 As MethodInfo = GetType(C2).GetMethod("M2",
            BindingFlags.Public Or BindingFlags.Static)

        Dim d1 As D1
        Dim d2 As D2
        Dim d3 As D3


        Console.WriteLine(vbLf & "An instance method closed over C2.")
        ' In this case, the delegate and the
        ' method must have the same list of argument types; use
        ' delegate type D2 with instance method M1.
        '
        Dim test As [Delegate] =
            [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)

        ' Because False was specified for throwOnBindFailure 
        ' in the call to CreateDelegate, the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if mi1 happened to represent a method of 
        ' some class other than C2).
        '
        If test IsNot Nothing Then
            d2 = CType(test, D2)

            ' The same instance of C2 is used every time the
            ' delegate is invoked.
            d2("Hello, World!")
            d2("Hi, Mom!")
        End If


        Console.WriteLine(vbLf & "An open instance method.")
        ' In this case, the delegate has one more 
        ' argument than the instance method; this argument comes
        ' at the beginning, and represents the hidden instance
        ' argument of the instance method. Use delegate type D1
        ' with instance method M1.
        '
        d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)

        ' An instance of C2 must be passed in each time the 
        ' delegate is invoked.
        '
        d1(c1, "Hello, World!")
        d1(New C2(5280), "Hi, Mom!")


        Console.WriteLine(vbLf & "An open Shared method.")
        ' In this case, the delegate and the method must 
        ' have the same list of argument types; use delegate type
        ' D2 with Shared method M2.
        '
        d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)

        ' No instances of C2 are involved, because this is a Shared
        ' method. 
        '
        d2("Hello, World!")
        d2("Hi, Mom!")


        Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
        ' The delegate must omit the first argument of the method.
        ' A string is passed as the firstArgument parameter, and 
        ' the delegate is bound to this string. Use delegate type 
        ' D3 with Shared method M2. 
        '
        d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)

        ' Each time the delegate is invoked, the same string is
        ' used.
        d3()

    End Sub
End Class

' This code example produces the following output:
'
'An instance method closed over C2.
'Instance method M1 on C2:  id = 42, s = Hello, World!
'Instance method M1 on C2:  id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C2:  id = 42, s = Hello, World!
'Instance method M1 on C2:  id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C2:  s = Hello, World!
'Shared method M2 on C2:  s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C2:  s = Hello, World!
'

2. példa

Az alábbi példakód a paramétertípusok és a visszatérési típusok kompatibilitását mutatja be.

A példakód egy Base nevű alaposztályt és egy Derived nevű osztályt határoz meg, amely Baseszármazik. A származtatott osztály egy static nevű Shared (MyMethod visual basic) metódussal rendelkezik, amely egy Base típusú paraméterrel és egy Derivedvisszatérési típussal rendelkezik. A példakód egy Example nevű delegáltat is definiál, amely egy Derived típusú paraméterrel és egy Basevisszatérési típussal rendelkezik.

A példakód azt mutatja be, hogy a Example nevű delegált használható a MyMethodmetódus ábrázolására. A metódus a meghatalmazotthoz köthető, mert:

A delegált paramétertípusa (Derived) szigorúbb, mint a MyMethod paramétertípusa (Base), így mindig biztonságosan átadhatja a delegált argumentumát MyMethod.
A MyMethod (Derived) visszatérési típusa szigorúbb, mint a delegált paramétertípusa (Base), így a metódus visszatérési típusát mindig biztonságosan a delegált visszatérési típusára állíthatja.

A példakód nem hoz létre kimenetet.

using System;
using System.Reflection;

// Define two classes to use in the demonstration, a base class and
// a class that derives from it.
//
public class Base { }

public class Derived : Base
{
    // Define a static method to use in the demonstration. The method
    // takes an instance of Base and returns an instance of Derived.
    // For the purposes of the demonstration, it is not necessary for
    // the method to do anything useful.
    //
    public static Derived MyMethod(Base arg)
    {
        Base dummy = arg;
        return new Derived();
    }
}

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base Example5(Derived arg);

class Test
{
    public static void Main()
    {
        // The binding flags needed to retrieve MyMethod.
        BindingFlags flags = BindingFlags.Public | BindingFlags.Static;

        // Get a MethodInfo that represents MyMethod.
        MethodInfo minfo = typeof(Derived).GetMethod("MyMethod", flags);

        // Demonstrate contravariance of parameter types and covariance
        // of return types by using the delegate Example5 to represent
        // MyMethod. The delegate binds to the method because the
        // parameter of the delegate is more restrictive than the
        // parameter of the method (that is, the delegate accepts an
        // instance of Derived, which can always be safely passed to
        // a parameter of type Base), and the return type of MyMethod
        // is more restrictive than the return type of Example5 (that
        // is, the method returns an instance of Derived, which can
        // always be safely cast to type Base).
        //
        Example5 ex =
            (Example5)Delegate.CreateDelegate(typeof(Example5), minfo);

        // Execute MyMethod using the delegate Example5.
        //
        Base b = ex(new Derived());
    }
}

open System
open System.Reflection

// Define two classes to use in the demonstration, a base class and
// a class that derives from it.
type Base() = class end

type Derived() =
    inherit Base()

    // Define a static method to use in the demonstration. The method
    // takes an instance of Base and returns an instance of Derived.
    // For the purposes of the demonstration, it is not necessary for
    // the method to do anything useful.
    static member MyMethod(arg: Base) =
        Derived()

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
type Example = delegate of Derived -> Base

// The binding flags needed to retrieve MyMethod.
let flags = BindingFlags.Public ||| BindingFlags.Static

// Get a MethodInfo that represents MyMethod.
let minfo = typeof<Derived>.GetMethod("MyMethod", flags)

// Demonstrate contravariance of parameter types and covariance
// of return types by using the delegate Example to represent
// MyMethod. The delegate binds to the method because the
// parameter of the delegate is more restrictive than the
// parameter of the method (that is, the delegate accepts an
// instance of Derived, which can always be safely passed to
// a parameter of type Base), and the return type of MyMethod
// is more restrictive than the return type of Example (that
// is, the method returns an instance of Derived, which can
// always be safely cast to type Base).
let ex = Delegate.CreateDelegate(typeof<Example>, minfo) :?> Example

// Execute MyMethod using the delegate Example.
let b = Derived() |> ex.Invoke

Imports System.Reflection

' Define two classes to use in the demonstration, a base class and 
' a class that derives from it.
'
Public Class Base
End Class

Public Class Derived
    Inherits Base

    ' Define a Shared method to use in the demonstration. The method 
    ' takes an instance of Base and returns an instance of Derived.  
    ' For the purposes of the demonstration, it is not necessary for 
    ' the method to do anything useful. 
    '
    Public Shared Function MyMethod(ByVal arg As Base) As Derived
        Dim dummy As Base = arg
        Return New Derived()
    End Function

End Class

' Define a delegate that takes an instance of Derived and returns an
' instance of Base.
'
Public Delegate Function Example(ByVal arg As Derived) As Base

Module Test

    Sub Main()

        ' The binding flags needed to retrieve MyMethod.
        Dim flags As BindingFlags = _
            BindingFlags.Public Or BindingFlags.Static

        ' Get a MethodInfo that represents MyMethod.
        Dim minfo As MethodInfo = _
            GetType(Derived).GetMethod("MyMethod", flags)

        ' Demonstrate contravariance of parameter types and covariance
        ' of return types by using the delegate Example to represent
        ' MyMethod. The delegate binds to the method because the
        ' parameter of the delegate is more restrictive than the 
        ' parameter of the method (that is, the delegate accepts an
        ' instance of Derived, which can always be safely passed to
        ' a parameter of type Base), and the return type of MyMethod
        ' is more restrictive than the return type of Example (that
        ' is, the method returns an instance of Derived, which can
        ' always be safely cast to type Base). 
        '
        Dim ex As Example = CType( _
            [Delegate].CreateDelegate(GetType(Example), minfo), _
            Example _
        )

        ' Execute MyMethod using the delegate Example.
        '        
        Dim b As Base = ex(New Derived())
    End Sub
End Module

CreateDelegate(Type, Object, MethodInfo) és CreateDelegate(Type, Object, MethodInfo, Boolean) metódusok

Ennek a két túlterhelésnek a funkciója ugyanaz, kivéve, hogy az egyik lehetővé teszi annak megadását, hogy dobjon-e hibát, ha a kötés sikertelen, míg a másik mindig dob hibát.

A delegált típusnak és a metódusnak kompatibilis visszatérési típusokkal kell rendelkeznie. Vagyis a method visszatérési típusának átruházhatónak kell lennie a typevisszatérési típusára.

firstArgument– a túlterhelések második paramétere – a meghatalmazott által képviselt metódus első argumentuma. Ha firstArgument van megadva, azt a rendszer minden alkalommal átadja method, amikor a meghatalmazottat meghívják; firstArgument állítólag a meghatalmazotthoz van kötve, és a meghatalmazott az első argumentuma miatt zárva lesz. Ha methodstatic (Shared a Visual Basicben), a meghatalmazott meghívásakor megadott argumentumlista az első kivételével az összes paramétert tartalmazza; ha method egy példánymetódus, akkor a firstArgument a rejtett példányparaméternek továbbítja (c#-ban this, vagy a Visual Basicben Me).

Ha firstArgument van megadva, a method első paraméterének referenciatípusnak kell lennie, és firstArgument kompatibilisnek kell lennie ezzel a típussal.

Important

Ha methodstatic (Shared a Visual Basicben), és első paramétere Object vagy ValueTypetípusú, akkor firstArgument lehet értéktípus. Ebben az esetben a firstArgument automatikusan be van jelölve. Automatikus boxolás nem történik más argumentumok esetében, mint ahogyan egy C# vagy Visual Basic függvényhívásnál történne.

Ha firstArgument null értékű hivatkozás, és method egy példánymetódus, az eredmény a delegált típusú type és a methodaláírásától függ:

Ha a type aláírása explicit módon tartalmazza a methodrejtett első paraméterét, akkor a meghatalmazott a nyílt példány metódusát jelöli. Amikor a delegált meghívásra kerül, az argumentumok listájának első argumentuma a methodrejtett példányparaméterének kerül átadásra.
Ha a method és type aláírása egyezik (azaz minden paramétertípus kompatibilis), akkor a delegáltat null értékű hivatkozással kell bezárni. A delegátus meghívása olyan, mintha null példányon hívna meg egy példánymetódust, ami nem különösebben hasznos.

Ha firstArgument null értékű hivatkozás, és method statikus, az eredmény a delegált típusú type és a methodaláírásától függ:

Ha a method és type aláírása egyezik (vagyis minden paramétertípus kompatibilis), a meghatalmazott azt mondja, hogy egy nyitott statikus metódust jelöl. Ez a statikus metódusok leggyakoribb esete. Ebben az esetben valamivel jobb teljesítményt érhet el a CreateDelegate(Type, MethodInfo) metódus túlterhelésével.
Ha a type aláírása a method második paraméterével kezdődik, és a többi paramétertípus kompatibilis, akkor a delegáltat null értékű hivatkozással kell bezárni. A meghatalmazott meghívásakor a függvény null értékű hivatkozást ad át a methodelső paraméterének.

Example

Az alábbi példakód azokat a módszereket mutatja be, amelyek egyetlen delegálási típust jelölhetnek: egy példánymetódushoz zárt, egy példánymetódushoz nyitott, egy statikus metódushoz nyitott, és egy statikus metódushoz zárt.

A példakód két osztályt határoz meg, C és F, valamint egy delegált típusú D egy Ctípusú argumentummal. Az osztályok egyező statikus és példánymetódusokkal rendelkeznek M1, M3és M4, és az osztály C is rendelkezik olyan példánymetódus-M2, amely nem rendelkezik argumentumokkal.

Egy Example nevű harmadik osztály tartalmazza a meghatalmazottakat létrehozó kódot.

A meghatalmazottak M1C típusú és Ftípusú példánymetódushoz jönnek létre; mindegyik a megfelelő típusú példányon van lezárva. A M1 típusú metódus C a kötött példány és az argumentum ID tulajdonságait jeleníti meg.
A M2típusú C metódushoz egy delegált jön létre. Ez egy nyílt példánybeli delegált, amelyben a delegált argumentuma a példánymetódus rejtett első argumentumát képviseli. A metódusnak nincsenek más argumentumai. Úgy hívják, mintha statikus módszer lenne.
A delegátumok a M3 statikus metódus és a C, valamint a Ftípusokhoz jönnek létre; ezek nyitott statikus delegátumok.
Végül, delegáltak jönnek létre a M4 statikus metódushoz, amely a C típusú és Ftípushoz tartozik; minden metódus első argumentuma a deklaráló típus, és a típus egy példánya biztosított, így a delegáltak az első argumentumukra zártak. A M4 típusú metódus C a kötött példány és az argumentum ID tulajdonságait jeleníti meg.

using System;
using System.Reflection;

// Declare a delegate type. The object of this code example
// is to show all the methods this delegate can bind to.
//
public delegate void D(C1 c);

// Declare two sample classes, C1 and F. Class C1 has an ID
// property so instances can be identified.
//
public class C1
{
    private int id;
    public int ID => id;
    public C1(int id) => this.id = id;

    public void M1(C1 c)
    {
        Console.WriteLine("Instance method M1(C1 c) on C1:  this.id = {0}, c.ID = {1}",
            this.id, c.ID);
    }

    public void M2()
    {
        Console.WriteLine($"Instance method M2() on C1:  this.id = {this.id}");
    }

    public static void M3(C1 c)
    {
        Console.WriteLine($"Static method M3(C1 c) on C1:  c.ID = {c.ID}");
    }

    public static void M4(C1 c1, C1 c2)
    {
        Console.WriteLine("Static method M4(C1 c1, C1 c2) on C1:  c1.ID = {0}, c2.ID = {1}",
            c1.ID, c2.ID);
    }
}

public class F
{
    public void M1(C1 c)
    {
        Console.WriteLine($"Instance method M1(C1 c) on F:  c.ID = {c.ID}");
    }

    public static void M3(C1 c)
    {
        Console.WriteLine($"Static method M3(C1 c) on F:  c.ID = {c.ID}");
    }

    public static void M4(F f, C1 c)
    {
        Console.WriteLine($"Static method M4(F f, C1 c) on F:  c.ID = {c.ID}");
    }
}

public class Example
{
    public static void Main()
    {
        C1 c1 = new (42);
        C1 c2 = new (1491);
        F f1 = new ();

        D d;

        // Instance method with one argument of type C1.
        MethodInfo cmi1 = typeof(C1).GetMethod("M1");
        // Instance method with no arguments.
        MethodInfo cmi2 = typeof(C1).GetMethod("M2");
        // Static method with one argument of type C1.
        MethodInfo cmi3 = typeof(C1).GetMethod("M3");
        // Static method with two arguments of type C1.
        MethodInfo cmi4 = typeof(C1).GetMethod("M4");

        // Instance method with one argument of type C1.
        MethodInfo fmi1 = typeof(F).GetMethod("M1");
        // Static method with one argument of type C1.
        MethodInfo fmi3 = typeof(F).GetMethod("M3");
        // Static method with an argument of type F and an argument
        // of type C1.
        MethodInfo fmi4 = typeof(F).GetMethod("M4");

        Console.WriteLine("\nAn instance method on any type, with an argument of type C1.");
        // D can represent any instance method that exactly matches its
        // signature. Methods on C1 and F are shown here.
        //
        d = (D)Delegate.CreateDelegate(typeof(D), c1, cmi1);
        d(c2);
        d = (D)Delegate.CreateDelegate(typeof(D), f1, fmi1);
        d(c2);

        Console.WriteLine("\nAn instance method on C1 with no arguments.");
        // D can represent an instance method on C1 that has no arguments;
        // in this case, the argument of D represents the hidden first
        // argument of any instance method. The delegate acts like a
        // static method, and an instance of C1 must be passed each time
        // it is invoked.
        //
        d = (D)Delegate.CreateDelegate(typeof(D), null, cmi2);
        d(c1);

        Console.WriteLine("\nA static method on any type, with an argument of type C1.");
        // D can represent any static method with the same signature.
        // Methods on F and C1 are shown here.
        //
        d = (D)Delegate.CreateDelegate(typeof(D), null, cmi3);
        d(c1);
        d = (D)Delegate.CreateDelegate(typeof(D), null, fmi3);
        d(c1);

        Console.WriteLine("\nA static method on any type, with an argument of");
        Console.WriteLine("    that type and an argument of type C1.");
        // D can represent any static method with one argument of the
        // type the method belongs and a second argument of type C1.
        // In this case, the method is closed over the instance of
        // supplied for the its first argument, and acts like an instance
        // method. Methods on F and C1 are shown here.
        //
        d = (D)Delegate.CreateDelegate(typeof(D), c1, cmi4);
        d(c2);
        Delegate test =
            Delegate.CreateDelegate(typeof(D), f1, fmi4, false);

        // This final example specifies false for throwOnBindFailure
        // in the call to CreateDelegate, so the variable 'test'
        // contains Nothing if the method fails to bind (for
        // example, if fmi4 happened to represent a method of
        // some class other than F).
        //
        if (test != null)
        {
            d = (D)test;
            d(c2);
        }
    }
}

/* This code example produces the following output:

An instance method on any type, with an argument of type C1.
Instance method M1(C1 c) on C1:  this.id = 42, c.ID = 1491
Instance method M1(C1 c) on F:  c.ID = 1491

An instance method on C1 with no arguments.
Instance method M2() on C1:  this.id = 42

A static method on any type, with an argument of type C1.
Static method M3(C1 c) on C1:  c.ID = 42
Static method M3(C1 c) on F:  c.ID = 42

A static method on any type, with an argument of
    that type and an argument of type C1.
Static method M4(C1 c1, C1 c2) on C1:  c1.ID = 42, c2.ID = 1491
Static method M4(F f, C1 c) on F:  c.ID = 1491
*/

open System

// Declare two sample classes, C and F. Class C has an ID
// property so instances can be identified.
type C(id) =
    member _.ID = id 

    member _.M1(c: C) =
        printfn $"Instance method M1(C c) on C:  this.id = {id}, c.ID = {c.ID}"

    member _.M2() =
        printfn $"Instance method M2() on C:  this.id = {id}"

    static member M3(c: C) =
        printfn $"Static method M3(C c) on C:  c.ID = {c.ID}"

    static member M4(c1: C, c2: C) =
        printfn $"Static method M4(C c1, C c2) on C:  c1.ID = {c1.ID}, c2.ID = {c2.ID}"

// Declare a delegate type. The object of this code example
// is to show all the methods this delegate can bind to.
type D = delegate of C -> unit


type F() =
    member _.M1(c: C) =
        printfn $"Instance method M1(C c) on F:  c.ID = {c.ID}"

    member _.M3(c: C) =
        printfn $"Static method M3(C c) on F:  c.ID = {c.ID}"

    member _.M4(f: F, c: C) =
        printfn $"Static method M4(F f, C c) on F:  c.ID = {c.ID}"

[<EntryPoint>]
let main _ =
    let c1 = C 42
    let c2 = C 1491
    let f1 = F()

    // Instance method with one argument of type C.
    let cmi1 = typeof<C>.GetMethod "M1"
    // Instance method with no arguments.
    let cmi2 = typeof<C>.GetMethod "M2"
    // Static method with one argument of type C.
    let cmi3 = typeof<C>.GetMethod "M3"
    // Static method with two arguments of type C.
    let cmi4 = typeof<C>.GetMethod "M4"

    // Instance method with one argument of type C.
    let fmi1 = typeof<F>.GetMethod "M1"
    // Static method with one argument of type C.
    let fmi3 = typeof<F>.GetMethod "M3"
    // Static method with an argument of type F and an argument
    // of type C.
    let fmi4 = typeof<F>.GetMethod "M4"

    printfn "\nAn instance method on any type, with an argument of type C."
    // D can represent any instance method that exactly matches its
    // signature. Methods on C and F are shown here.
    let d = Delegate.CreateDelegate(typeof<D>, c1, cmi1) :?> D
    d.Invoke c2
    let d =  Delegate.CreateDelegate(typeof<D>, f1, fmi1) :?> D
    d.Invoke c2

    Console.WriteLine("\nAn instance method on C with no arguments.")
    // D can represent an instance method on C that has no arguments
    // in this case, the argument of D represents the hidden first
    // argument of any instance method. The delegate acts like a
    // static method, and an instance of C must be passed each time
    // it is invoked.
    let d = Delegate.CreateDelegate(typeof<D>, null, cmi2) :?> D
    d.Invoke c1

    printfn "\nA static method on any type, with an argument of type C."
    // D can represent any static method with the same signature.
    // Methods on F and C are shown here.
    let d = Delegate.CreateDelegate(typeof<D>, null, cmi3) :?> D
    d.Invoke c1
    let d = Delegate.CreateDelegate(typeof<D>, null, fmi3) :?> D
    d.Invoke c1

    printfn "\nA static method on any type, with an argument of"
    printfn "    that type and an argument of type C."
    // D can represent any static method with one argument of the
    // type the method belongs and a second argument of type C.
    // In this case, the method is closed over the instance of
    // supplied for the its first argument, and acts like an instance
    // method. Methods on F and C are shown here.
    let d = Delegate.CreateDelegate(typeof<D>, c1, cmi4) :?> D
    d.Invoke c2
    let test =
        Delegate.CreateDelegate(typeof<D>, f1, fmi4, false)

    // This final example specifies false for throwOnBindFailure
    // in the call to CreateDelegate, so the variable 'test'
    // contains Nothing if the method fails to bind (for
    // example, if fmi4 happened to represent a method of
    // some class other than F).
    match test with
    | :? D as d ->
        d.Invoke c2
    | _ -> ()
    0

// This code example produces the following output:
//     An instance method on any type, with an argument of type C.
//     Instance method M1(C c) on C:  this.id = 42, c.ID = 1491
//     Instance method M1(C c) on F:  c.ID = 1491
//    
//     An instance method on C with no arguments.
//     Instance method M2() on C:  this.id = 42
//    
//     A static method on any type, with an argument of type C.
//     Static method M3(C c) on C:  c.ID = 42
//     Static method M3(C c) on F:  c.ID = 42
//    
//     A static method on any type, with an argument of
//         that type and an argument of type C.
//     Static method M4(C c1, C c2) on C:  c1.ID = 42, c2.ID = 1491
//     Static method M4(F f, C c) on F:  c.ID = 1491

Imports System.Reflection
Imports System.Security.Permissions

' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C) 

' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C

    Private _id As Integer

    Public ReadOnly Property ID() As Integer 
        Get
            Return _id
        End Get
    End Property

    Public Sub New(ByVal newId As Integer) 
        Me._id = newId
    End Sub
    
    Public Sub M1(ByVal c As C) 
        Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}", _
            Me.id, c.ID)
    End Sub
    
    Public Sub M2() 
        Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)
    End Sub
    
    Public Shared Sub M3(ByVal c As C) 
        Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) 
        Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _
            c1.ID, c2.ID)
    End Sub
End Class


Public Class F
    
    Public Sub M1(ByVal c As C) 
        Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M3(ByVal c As C) 
        Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M4(ByVal f As F, ByVal c As C) 
        Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)
    End Sub
End Class

Public Class Example5

    Public Shared Sub Main()

        Dim c1 As New C(42)
        Dim c2 As New C(1491)
        Dim f1 As New F()

        Dim d As D

        ' Instance method with one argument of type C.
        Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")
        ' Instance method with no arguments.
        Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")
        ' Shared method with one argument of type C.
        Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")
        ' Shared method with two arguments of type C.
        Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")

        ' Instance method with one argument of type C.
        Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")
        ' Shared method with one argument of type C.
        Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")
        ' Shared method with an argument of type F and an 
        ' argument of type C.
        Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")

        Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")
        ' D can represent any instance method that exactly matches its
        ' signature. Methods on C and F are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)
        d(c2)
        d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)
        d(c2)

        Console.WriteLine(vbLf & "An instance method on C with no arguments.")
        ' D can represent an instance method on C that has no arguments;
        ' in this case, the argument of D represents the hidden first
        ' argument of any instance method. The delegate acts like a 
        ' Shared method, and an instance of C must be passed each time
        ' it is invoked.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)
        d(c1)

        Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")
        ' D can represent any Shared method with the same signature.
        ' Methods on F and C are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)
        d(c1)
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)
        d(c1)

        Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")
        Console.WriteLine("    that type and an argument of type C.")
        ' D can represent any Shared method with one argument of the
        ' type the method belongs and a second argument of type C.
        ' In this case, the method is closed over the instance of
        ' supplied for the its first argument, and acts like an instance
        ' method. Methods on F and C are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)
        d(c2)
        Dim test As [Delegate] =
            [Delegate].CreateDelegate(GetType(D), f1, fmi4, False)

        ' This final example specifies False for throwOnBindFailure 
        ' in the call to CreateDelegate, so the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if fmi4 happened to represent a method of  
        ' some class other than F).
        '
        If test IsNot Nothing Then
            d = CType(test, D)
            d(c2)
        End If

    End Sub
End Class

' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C:  this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F:  c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C:  this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C:  c.ID = 42
'Shared method M3(c As C) on F:  c.ID = 42
'
'A Shared method on any type, with an argument of
'    that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C:  c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F:  c.ID = 1491
'

Kompatibilis paramétertípusok és visszatérési típus

Az ezzel a metódussal létrehozott delegált paramétertípusainak és visszatérési típusának kompatibilisnek kell lennie a delegált által képviselt paramétertípussal és visszatérési típussal; a típusoknak nem kell pontosan egyezniük.

A meghatalmazott paramétere kompatibilis a metódus megfelelő paraméterével, ha a delegálási paraméter típusa szigorúbb, mint a metódusparaméter típusa, mivel ez garantálja, hogy a delegáltnak átadott argumentum biztonságosan átadható a metódusnak.

Hasonlóképpen, a delegált visszatérési típusa kompatibilis a metódus visszatérési típusával, ha a metódus visszatérési típusa korlátozóbb, mint a delegált visszatérési típusa, mivel ez garantálja, hogy a metódus visszatérési értéke biztonságosan átvehető a delegált visszatérési típusára.

Egy Hashtable típusú paraméterrel és a Object visszatérési típusával rendelkező delegáltak például olyan metódust képviselhetnek, amely Object típusú paraméterrel és Hashtabletípusú visszatérési értékkel rendelkezik.

Határozza meg, hogy a meghatalmazott milyen módszereket jelölhet

A CreateDelegate(Type, Object, MethodInfo) túlterhelés által biztosított rugalmasság másik hasznos módja, hogy bármely adott meghatalmazott a metódus-aláírás és a metódustípus négy különböző kombinációját (statikus és példány) képviselheti. Fontoljon meg egy D típusú delegáltat, amelynek egy Ctípusú argumentuma van. Az alábbiakban az D által képviselhető metódusokat ismertetjük, figyelmen kívül hagyva a visszatérési típust, mivel annak minden esetben meg kell egyeznie.

D bármely olyan példánymetódust jelölhet, amelynek pontosan egy Ctípusú argumentuma van, függetlenül attól, hogy a példánymetódus milyen típushoz tartozik. Amikor a CreateDelegate meghívásra kerül, a firstArgument a method tartozó típus egy példánya, és az eredményként kapott delegált zárt lesz ahhoz a példányhoz. (Triviálisan a D null hivatkozással is bezárható, ha firstArgument null hivatkozás.)
D az argumentumokat nem tartalmazó C egy példánymetódusát jelölheti. Amikor a CreateDelegate meghívásra kerül, a firstArgument null referencia. Az eredményként kapott delegált egy nyitott példánymetódust jelöl, és minden egyes meghíváskor meg kell adni egy C-példányt.
D olyan statikus metódust jelölhet, amely egy Ctípusú argumentumot vesz fel, és ez a metódus bármilyen típushoz tartozhat. Amikor a CreateDelegate meghívásra kerül, a firstArgument null referencia. Az eredményként kapott meghatalmazott egy nyitott statikus metódust jelöl, és minden egyes meghíváskor meg kell adni egy C-példányt.
D olyan statikus metódust jelölhet, amely F típushoz tartozik, és két argumentumot is tartalmazhat, F típusú és Ctípusú. A CreateDelegate meghívásakor a firstArgument a Fegy példánya. Az eredményként kapott delegált egy statikus metódust jelöl, amely a Fadott példánya felett van lezárva. Vegye figyelembe, hogy abban az esetben, ha F és C azonos típusúak, a statikus metódusnak két argumentuma van. Ebben az esetben D null hivatkozással van lezárva, ha firstArgument null hivatkozás.

Megjegyzések

Az Delegate osztály a delegálttípusok alaposztálya. Azonban csak a rendszer és a fordítók származhatnak explicit módon az osztályból vagy az Delegate MulticastDelegate osztályból. Delegált típusból nem lehet új típust levezetni. Az Delegate osztály nem tekinthető delegált típusnak, hanem a delegálttípusok származtatására használt osztály.

A legtöbb nyelv implementál egy kulcsszót delegate , és az adott nyelvek fordítói képesek az MulticastDelegate osztályból származni, ezért a felhasználóknak a delegate nyelv által biztosított kulcsszót kell használniuk.

Note

A közös nyelvi futtatókörnyezet minden delegálttípushoz biztosít egy metódust Invoke , ugyanazzal az aláírással, mint a meghatalmazott. Nem kell explicit módon meghívnia ezt a metódust a C#-ból vagy Visual Basic, mert a fordítók automatikusan meghívják. A Invoke metódus akkor hasznos , ha meg szeretné keresni a delegált típus aláírását.

A közös nyelvi futtatókörnyezet minden delegálttípust BeginInvoke és EndInvoke metódust biztosít a meghatalmazott aszinkron meghívásának engedélyezéséhez. További információ ezekről a metódusokról: Szinkron metódusok aszinkron meghívása.

A delegált típusú deklaráció egy olyan szerződést hoz létre, amely egy vagy több metódus aláírását határozza meg. A meghatalmazott egy meghatalmazotttípus egy példánya, amely a következőre hivatkozik:

Egy típus példánymetódusa és az adott típushoz hozzárendelhető célobjektum.
Egy típus példánymetódusa, amelynek rejtett this paramétere megjelenik a formális paraméterlistában. A meghatalmazottról azt mondják, hogy egy nyílt példány meghatalmazottja.
Statikus módszer.
A metódus első paraméteréhez hozzárendelhető statikus és célobjektum. A meghatalmazott az első argumentuma miatt zárva lesz.

A delegált kötésről további információt a metódus túlterhelésével CreateDelegate(Type, Object, MethodInfo, Boolean) kapcsolatban talál.

Ha egy meghatalmazott az első argumentuma (a leggyakoribb eset) során bezárt példánymetódust jelöl, a delegált egy hivatkozást tárol a metódus belépési pontjára és egy objektumra mutató hivatkozást, amelyet célnak neveznek, amely a metódust definiáló típushoz rendelhető. Amikor egy meghatalmazott egy nyitott példány metódusát jelöli, a metódus belépési pontjára mutató hivatkozást tárol. A meghatalmazotti aláírásnak tartalmaznia kell a rejtett this paramétert a hivatalos paraméterlistájában; ebben az esetben a meghatalmazott nem hivatkozik célobjektumra, és a meghatalmazott meghívásakor meg kell adnia egy célobjektumot.

Ha egy meghatalmazott statikus metódust jelöl, a meghatalmazott a metódus belépési pontjára mutató hivatkozást tárol. Ha egy delegált egy statikus metódust jelöl, amely az első argumentuma alatt van lezárva, a delegált a metódus belépési pontjára mutató hivatkozást és a metódus első argumentumának típusához hozzárendelhető célobjektumra mutató hivatkozást tárol. A meghatalmazott meghívásakor a statikus metódus első argumentuma megkapja a célobjektumot. Ennek az első argumentumnak referenciatípusnak kell lennie.

A meghatalmazottak meghívási listája a meghatalmazottak rendezett halmaza, amelyben a lista minden eleme pontosan az egyik metódust hívja meg, amelyet a meghatalmazott képvisel. A meghívási listák ismétlődő metódusokat tartalmazhatnak. A meghívás során a metódusok abban a sorrendben lesznek meghívva, amelyben megjelennek a meghívási listában. A meghatalmazott megkísérli meghívni az összes metódust a híváslistájában; az ismétlődő elemeket a rendszer minden alkalommal egyszer meghívja, amikor megjelennek a meghívási listában. A meghatalmazottak nem módosíthatók; létrehozása után a meghatalmazott meghívási listája nem változik.

A meghatalmazottakat csoportos küldésnek vagy kombinálhatónak nevezzük, mivel a meghatalmazottak meghívhatnak egy vagy több metódust, és használhatók a műveletek kombinálásához.

Az olyan műveletek kombinálása, mint például Combine az és Remove, nem módosítják a meglévő meghatalmazottakat. Ehelyett egy ilyen művelet egy új meghatalmazottat ad vissza, amely tartalmazza a művelet eredményeit, egy változatlan meghatalmazottat vagy null. Az egyesítő művelet akkor ad null vissza eredményt, ha a művelet eredménye olyan meghatalmazott, amely nem hivatkozik legalább egy metódusra. Az egyesítő művelet változatlan meghatalmazottat ad vissza, ha a kért műveletnek nincs hatása.

Note

A felügyelt nyelvek a delegálási műveletek implementálásához használják a metódusokat és Combine a Remove metódusokat. Ilyenek például a AddHandler és RemoveHandler utasítások a Visual Basic és a += és -= operátorok a delegált típusok C#-ban.

Az általános delegálási típusok variánstípus-paraméterekkel is rendelkezhetnek. A contravariant típusú paraméterek használhatók a delegált paramétertípusaként, a kovariant típusú paraméter pedig visszatérési típusként. Ez a funkció lehetővé teszi, hogy az azonos általános típusdefinícióból létrehozott általános delegálási típusok hozzárendelés-kompatibilisek legyenek, ha a típusargumentumok öröklési kapcsolattal rendelkező referenciatípusok, ahogyan azt a Kovariancia és a Contravariance is ismerteti.

Note

A variancia miatt hozzárendeléssel kompatibilis általános meghatalmazottak nem feltétlenül kombinálhatók. Ahhoz, hogy kombinálható legyen, a típusoknak pontosan meg kell egyeznie. Tegyük fel például, hogy egy elnevezett Derived osztály egy nevesített Baseosztályból származik. A Action<Base> (Action(Of Base) Visual Basic) típusú meghatalmazott Action<Derived> típusú változóhoz rendelhető, de a két meghatalmazott nem kombinálható, mert a típusok nem felelnek meg pontosan.

Ha egy meghívott metódus kivételt jelez, a metódus leáll, a kivétel visszakerül a meghatalmazott hívójának, és a meghívási listában szereplő többi metódus nem lesz meghívva. A hívó kivételének észlelése nem módosítja ezt a viselkedést.

Ha a meghatalmazott által meghívott metódusok aláírása tartalmaz egy visszatérési értéket, a meghatalmazott a meghívási lista utolsó elemének visszatérési értékét adja vissza. Ha az aláírás tartalmaz egy hivatkozással átadott paramétert, a paraméter végső értéke a meghívási listában szereplő összes metódus eredménye, amely egymás után hajtja végre és frissíti a paraméter értékét.

A C delegált legközelebbi megfelelője egy függvénymutató. A meghatalmazottak statikus vagy példánymetódusokat is képviselhetnek. Amikor a meghatalmazott egy példánymetódust jelöl, a meghatalmazott nem csak a metódus belépési pontjára mutató hivatkozást, hanem az osztálypéldányra mutató hivatkozást is tárol. A függvénymutatókkal ellentétben a meghatalmazottak objektumorientáltak és biztonságosak.

CreateDelegate-példák

A CreateDelegate metódusok egy megadott típusú delegáltat hoznak létre.

CreateDelegate(Type, MethodInfo) módszer

Ennek a metódusnak a túlterhelése egyenértékű a CreateDelegate(Type, MethodInfo, Boolean) metódus túlterhelésének meghívásával, és azzal, hogy a trueszámára meghatározza a throwOnBindFailure-et.

Konstruktorok

Name	Description
Delegate(Object, String)	Inicializál egy meghatalmazottat, aki meghívja a megadott példány metódusát a megadott osztálypéldányon.
Delegate(Type, String)	Inicializál egy meghatalmazottat, aki meghívja a megadott statikus metódust a megadott osztályból.

Tulajdonságok

Name	Description
HasSingleTarget	Egy olyan értéket kap, amely jelzi, hogy a Delegate hívási cél egyetlen-e.
Method	Lekéri a meghatalmazott által képviselt metódust.
Target	Lekéri azt az osztálypéldányt, amelyre az aktuális meghatalmazott meghívja a példánymetódust.

Metódusok

Name	Description
Clone()	Létrehozza a meghatalmazott sekély másolatát.
Combine(Delegate, Delegate)	Összefűzi két meghatalmazott meghívási listáját.
Combine(Delegate[])	Összefűzi a meghatalmazottak tömbjének meghívási listáit.
Combine(ReadOnlySpan<Delegate>)	Összefűzi a meghatalmazottak egy tartományának meghívási listáit.
CombineImpl(Delegate)	Összefűzi a megadott csoportos küldésű (kombinálható) delegált és az aktuális csoportos küldésű (kombinálható) delegált meghívási listáit.
CreateDelegate(Type, MethodInfo, Boolean)	Létrehoz egy megadott típusú delegáltat, amely a megadott statikus metódust képviseli, a kötés meghiúsulása esetén a megadott viselkedéssel.
CreateDelegate(Type, MethodInfo)	Létrehoz egy megadott típusú delegáltat, amely a megadott metódust képviseli.
CreateDelegate(Type, Object, MethodInfo, Boolean)	Létrehoz egy megadott típusú delegáltat, amely a megadott statikus vagy példánymetódusnak felel meg, a megadott első argumentummal és a kötés meghiúsulásának megadott viselkedésével.
CreateDelegate(Type, Object, MethodInfo)	Létrehoz egy megadott típusú delegáltat, amely a megadott statikus vagy példánymetódusnak felel meg a megadott első argumentummal.
CreateDelegate(Type, Object, String, Boolean, Boolean)	Létrehoz egy megadott típusú delegáltat, amely a megadott osztálypéldányon meghívandó adott példánymetódust jelöli, a megadott kis- és nagybetűk érzékenységével és a kötés meghiúsulásával kapcsolatos megadott viselkedéssel.
CreateDelegate(Type, Object, String, Boolean)	Létrehoz egy megadott típusú delegáltat, amely a megadott osztálypéldányon meghívandó, a megadott kis- és nagybetűkre vonatkozó metódust jelöli.
CreateDelegate(Type, Object, String)	Létrehoz egy megadott típusú delegáltat, amely a megadott osztálypéldányon meghívandó megadott példánymetódust jelöli.
CreateDelegate(Type, Type, String, Boolean, Boolean)	Létrehoz egy megadott típusú delegáltat, amely a megadott osztály megadott statikus metódusát képviseli, a megadott kis- és nagybetűk érzékenységével és a kötés meghiúsulásának megadott viselkedésével.
CreateDelegate(Type, Type, String, Boolean)	Létrehoz egy megadott típusú delegáltat, amely a megadott osztály megadott statikus metódusát képviseli a megadott kis- és nagybetűk érzékenységével.
CreateDelegate(Type, Type, String)	Létrehoz egy megadott típusú delegáltat, amely a megadott osztály megadott statikus metódusát jelöli.
DynamicInvoke(Object[])	Dinamikusan meghívja (későn kötött) az aktuális meghatalmazott által képviselt metódust.
DynamicInvokeImpl(Object[])	Dinamikusan meghívja (későn kötött) az aktuális meghatalmazott által képviselt metódust.
EnumerateInvocationList<TDelegate>(TDelegate)	Enumerátort kap a meghatalmazott meghívási céljaihoz.
Equals(Object)	Meghatározza, hogy a megadott objektum és az aktuális delegált azonos típusú-e, és ugyanazokkal a célokkal, metódusokkal és meghívási listával rendelkezik-e.
GetHashCode()	A meghatalmazott kivonatkódját adja vissza.
GetInvocationList()	A meghatalmazott meghívási listáját adja vissza.
GetMethodImpl()	Lekéri az aktuális meghatalmazott által képviselt metódust.
GetObjectData(SerializationInfo, StreamingContext)	Elavult. Nem támogatott.
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
Remove(Delegate, Delegate)	Eltávolítja egy meghatalmazott meghívási listájának utolsó előfordulását egy másik meghatalmazott meghívási listájából.
RemoveAll(Delegate, Delegate)	Eltávolítja a meghatalmazott meghívási listájának összes előfordulását egy másik meghatalmazott meghívási listájából.
RemoveImpl(Delegate)	Eltávolítja egy meghatalmazott meghívási listáját egy másik meghatalmazott meghívási listájából.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)

Operátorok

Name	Description
Equality(Delegate, Delegate)	Meghatározza, hogy a megadott meghatalmazottak egyenlőek-e.
Inequality(Delegate, Delegate)	Meghatározza, hogy a megadott meghatalmazottak nem egyenlők-e.

Bővítő metódusok

Name	Description
GetMethodInfo(Delegate)	Lekéri a megadott meghatalmazott által képviselt metódust képviselő objektumot.

A következőre érvényes:

Lásd még

Visszajelzés

Hasznosnak találta ezt az oldalt?