Delegáti (Visual Basic)Delegates (Visual Basic)

Delegáti jsou objekty, které odkazují na metody.Delegates are objects that refer to methods. Se někdy označuje jako ukazatele na funkci bezpečnosti typů protože jsou podobní ukazatelům na funkci použít v jiných programovacích jazycích.They are sometimes described as type-safe function pointers because they are similar to function pointers used in other programming languages. Ale na rozdíl od ukazatelů na funkce, Visual Basic Delegáti jsou typem odkazu na základě třídy System.Delegate.But unlike function pointers, Visual Basic delegates are a reference type based on the class System.Delegate. Delegáty lze odkazovat na obě sdílené metody, metody, které může být volána bez konkrétní instanci třídy – a instanci metody.Delegates can reference both shared methods — methods that can be called without a specific instance of a class — and instance methods.

Delegáti a událostiDelegates and Events

Delegáti jsou užitečné v situacích, kdy potřebujete prostředník mezi volání procedury a procedura volána.Delegates are useful in situations where you need an intermediary between a calling procedure and the procedure being called. Můžete například objekt, který vyvolává události, které mají být schopny volat jiné obslužné za různých okolností.For example, you might want an object that raises events to be able to call different event handlers under different circumstances. Objekt vyvolání události nemůže vědět předem, které obslužná rutina události je bohužel zpracování určité události.Unfortunately, the object raising the events cannot know ahead of time which event handler is handling a specific event. Visual Basic umožňuje obslužné rutiny událostí dynamicky přidružit s událostmi vytvořením delegáta pro vás při použití AddHandler příkazu.Visual Basic lets you dynamically associate event handlers with events by creating a delegate for you when you use the AddHandler statement. V době běhu delegát předává volání obslužné rutiny příslušné události.At run time, the delegate forwards calls to the appropriate event handler.

I když můžete vytvořit vlastní delegáty, ve většině případů vytvoří delegát jazyka Visual Basic a za vás postará o podrobnosti.Although you can create your own delegates, in most cases Visual Basic creates the delegate and takes care of the details for you. Například Event příkaz implicitně definuje třídu delegáta s názvem <EventName>EventHandler jako vnořené třídy z třídy obsahující Event příkaz a se stejnou signaturou jako události.For example, an Event statement implicitly defines a delegate class named <EventName>EventHandler as a nested class of the class containing the Event statement, and with the same signature as the event. AddressOf Příkaz implicitně vytvoří instanci delegáta, který odkazuje na konkrétní postup.The AddressOf statement implicitly creates an instance of a delegate that refers to a specific procedure. Následující dva řádky kódu jsou ekvivalentní.The following two lines of code are equivalent. V prvním řádku, uvidíte explicitní vytvoření instance EventHandler, s odkazem na metodu Button1_Click odeslán jako argument.In the first line, you see the explicit creation of an instance of EventHandler, with a reference to method Button1_Click sent as the argument. Druhý řádek je pohodlnější způsob, jak to samé udělá.The second line is a more convenient way to do the same thing.

AddHandler Button1.Click, New EventHandler(AddressOf Button1_Click)
' The following line of code is shorthand for the previous line.
AddHandler Button1.Click, AddressOf Me.Button1_Click

Můžete použít zkrácený způsob vytváření delegátů kdekoli kompilátor může určit typ delegáta podle kontextu.You can use the shorthand way of creating delegates anywhere the compiler can determine the delegate's type by the context.

Typ delegáta deklarovaného události, které používají existujícíDeclaring Events that Use an Existing Delegate Type

V některých případech můžete chtít událost použít existující typ delegáta jako jeho základní delegáta deklarovat.In some situations, you may want to declare an event to use an existing delegate type as its underlying delegate. Následující syntaxe ukazuje, jak:The following syntax demonstrates how:

Delegate Sub DelegateType()
Event AnEvent As DelegateType

To je užitečné, pokud chcete směrovat více událostí na stejnou obslužnou rutinu.This is useful when you want to route multiple events to the same handler.

Delegát proměnné a parametryDelegate Variables and Parameters

Lze použít delegáty pro ostatní, cokoli jiného než událost související s úkoly, jako je například volných vláken nebo s postupy, které je potřeba volat jiné verze funkcí v době běhu.You can use delegates for other, non-event related tasks, such as free threading or with procedures that need to call different versions of functions at run time.

Například předpokládejme, že budete mít aplikaci klasifikované ad, který obsahuje seznam s názvy aut.For example, suppose you have a classified-ad application that includes a list box with the names of cars. Reklamy jsou seřazeny podle názvu, který je obvykle zkontrolujte Auto.The ads are sorted by title, which is normally the make of the car. Pokud některé auta obsahovat rok car před značku, dojde k potížím, které mohou nastat.A problem you may face occurs when some cars include the year of the car before the make. Problém je, že funkce integrované řazení pole se seznamem seřadí pouze podle kódy znaků; umístí všechny reklamy spuštění s datem, nejprve, za nímž následuje reklamy, spouští se s bylo možné vytvořit.The problem is that the built-in sort functionality of the list box sorts only by character codes; it places all the ads starting with dates first, followed by the ads starting with the make.

To pokud chcete napravit, můžete vytvořit proceduru řazení ve třídě, která používá standardní abecední řazení na většině pole se seznamem, ale je možné přepínat v době běhu k postupu vlastní řazení pro car reklamy.To fix this, you can create a sort procedure in a class that uses the standard alphabetic sort on most list boxes, but is able to switch at run time to the custom sort procedure for car ads. K tomuto účelu předáte postup vlastní řazení na třídu řazení v době běhu, použití delegátů.To do this, you pass the custom sort procedure to the sort class at run time, using delegates.

Výrazy Lambda a AddressOfAddressOf and Lambda Expressions

Každá třída delegáta je definován konstruktor, který je předán specifikace metodu objektu.Each delegate class defines a constructor that is passed the specification of an object method. Argument pro konstruktor delegate musí být odkaz na metodu nebo výraz lambda.An argument to a delegate constructor must be a reference to a method, or a lambda expression.

Pokud chcete zadat odkaz na metodu, použijte následující syntaxi:To specify a reference to a method, use the following syntax:

AddressOf [expression.]methodNameAddressOf [expression.]methodName

Typ kompilace expression musí být názvem třídy nebo rozhraní, které obsahuje metodu se zadaným názvem, jehož předpis shoduje se signaturou třídy delegáta.The compile-time type of the expression must be the name of a class or an interface that contains a method of the specified name whose signature matches the signature of the delegate class. methodName Může být buď sdílené metody nebo metodu instance.The methodName can be either a shared method or an instance method. methodName Není volitelný, i v případě vytvoření delegáta pro výchozí metodu třídy.The methodName is not optional, even if you create a delegate for the default method of the class.

Pokud chcete zadat výraz lambda, použijte následující syntaxi:To specify a lambda expression, use the following syntax:

Function ([parm Jako type, parm2 jako type2;...]) expressionFunction ([parm As type, parm2 As type2, ...]) expression

Následující příklad ukazuje, jak AddressOf a výrazy lambda umožňují zadat odkaz pro delegáta.The following example shows both AddressOf and lambda expressions used to specify the reference for a delegate.

Module Module1

    Sub Main()
        ' Create an instance of InOrderClass and assign values to the properties.
        ' InOrderClass method ShowInOrder displays the numbers in ascending 
        ' or descending order, depending on the comparison method you specify.
        Dim inOrder As New InOrderClass
        inOrder.Num1 = 5
        inOrder.Num2 = 4

        ' Use AddressOf to send a reference to the comparison function you want
        ' to use.
        inOrder.ShowInOrder(AddressOf GreaterThan)
        inOrder.ShowInOrder(AddressOf LessThan)

        ' Use lambda expressions to do the same thing.
        inOrder.ShowInOrder(Function(m, n) m > n)
        inOrder.ShowInOrder(Function(m, n) m < n)
    End Sub

    Function GreaterThan(ByVal num1 As Integer, ByVal num2 As Integer) As Boolean
        Return num1 > num2
    End Function

    Function LessThan(ByVal num1 As Integer, ByVal num2 As Integer) As Boolean
        Return num1 < num2
    End Function

    Class InOrderClass
        ' Define the delegate function for the comparisons.
        Delegate Function CompareNumbers(ByVal num1 As Integer, ByVal num2 As Integer) As Boolean
        ' Display properties in ascending or descending order.
        Sub ShowInOrder(ByVal compare As CompareNumbers)
            If compare(_num1, _num2) Then
                Console.WriteLine(_num1 & "  " & _num2)
            Else
                Console.WriteLine(_num2 & "  " & _num1)
            End If
        End Sub

        Private _num1 As Integer
        Property Num1() As Integer
            Get
                Return _num1
            End Get
            Set(ByVal value As Integer)
                _num1 = value
            End Set
        End Property

        Private _num2 As Integer
        Property Num2() As Integer
            Get
                Return _num2
            End Get
            Set(ByVal value As Integer)
                _num2 = value
            End Set
        End Property
    End Class
End Module

Signatura funkce musí odpovídat typu delegátu.The signature of the function must match that of the delegate type. Další informace o výrazech lambda naleznete v tématu výrazy Lambda.For more information about lambda expressions, see Lambda Expressions. Další příklady výrazů lambda a AddressOf přiřazení na delegáty, naleznete v tématu volný převod delegáta.For more examples of lambda expression and AddressOf assignments to delegates, see Relaxed Delegate Conversion.

NázevTitle PopisDescription
Postupy: Volání metody delegátaHow to: Invoke a Delegate Method Poskytuje příklad, který ukazuje, jak přidružit metodu delegáta a poté vyvolat tuto metodu prostřednictvím delegáta.Provides an example that shows how to associate a method with a delegate and then invoke that method through the delegate.
Postupy: Předání procedur jiné proceduře v jazyce Visual BasicHow to: Pass Procedures to Another Procedure in Visual Basic Ukazuje, jak mají být předány jiné proceduře jeden postup používání delegátů.Demonstrates how to use delegates to pass one procedure to another procedure.
Volný převod delegátaRelaxed Delegate Conversion Popisuje, jak můžete přiřadit typu Sub a funkce na delegáty nebo obslužné rutiny i v případě, že jejich podpisy nejsou stejnéDescribes how you can assign subs and functions to delegates or handlers even when their signatures are not identical
UdálostiEvents Poskytuje přehled o události v jazyce Visual Basic.Provides an overview of events in Visual Basic.