Komponenten für Windows-Runtime in C# und Visual Basic

Sie können verwalteten Code verwenden, um eigene Windows-Runtime Typen zu erstellen und in einer Windows-Runtime Komponente zu verpacken. Sie können Ihre Komponente in Universelle Windows-Plattform (UWP)-Apps verwenden, die in C++, JavaScript, Visual Basic oder C# geschrieben wurden. In diesem Thema werden die Regeln zum Erstellen einer Komponente und einige Aspekte der .NET-Unterstützung für die Windows-Runtime erläutert. Im Allgemeinen ist diese Unterstützung allen .NET-Programmierern klar. Wenn Sie aber eine Komponente erstellen, die mit JavaScript oder C++ verwendet werden soll, müssen Sie auf die Unterschiede bei der Unterstützung der Windows-Runtime durch diese Sprachen achten.

Wenn Sie eine Komponente nur für UWP-Apps erstellen, die in Visual Basic oder C# geschrieben wurden und die Komponente keine UWP-Steuerelemente enthält, sollten Sie die Klassenbibliotheksvorlage anstelle der Projektvorlage Windows-Runtime Komponente in Microsoft Visual Studio verwenden. Es gibt weniger Einschränkungen für eine einfache Klassenbibliothek.

Deklarieren von Typen in Komponenten für Windows-Runtime

Intern können die Windows-Runtime Typen in Ihrer Komponente alle .NET-Funktionen verwenden, die in einer UWP-App zulässig sind. Weitere Informationen finden Sie unter .NET für UWP-Apps.

Extern können die Member Ihrer Typen nur Windows-Runtime Typen für ihre Parameter und Rückgabewerte verfügbar machen. In der folgenden Liste werden die Einschränkungen für .NET-Typen beschrieben, die von einer Windows-Runtime Komponente verfügbar gemacht werden.

• Die Felder, Parameter und Rückgabewerte aller öffentlichen Typen und Member in Ihrer Komponente müssen Windows-Runtime Typen sein. Diese Einschränkung umfasst die Windows-Runtime Typen, die Sie erstellen, sowie Typen, die vom Windows-Runtime selbst bereitgestellt werden. Sie enthält auch eine Reihe von .NET-Typen. Die Einbeziehung dieser Typen ist Teil der Unterstützung, die .NET bereitstellt, um die natürliche Verwendung der Windows-Runtime in verwaltetem Code zu ermöglichen. Ihr Code scheint bekannte .NET-Typen anstelle der zugrunde liegenden Windows-Runtime Typen zu verwenden. Sie können z. B. .NET-Grundtypen wie Int32 und Double, bestimmte grundlegende Typen wie DateTimeOffset und Uri sowie einige häufig verwendete generische Schnittstellentypen wie IEnumerable<T> (IEnumerable(Of T) in Visual Basic) und IDictionary<TKey,TValue> verwenden. Beachten Sie, dass die Typargumente dieser generischen Typen Windows-Runtime Typen sein müssen. Dies wird in den Abschnitten "Übergeben von Windows-Runtime Typen an verwalteten Code und Übergeben von verwalteten Typen an die Windows-Runtime weiter unten in diesem Thema erläutert.

• Öffentliche Klassen und Schnittstellen können Methoden, Eigenschaften und Ereignisse enthalten. Sie können Stellvertretungen für Ihre Ereignisse deklarieren oder den EventHandler<T-Delegaten> verwenden. Eine öffentliche Klasse oder Schnittstelle kann nicht:

  • Generisch sein.
  • Implementieren Sie eine Schnittstelle, die keine Windows-Runtime Schnittstelle ist (Sie können jedoch eigene Windows-Runtime Schnittstellen erstellen und implementieren).
  • Abgeleitet von Typen, die sich nicht im Windows-Runtime befinden, z. B. "System.Exception" und "System.EventArgs".

• Alle öffentlichen Typen müssen über einen Stammnamespace verfügen, der dem Assemblynamen entspricht, und der Assemblyname darf nicht mit "Windows" beginnen.

  Tipp. Standardmäßig weisen Visual Studio-Projekte Namespacenamen auf, die dem Assemblynamen entsprechen. In Visual Basic wird die Namespace-Anweisung für diesen Standardnamespace nicht im Code angezeigt.

• Öffentliche Strukturen dürfen keine anderen Elemente als öffentliche Felder haben, und diese Felder müssen Werttypen oder Zeichenfolgen sein.

• Öffentliche Klassen müssen versiegelt sein (NotInheritable in Visual Basic). Wenn Ihr Programmiermodell Polymorphismus erfordert, können Sie eine öffentliche Schnittstelle erstellen und diese Schnittstelle für die Klassen implementieren, die polymorph sein müssen.

Debuggen der Komponente

Wenn Sowohl Ihre UWP-App als auch Ihre Komponente mit verwaltetem Code erstellt werden, können Sie beide gleichzeitig debuggen.

Wenn Sie Ihre Komponente als Teil einer UWP-App mit C++ testen, können Sie verwalteten und systemeigenen Code gleichzeitig debuggen. Der Standardwert ist nur systemeigener Code.

So debuggen Sie systemeigenen C++-Code und verwalteten Code

1. Öffnen Sie das Kontextmenü für Ihr Visual C++-Projekt, und wählen Sie "Eigenschaften" aus.
2. Wählen Sie auf den Eigenschaftenseiten unter "Konfigurationseigenschaften" die Option "Debuggen" aus.
3. Wählen Sie "Debuggertyp" aus, und ändern Sie im Dropdown-Listenfeld "Nur nativ" in "Gemischt" (verwaltet und nativ). Wählen Sie OK aus.
4. Legen Sie Haltepunkte in systemeigenem und verwaltetem Code fest.

Wenn Sie Ihre Komponente als Teil einer UWP-App mit JavaScript testen, befindet sich die Lösung standardmäßig im JavaScript-Debuggingmodus. In Visual Studio können Sie JavaScript und verwalteten Code nicht gleichzeitig debuggen.

So debuggen Sie verwalteten Code anstelle von JavaScript

1. Öffnen Sie das Kontextmenü für Ihr JavaScript-Projekt, und wählen Sie "Eigenschaften" aus.
2. Wählen Sie auf den Eigenschaftenseiten unter "Konfigurationseigenschaften" die Option "Debuggen" aus.
3. Wählen Sie "Debuggertyp" aus, und ändern Sie im Dropdown-Listenfeld "Skript Nur verwaltet" in "Nur verwaltet". Wählen Sie OK aus.
4. Legen Sie Haltepunkte in verwaltetem Code fest, und debuggen Sie sie wie gewohnt.

Übergeben Windows-Runtime Typen an verwalteten Code

Wie bereits im Abschnitt "Deklarieren von Typen in Windows-Runtime Komponenten" erwähnt, können bestimmte .NET-Typen in den Signaturen von Membern öffentlicher Klassen angezeigt werden. Dies ist Teil der Unterstützung, die .NET bereitstellt, um die natürliche Verwendung der Windows-Runtime in verwaltetem Code zu ermöglichen. Sie enthält primitive Typen und einige Klassen und Schnittstellen. Wenn Ihre Komponente aus JavaScript oder aus C++-Code verwendet wird, ist es wichtig zu wissen, wie Ihre .NET-Typen für den Aufrufer angezeigt werden. Siehe Exemplarische Vorgehensweise zum Erstellen einer C#- oder Visual Basic-Windows-Runtime-Komponente und zum Aufrufen von JavaScript für Beispiele mit JavaScript. In diesem Abschnitt werden häufig verwendete Typen erläutert.

In .NET weisen primitive Typen wie die Int32-Struktur viele nützliche Eigenschaften und Methoden auf, z. B. die TryParse-Methode . Im Gegensatz dazu weisen primitive Typen und Strukturen in der Windows-Runtime nur Felder auf. Wenn Sie diese Typen an verwalteten Code übergeben, scheinen sie .NET-Typen zu sein, und Sie können die Eigenschaften und Methoden von .NET-Typen wie gewohnt verwenden. In der folgenden Liste werden die Ersetzungen zusammengefasst, die automatisch in der IDE vorgenommen werden:

• Verwenden Sie für die Windows-Runtime Grundtypen Int32, Int64, Single, Double, Boolean, String (eine unveränderliche Auflistung von Unicode-Zeichen), Enum, UInt32, UInt64 und Guid den Typ desselben Namens im Systemnamespace.
• Verwenden Sie für UInt8 System.Byte.
• Verwenden Sie für Char16 "System.Char".
• Verwenden Sie für die IInspectable-Schnittstelle System.Object.

Wenn C# oder Visual Basic ein Sprachschlüsselwort für jeden dieser Typen bereitstellt, können Sie stattdessen das Sprachstichwort verwenden.

Zusätzlich zu primitiven Typen werden einige grundlegende, häufig verwendete Windows-Runtime Typen in verwaltetem Code als ihre .NET-Entsprechungen angezeigt. Angenommen, Ihr JavaScript-Code verwendet die Windows.Foundation.Uri-Klasse , und Sie möchten ihn an eine C#- oder Visual Basic-Methode übergeben. Der entsprechende Typ in verwaltetem Code ist die .NET System.Uri-Klasse und das ist der Typ, der für den Methodenparameter verwendet werden soll. Sie können feststellen, wann ein Windows-Runtime Typ als .NET-Typ angezeigt wird, da IntelliSense in Visual Studio den Windows-Runtime Typ ausblendet, wenn Sie verwalteten Code schreiben und den entsprechenden .NET-Typ darstellt. (In der Regel haben die beiden Typen denselben Namen. Beachten Sie jedoch, dass die Windows.Foundation.DateTime-Struktur in verwaltetem Code als System.DateTimeOffset und nicht als System.DateTime angezeigt wird.)

Bei einigen häufig verwendeten Sammlungstypen besteht die Zuordnung zwischen den Schnittstellen, die von einem Windows-Runtime Typ implementiert werden, und den Schnittstellen, die vom entsprechenden .NET-Typ implementiert werden. Wie bei den oben genannten Typen deklarieren Sie Parametertypen mithilfe des .NET-Typs. Dadurch werden einige Unterschiede zwischen den Typen ausgeblendet und das Schreiben von .NET-Code natürlicher.

In der folgenden Tabelle sind die am häufigsten verwendeten generischen Schnittstellentypen zusammen mit anderen allgemeinen Klassen- und Schnittstellenzuordnungen aufgeführt. Eine vollständige Liste der Windows-Runtime Typen, die .NET zugeordnet werden, finden Sie unter .NET-Zuordnungen von Windows-Runtime Typen.

Wenn ein Typ mehrere Schnittstellen implementiert, können Sie eine der Schnittstellen verwenden, die er als Parametertyp oder Rückgabetyp eines Elements implementiert. Sie können z. B. ein Wörterbuch int, eine Zeichenfolge> (Dictionary(Of Integer, String) in Visual Basic als IDictionary<int, string>, IReadOnlyDictionary<int, string> oder IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>> übergeben oder zurückgeben.<

Im Windows-Runtime werden IMap<K, V> und IMapView<K> mit IKeyValuePair durchlaufen. Wenn Sie sie an verwalteten Code übergeben, werden sie als "IDictionary<TKey", "TValue>" und "IReadOnlyDictionary<TKey", "TValue>" angezeigt. Daher verwenden Sie natürlich System.Collections.Generic.KeyValuePair<TKey, TValue>, um sie aufzulisten.

Die Darstellungsweise von Schnittstellen in verwaltetem Code wirkt sich auf die Darstellungsweise der Typen aus, die diese Schnittstellen implementieren. Beispielsweise implementiert die PropertySet-Klasse IMap<K, V>, die in verwaltetem Code als IDictionary<TKey, TValue> angezeigt wird. PropertySet wird wie bei der Implementierung von "IDictionary<TKey", "TValue>" anstelle von "IMap<K", "V>" angezeigt. Daher scheint es in verwaltetem Code eine Add-Methode zu haben, die sich wie die Add-Methode in .NET-Wörterbüchern verhält. Es scheint keine Insert-Methode zu haben. Dieses Beispiel finden Sie im Thema Walkthrough of creating a C# or Visual Basic Windows-Runtime component, and calling it from JavaScript.You can see this example in the topic Walkthrough of creating a C# or Visual Basic Windows-Runtime component, and calling it from JavaScript.

Übergeben von verwalteten Typen an die Windows-Runtime

Wie im vorherigen Abschnitt erläutert, können einige Windows-Runtime Typen als .NET-Typen in den Signaturen der Member Ihrer Komponente oder in den Signaturen Windows-Runtime Membern angezeigt werden, wenn Sie sie in der IDE verwenden. Wenn Sie .NET-Typen an diese Member übergeben oder als Rückgabewerte der Komponentenmitglieder verwenden, werden sie dem Code auf der anderen Seite als entsprechender Windows-Runtime Typ angezeigt. Beispiele für die Effekte, die beim Aufrufen der Komponente aus JavaScript auftreten können, finden Sie im Abschnitt "Zurückgeben von verwalteten Typen aus Ihrer Komponente" in der exemplarischen Vorgehensweise zum Erstellen einer C#- oder Visual Basic-Windows-Runtime Komponente und zum Aufrufen dieser Komponente aus JavaScript.

Überladene Methoden

In der Windows-Runtime können Methoden überladen werden. Wenn Sie jedoch mehrere Überladungen mit derselben Anzahl von Parametern deklarieren, müssen Sie das Attribut "Windows.Foundation.Metadata.DefaultOverloadAttribute " nur auf eine dieser Überladungen anwenden. Diese Überladung ist die einzige, die Sie aus JavaScript aufrufen können. Im folgenden Code ist beispielsweise die Überladung, die einen Int (Integer in Visual Basic) akzeptiert, die Standardüberladung.

public string OverloadExample(string s)
{
    return s;
}

[Windows.Foundation.Metadata.DefaultOverload()]
public int OverloadExample(int x)
{
    return x;
}

Public Function OverloadExample(ByVal s As String) As String
    Return s
End Function

<Windows.Foundation.Metadata.DefaultOverload> _
Public Function OverloadExample(ByVal x As Integer) As Integer
    Return x
End Function

[WICHTIG] JavaScript ermöglicht es Ihnen, einen beliebigen Wert an OverloadExample zu übergeben, und wandelt den Wert auf den Typ um, der vom Parameter benötigt wird. Sie können OverloadExample mit "forty-two", "42" oder 42.3 aufrufen, aber alle diese Werte werden an die Standardüberladung übergeben. Die Standardüberladung im vorherigen Beispiel gibt 0, 42 bzw. 42 zurück.

Sie können das DefaultOverloadAttribute-Attribut nicht auf Konstruktoren anwenden. Alle Konstruktoren in einer Klasse müssen unterschiedliche Parameternummern aufweisen.

Implementieren von IStringable

Ab Windows 8.1 enthält die Windows-Runtime eine IStringable-Schnittstelle, deren einzelne Methode IStringable.ToString eine grundlegende Formatierung unterstützt, die mit der von Object.ToString bereitgestellten Methode vergleichbar ist. Wenn Sie IStringable in einem öffentlichen verwalteten Typ implementieren, der in eine Windows-Runtime Komponente exportiert wird, gelten die folgenden Einschränkungen:

• Sie können die IStringable-Schnittstelle nur in einer "Class implements"-Beziehung definieren, z. B. den folgenden Code in C#:

  public class NewClass : IStringable
  

  Oder den folgenden Visual Basic-Code:

  Public Class NewClass : Implements IStringable
  

• IStringable kann nicht auf einer Schnittstelle implementiert werden.

• Sie können keinen Parameter als IStringable-Typ deklarieren.

• IStringable kann nicht der Rückgabetyp einer Methode, Eigenschaft oder eines Felds sein.

• Sie können Ihre IStringable-Implementierung nicht aus Basisklassen ausblenden, indem Sie eine Methodendefinition wie die folgende verwenden:

  public class NewClass : IStringable
  {
     public new string ToString()
     {
        return "New ToString in NewClass";
     }
  }
  

  Stattdessen muss die IStringable.ToString-Implementierung immer die Basisklassenimplementierung überschreiben. Sie können eine ToString-Implementierung nur ausblenden, indem Sie sie in einer stark typierten Klasseninstanz aufrufen.

Asynchrone Vorgänge

Um eine asynchrone Methode in Ihrer Komponente zu implementieren, fügen Sie "Async" am Ende des Methodennamens hinzu und geben eine der Windows-Runtime Schnittstellen zurück, die asynchrone Aktionen oder Vorgänge darstellen: IAsyncActionWithProgress TProgress<>, IAsyncOperation<TResult> oder IAsyncOperationWithProgress<TResult, TProgress.>

Sie können .NET-Aufgaben (die Task-Klasse und die generische Task<TResult-Klasse>) verwenden, um Ihre asynchrone Methode zu implementieren. Sie müssen eine Aufgabe zurückgeben, die einen laufenden Vorgang darstellt, z. B. eine Aufgabe, die von einer asynchronen Methode zurückgegeben wird, die in C# oder Visual Basic geschrieben wurde, oder eine Aufgabe, die von der Task.Run-Methode zurückgegeben wird. Wenn Sie einen Konstruktor zum Erstellen der Aufgabe verwenden, müssen Sie die Task.Start-Methode aufrufen, bevor Sie sie zurückgeben.

Eine Methode, die await (Await in Visual Basic) verwendet wird, erfordert das async Schlüsselwort (Async in Visual Basic). Wenn Sie eine solche Methode aus einer Windows-Runtime Komponente verfügbar machen, wenden Sie das async Schlüsselwort auf den Delegaten an, den Sie an die Run-Methode übergeben.

Für asynchrone Aktionen und Vorgänge, die die Abbruch- oder Fortschrittsberichterstattung nicht unterstützen, können Sie die Erweiterungsmethode "WindowsRuntimeSystemExtensions.AsAsyncAction " oder "AsAsyncOperation<TResult> " verwenden, um die Aufgabe in die entsprechende Schnittstelle einzuschließen. Der folgende Code implementiert beispielsweise eine asynchrone Methode mithilfe der Task.Run<TResult-Methode> , um eine Aufgabe zu starten. Die AsAsyncOperation<TResult-Erweiterungsmethode> gibt die Aufgabe als Windows-Runtime asynchronen Vorgang zurück.

public static IAsyncOperation<IList<string>> DownloadAsStringsAsync(string id)
{
    return Task.Run<IList<string>>(async () =>
    {
        var data = await DownloadDataAsync(id);
        return ExtractStrings(data);
    }).AsAsyncOperation();
}

Public Shared Function DownloadAsStringsAsync(ByVal id As String) _
     As IAsyncOperation(Of IList(Of String))

    Return Task.Run(Of IList(Of String))(
        Async Function()
            Dim data = Await DownloadDataAsync(id)
            Return ExtractStrings(data)
        End Function).AsAsyncOperation()
End Function

Der folgende JavaScript-Code zeigt, wie die Methode mithilfe eines WinJS.Promise-Objekts aufgerufen werden kann. Die An die anschließende Methode übergebene Funktion wird ausgeführt, wenn der asynchrone Aufruf abgeschlossen ist. Der stringList-Parameter enthält die Liste der Zeichenfolgen, die von der DownloadAsStringAsync-Methode zurückgegeben werden, und die Funktion führt die erforderliche Verarbeitung aus.

function asyncExample(id) {

    var result = SampleComponent.Example.downloadAsStringAsync(id).then(
        function (stringList) {
            // Place code that uses the returned list of strings here.
        });
}

Verwenden Sie für asynchrone Aktionen und Vorgänge, die die Abbruch- oder Fortschrittsberichterstattung unterstützen, die AsyncInfo-Klasse, um eine gestartete Aufgabe zu generieren und die Abbruch- und Statusberichtsfunktionen der Aufgabe mit den Abbruch- und Fortschrittsberichtsfeatures der entsprechenden Windows-Runtime Schnittstelle zu verbinden. Ein Beispiel, das sowohl die Abbruch- als auch die Statusberichterstattung unterstützt, finden Sie unter Walkthrough of creating a C# or Visual Basic Windows-Runtime component, and calling it from JavaScript.For an example that supports both cancellation and progress reporting, see Walkthrough of creating a C# or Visual Basic Windows-Runtime component, and calling it from JavaScript.

Beachten Sie, dass Sie die Methoden der AsyncInfo-Klasse verwenden können, auch wenn Ihre asynchrone Methode die Abbruch- oder Fortschrittsberichterstattung nicht unterstützt. Wenn Sie eine Visual Basic-Lambda-Funktion oder eine anonyme C#-Methode verwenden, geben Sie keine Parameter für die Token- und IProgress<T-Schnittstelle> an. Wenn Sie eine C#-Lambda-Funktion verwenden, geben Sie einen Tokenparameter an, ignorieren Sie ihn jedoch. Das vorherige Beispiel, das die AsAsyncOperation TResult-Methode> verwendet hat, sieht wie folgt aus, wenn Sie stattdessen die Methodenüberladung "AsyncInfo.Run<TResult>(Func<CancellationToken, Task<TResult>>)" verwenden.<

public static IAsyncOperation<IList<string>> DownloadAsStringsAsync(string id)
{
    return AsyncInfo.Run<IList<string>>(async (token) =>
    {
        var data = await DownloadDataAsync(id);
        return ExtractStrings(data);
    });
}

Public Shared Function DownloadAsStringsAsync(ByVal id As String) _
    As IAsyncOperation(Of IList(Of String))

    Return AsyncInfo.Run(Of IList(Of String))(
        Async Function()
            Dim data = Await DownloadDataAsync(id)
            Return ExtractStrings(data)
        End Function)
End Function

Wenn Sie eine asynchrone Methode erstellen, die optional die Abbruch- oder Fortschrittsberichterstattung unterstützt, sollten Sie Überladungen hinzufügen, die keine Parameter für ein Abbruchtoken oder die IProgress<T-Schnittstelle> aufweisen.

Auslösen von Ausnahmen

Sie können jeden Ausnahmetyp auslösen, der in .NET für Windows-Apps enthalten ist. Sie können ihre eigenen öffentlichen Ausnahmetypen in einer Windows-Runtime Komponente nicht deklarieren und auslösen, aber Sie können nicht öffentliche Typen deklarieren und auslösen.

Wenn die Komponente die Ausnahme nicht behandelt, wird eine entsprechende Ausnahme im Code ausgelöst, der die Komponente aufgerufen hat. Die Art und Weise, wie die Ausnahme für den Aufrufer angezeigt wird, hängt davon ab, wie die Anrufsprache die Windows-Runtime unterstützt.

• In JavaScript wird die Ausnahme als Objekt angezeigt, in dem die Ausnahmemeldung durch eine Stapelablaufverfolgung ersetzt wird. Wenn Sie Ihre App in Visual Studio debuggen, wird der ursprüngliche Meldungstext im Dialogfeld "Debuggerausnahme" angezeigt, der als "WinRT-Informationen" gekennzeichnet ist. Sie können nicht über JavaScript-Code auf den ursprünglichen Nachrichtentext zugreifen.

  Tipp. Derzeit enthält die Stapelablaufverfolgung den verwalteten Ausnahmetyp, es wird jedoch nicht empfohlen, die Ablaufverfolgung zu analysieren, um den Ausnahmetyp zu identifizieren. Verwenden Sie stattdessen einen HRESULT-Wert, wie weiter unten in diesem Abschnitt beschrieben.

• In C++ wird die Ausnahme als Plattform-Ausnahme angezeigt. Wenn die HResult-Eigenschaft der verwalteten Ausnahme dem HRESULT einer bestimmten Plattform-Ausnahme zugeordnet werden kann, wird die spezifische Ausnahme verwendet. andernfalls wird eine Platform::COMException-Ausnahme ausgelöst. Der Nachrichtentext der verwalteten Ausnahme ist für C++-Code nicht verfügbar. Wenn eine bestimmte Plattform-Ausnahme ausgelöst wurde, wird der Standardmeldungstext für diesen Ausnahmetyp angezeigt. andernfalls wird kein Nachrichtentext angezeigt. Siehe Ausnahmen (C++/CX).

• In C# oder Visual Basic ist die Ausnahme eine normale verwaltete Ausnahme.

Wenn Sie eine Ausnahme aus der Komponente auslösen, können Sie es für einen JavaScript- oder C++-Aufrufer einfacher machen, die Ausnahme zu behandeln, indem Sie einen nicht öffentlichen Ausnahmetyp auslösen, dessen HResult-Eigenschaftswert spezifisch für Ihre Komponente ist. Das HRESULT ist für einen JavaScript-Aufrufer über die Number-Eigenschaft des Ausnahmeobjekts und für einen C++-Aufrufer über die COMException::HResult-Eigenschaft verfügbar.

Deklarieren und Auslösen von Ereignissen

Wenn Sie einen Typ deklarieren, der die Daten für Ihr Ereignis enthält, leiten Sie von Object anstelle von EventArgs ab, da EventArgs kein Windows-Runtime Typ ist. Verwenden Sie "EventHandler<TEventArgs>" als Ereignistyp, und verwenden Sie den Ereignisargumenttyp als generisches Typargument. Lösen Sie das Ereignis genauso wie in einer .NET-Anwendung aus.

Wenn Ihre Windows-Runtime Komponente aus JavaScript oder C++ verwendet wird, folgt das Ereignis dem Windows-Runtime Ereignismuster, das diese Sprachen erwarten. Wenn Sie die Komponente aus C# oder Visual Basic verwenden, wird das Ereignis als normales .NET-Ereignis angezeigt. Ein Beispiel wird in walkthrough of creating a C# or Visual Basic Windows-Runtime component, and calling it from JavaScript bereitgestellt.

Wenn Sie benutzerdefinierte Ereignisaccessoren implementieren (ein Ereignis mit dem Benutzerdefinierten Schlüsselwort in Visual Basic deklarieren), müssen Sie dem Windows-Runtime Ereignismuster in Ihrer Implementierung folgen. Siehe benutzerdefinierte Ereignisse und Ereignisaccessoren in Windows-Runtime Komponenten. Beachten Sie, dass es sich beim Behandeln des Ereignisses aus C# oder Visual Basic-Code immer noch um ein normales .NET-Ereignis handelt.

Nächste Schritte

Nachdem Sie eine Windows-Runtime Komponente für ihre eigene Verwendung erstellt haben, stellen Sie möglicherweise fest, dass die darin enthaltene Funktionalität für andere Entwickler nützlich ist. Sie haben zwei Optionen zum Packen einer Komponente für die Verteilung an andere Entwickler. Siehe Verteilen einer verwalteten Windows-Runtime Komponente.

Weitere Informationen zu Visual Basic- und C#-Sprachfeatures und .NET-Unterstützung für die Windows-Runtime finden Sie in der Visual Basic- und C#-Dokumentation.

Problembehandlung

Zugehörige Themen

• .NET für UWP-Apps
• Exemplarische Vorgehensweise zum Erstellen einer Komponente für Windows-Runtime in C# oder Visual Basic und Aufrufen der Komponente über JavaScript