Freigeben über

Erstellen von Windows-Runtime-Komponenten in C# und Visual Basic

  • Artikel

Ab .NET Framework 4,5 können Sie verwalteten Code verwenden, um eigene Windows-Runtime-Typen zu erstellen, verpackt in einer Komponente für Windows-Runtime. Sie können die Komponente in Windows Store-Apps mit C++, JavaScript, Visual Basic oder C# verwenden. In diesem Artikel werden die Regeln zum Erstellen einer Komponente und einige Aspekte der .NET Framework-Unterstützung für Windows-Runtime erläutert. Im Allgemeinen ist diese Unterstützung für alle .NET Framework-Programmierer transparent. Wenn Sie jedoch eine Komponente erstellen, die mit JavaScript oder C++ verwendet werden soll, müssen Sie auf die Unterschiede in der Unterstützung von Windows-Runtime durch diese Sprachen achten.

Hinweis

Wenn Sie eine Komponente nur für die Verwendung in Windows Store-Anwendungen mit Visual Basic oder C# erstellen und die Komponente keine Windows Store-Steuerelemente enthält, sollten Sie die Verwendung der Vorlage Klassenbibliothek (Windows Store-Apps) anstelle der Vorlage Windows-Runtime-Komponente erwägen. Eine einfache Klassenbibliothek weist weniger Einschränkungen auf.

Dieser Artikel umfasst folgende Abschnitte:

  • Typen in Komponenten für Windows-Runtime deklarieren

  • Debuggen der Komponente

  • Übergeben von Windows-Runtime-Typen an verwalteten Code

  • Übergeben von verwalteten Typen an Windows-Runtime

  • Übergeben von Arrays

  • Überladene Methoden

  • Implementieren von IStringable

  • Asynchrone Vorgänge

  • Auslösen von Ausnahmen

  • Deklarieren und Auslösen von Ereignissen

  • Nächste Schritte

Deklarieren von Typen in Windows-Runtime-Komponenten

Intern können die Windows-Runtime-Typen Ihrer Komponente alle .NET Framework-Funktionalitäten verwenden, die in einer Windows Store-App zulässig sind. Weitere Informationen finden Sie unter .NET für Windows Store-Apps – Übersicht. 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 sind die Einschränkungen für .NET Framework-Typen aufgeführt, die von Windows-Runtime-Komponenten verfügbar gemacht werden können.

  • Felder, Parameter und Rückgabewerte aller öffentlichen Typen und Member in der Komponente müssen Windows-Runtime-Typen sein.

    Diese Einschränkung schließt die von Ihnen erstellen Windows-Runtime-Typen und die Typen, die von Windows-Runtime bereitgestellt werden, ein. Außerdem trifft sie auf einige .NET Framework-Typen zu. Die Aufnahme dieser Typen ist Teil der Unterstützung, die .NET Framework bietet, um die natürliche Verwendung Windows-Runtime in verwaltetem Code zu aktivieren: Es scheint, als verwende der Code bekannte .NET Framework-Typen anstelle der zugrunde liegenden Windows-Runtime-Typen. Beispielsweise können Sie .NET Framework-primitive Typen wie Int32 und Double, bestimmte Grundlagentypen 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 später in den Abschnitten Übergeben von Windows-Runtime-Typen an verwalteten Code und Übergeben von verwalteten Typen an Windows-Runtime näher erläutert.

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

    • generisch sein.

    • eine Schnittstelle implementieren, die keine Windows-Runtime-Schnittstelle ist. (Sie können allerdings Ihre eigenen Windows-Runtime-Schnittstellen erstellen und implementieren.)

    • von Typen abgeleitet sein, die nicht in Windows-Runtime vorkommen, wie System.Exception und System.EventArgs.

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

    Hinweis

    Standardmäßig entsprechen die Namespacenamen in Visual Studio-Projekten den Assemblynamen. In Visual Basic wird die Namespace-Anweisung für diesen Standardnamespace nicht im Code gezeigt.

  • Öffentliche Strukturen können nur öffentliche Felder enthalten, und diese Felder müssen Werttypen oder Zeichenfolgen sein.

  • Öffentliche Klassen müssen sealed sein (NotInheritable in Visual Basic). Erfordert das Programmiermodell Polymorphie, so können Sie eine öffentliche Schnittstelle erstellen und diese in den Klassen implementieren, die polymorph sein müssen.

Debuggen der Komponente

Wurden Ihre Windows Store Anwendung und Ihre Komponente mit verwaltetem Code erstellt, dann können Sie sie gleichzeitig debuggen.

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

So debuggen Sie systemeigenem C++-Code und verwalteten Code:

  1. Öffnen Sie das Kontextmenü für das Visual C++-Projekt, und wählen Sie Eigenschaften aus.

  2. Wählen Sie auf den Eigenschaftenseiten Konfigurationseigenschaften und dann Debugging aus.

  3. Wählen Sie erst Debuggertyp aus, und ändern Sie dann in der Dropdownliste Nur systemeigen zu Gemischt (verwaltet und systemeigen). Klicken Sie auf OK.

  4. Legen Sie Haltepunkte im systemeigenen und verwalteten Code fest.

Wenn Sie die Komponente als Teil einer Windows Store-App mit JavaScript testen, befindet sich die Projektmappe in JavaScript-Debugmodus. In Visual Studio und Visual Studio Express ist das gleichzeitige Debuggen von JavaScript und verwaltetem Code nicht möglich.

So debuggen Sie verwalteten Code statt JavaScript

  1. Öffnen Sie das Kontextmenü für das JavaScript-Projekt und wählen Sie Eigenschaften aus.

  2. Wählen Sie auf den Eigenschaftenseiten Konfigurationseigenschaften und dann Debugging aus.

  3. Wählen Sie Debuggertyp aus, und ändern Sie dann in der Dropdownliste Nur Skript zu Nur verwaltet. Klicken Sie auf OK.

  4. Legen Sie Haltepunkte im verwalteten Code fest und debuggen Sie wie gewohnt.

Übergeben von Windows-Runtime-Typen an verwalteten Code

Wie bereits im Abschnitt Typen in Komponenten für Windows-Runtime deklarieren erwähnt, können bestimmte .NET Framework-Typen in den Signaturen von Membern öffentlicher Klassen erscheinen. Dies ist ein Teil der Unterstützung, die .NET Framework bietet, um die natürliche Verwendung von Windows-Runtime in verwaltetem Code zu aktivieren. Darin sind primitive Typen und einige Klassen und Schnittstellen enthalten. Wenn eine Komponente von JavaScript oder von C++-Code verwendet wird, müssen Sie wissen, wie die .NET Framework-Typen für den Aufrufer angezeigt werden. Weitere Beispiele mit JavaScript finden Sie unter Exemplarische Vorgehensweise: Erstellen einer einfachen Komponente in C# oder Visual Basic und Aufrufen dieser Komponente über JavaScript. In diesem Abschnitt werden häufig verwendete Typen beschrieben.

In .NET Framework haben primitive Typen wie die Int32-Struktur viele nützliche Eigenschaften und Methoden, wie die TryParse-Methode. Im Gegensatz dazu haben primitive Typen und Strukturen in Windows-Runtime nur Felder. Wenn Sie diese Typen an verwalteten Code übergeben, verhalten sie sich wie .NET Framework-Typen, und Sie können deren Eigenschaften und Methoden wie gewohnt verwenden. Die folgende Liste fasst die Ersetzungen zusammen, die automatisch in der IDE ausgeführt werden:

  • Für die primitiven Windows-Runtime-Typen Int32, Int64, Single, Double, Boolean, String (eine unveränderliche Auflistung von Unicode-Zeichen), Enum, UInt32, UInt64 und Guid sollte der Typ desselben Namens im System-Namespace verwendet werden.

  • Für UInt8 sollte System.Byte verwendet werden.

  • Für Char16 sollte System.Char verwendet werden.

  • Für die IInspectable-Schnittstelle sollte System.Object verwendet werden.

Wenn C# oder Visual Basic ein Schlüsselwort für alle Typen bereitstellt, können Sie stattdessen das Schlüsselwort verwenden.

Zusätzlich zu den primitiven Typen erscheinen einige grundlegende, häufig verwendete Windows-Runtime-Typen in verwaltetem Code als ihre .NET Framework-Entsprechungen. Wenn Ihr JavaScript-Code beispielsweise die Windows.Foundation.Uri-Klasse verwendet und Sie diese einer C#- oder Visual Basic-Methode übergeben wollen, entspricht der Typ in verwaltetem Code der .NET Framework-System.Uri-Klasse ein. Das ist der Typ für den Methodenparameter. Sie können ganz einfach feststellen, wann ein Windows-Runtime-Typ als .NET Framework-Typ angezeigt wird: IntelliSense in Visual Studio blendet den Windows-Runtime-Typ aus, wenn Sie verwalteten Code schreiben, und zeigt den entsprechenden .NET Framework-Typ an. (Normalerweise 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.)

Für einige häufig verwendete Auflistungstypen findet die Zuordnung zwischen den Schnittstellen, die von einem Windows-Runtime-Typ implementiert werden, und Schnittstellen, die vom entsprechenden .NET Framework-Typ implementiert werden, statt. Wie bei den bereits erwähnten Typen deklarieren Sie Parametertypen, indem Sie den .NET Framework-Typ verwenden. So werden einige Unterschiede ausgeblendet, und das Schreiben von .NET Framework-Code wirkt natürlicher. In der folgenden Tabelle sind die häufigsten dieser generischen Schnittstellentypen zusammen mit anderen allgemeinen Klassen- und Schnittstellenzuordnungen aufgeführt. Sie finden eine vollständige Liste der Windows-Runtime-Typen, die von .NET Framework zugeordnet werden, unter .NET Framework-Zuordnungen von Windows-Runtime-Typen.

Windows-Runtime

.NET Framework

IIterable<T>

IEnumerable<T>

IVector<T>

IList<T>

IVectorView<T>

IReadOnlyList<T>

IMap<K, V>

IDictionary<TKey, TValue>

IMapView<K, V>

IReadOnlyDictionary<TKey, TValue>

IKeyValuePair<K, V>

KeyValuePair<TKey, TValue>

IBindableIterable

IEnumerable

IBindableVector

IList

Windows.UI.Xaml.Data.INotifyPropertyChanged

System.ComponentModel.INotifyPropertyChanged

Windows.UI.Xaml.Data.PropertyChangedEventHandler

System.ComponentModel.PropertyChangedEventHandler

Windows.UI.Xaml.Data.PropertyChangedEventArgs

System.ComponentModel.PropertyChangedEventArgs

    

Wenn ein Typ mehr als eine Schnittstelle implementiert, können Sie jede der Schnittstellen verwenden, die als Parametertyp oder Rückgabetyp eines Members implementiert wird. Beispielsweise können Sie Dictionary<int, string> (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.

Wichtig

JavaScript verwendet die Schnittstelle, die zuerst in der Liste der Schnittstellen angezeigt wird, die ein verwalteter Typ implementiert. Wenn Sie beispielsweise Dictionary<int, string> an JavaScript-Code zurückgeben, wird es stets als IDictionary<int, string> angezeigt, unabhängig vom angegebenen Rückgabetyp. Dies bedeutet, dass die erste Schnittstelle Member enthalten muss, die auch auf den neueren Schnittstellen erscheinen. Ansonsten ist ein Member nicht für JavaScript sichtbar.

In Windows-Runtime werden IMap<K, V> und IMapView<K, V> durchlaufen, indem IKeyValuePair verwendet wird. Wenn Sie sie an verwalteten Code übergeben, erscheinen sie als IDictionary<TKey, TValue> und IReadOnlyDictionary<TKey, TValue>. Also können Sie System.Collections.Generic.KeyValuePair<TKey, TValue> für die Auflistung verwenden.

Die Darstellungsweise von Schnittstellen in verwaltetem Code wirkt sich auf die Darstellungsweise der Typen aus, die diese Schnittstellen implementieren. Die Klasse PropertySet implementiert beispielsweise IMap<K, V>, was in verwaltetem Code als IDictionary<TKey, TValue> angezeigt wird. Es hat den Anschein, als hätte PropertySet IDictionary<TKey, TValue> anstelle von IMap<K, V> implementiert. In verwaltetem Code verfügt die Klasse anscheinend über eine Add-Methode, die sich wie die Add-Methode in .NET Framework-Wörterbüchern verhält. Es erscheint nicht, eine Insert-Methode verfügen. Sie finden dieses Beispiel in dem Artikel Exemplarische Vorgehensweise: Erstellen einer einfachen Komponente in C# oder Visual Basic und Aufrufen dieser Komponente über JavaScript.

Übergeben von verwalteten Typen an Windows-Runtime

Wie bereits erwähnt, können einige Windows-Runtime-Typen als .NET Framework-Typen in den Signaturen des Komponentenmembers oder in den Signaturen von Windows-Runtime-Membern erscheinen, wenn Sie sie in der IDE verwenden. Wenn Sie die .NET Framework-Typen an diese Member übergeben oder als Rückgabewerte der Komponentenmember verwenden, werden sie vom Code auf der anderen Seite als der entsprechende Windows-Runtime-Typ aufgefasst. Sie finden einige Beispiele für die Auswirkungen beim Aufruf Ihrer Komponente in JavaScript im Abschnitt "Rückgabe von verwalteten Typen aus der Komponente" in Exemplarische Vorgehensweise: Erstellen einer einfachen Komponente in C# oder Visual Basic und Aufrufen dieser Komponente über JavaScript.

Übergeben von Arrays

In Windows-Runtime sind alle Parameter entweder für die Eingabe oder die Ausgabe vorgesehen. Es gibt keine ref-Parameter (ByRef in Visual Basic). Der Arrayinhalt, der an die Windows-Runtime-Komponente übergeben wird, muss entweder für die Eingabe oder die Ausgabe gedacht sein. Das heißt, Arrays dürfen nicht änderbar sein. Wird ein Array als Wert (ByVal in Visual Basic) übergeben, müssen Sie das ReadOnlyArrayAttribute-Attribut oder das Attribut WriteOnlyArrayAttribute anwenden, um die Priorität festzulegen. Weitere Informationen finden Sie unter Übergeben von Arrays an eine Windows-Runtime-Komponente.

Überladene Methoden

In Windows-Runtime können Methoden überladen werden. Wenn Sie jedoch mehrere Überladungen mit der gleichen Anzahl von Parametern deklarieren, müssen Sie das Windows.Foundation.Metadata.DefaultOverloadAttribute-Attribut auf nur eine dieser Überladungen anwenden. Nur diese Überladung kann von JavaScript aufgerufen werden. Im folgenden Code ist die Überladung, die int nimmt (Integer in Visual Basic), die standardmäßige Ü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

Warnung

JavaScript ermöglicht die Übergabe aller Werte an OverloadExample und wandelt den Wert in den Typ um, der vom Parameter benötigt wird. Sie können OverloadExample mit "zweiundvierzig", "42" oder 42,3 aufrufen. Alle diese Werte werden an die Überladung übergeben. Die standardmäßige Überladung im vorherigen Beispiel gibt 0, 42 und 42 zurück.

Sie können das DefaultOverloadAttribute-Attribut nicht bei Konstruktoren anwenden. Alle Konstruktoren in einer Klasse müssen verschiedene Parameteranzahlen aufweisen.

Implementieren von IStringable

Ab Windows 8,1 enthält Windows-Runtime eine IStringable-Schnittstelle, deren einzige Methode, IStringable.ToString, grundlegende Unterstützung bei der Formatierung bietet, die vergleichbar mit der von Object.ToString ist. Wenn Sie sich entschließen, IStringable in einem öffentlich verwalteten Typ zu 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, wie z. B.

    public class NewClass : IStringable

    in C# oder

    Public Class NewClass : Implements IStringable

    in Visual Basic.

  • Sie können IStringable nicht in einer Schnittstelle implementieren.

  • Sie können einen Parameter nicht als Typ IStringable deklarieren.

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

  • Sie können die Implementierung von IStringable nicht vor Basisklassen verbergen, indem Sie eine Methodendefinition wie die folgende verwenden:

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

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

Beachten Sie, dass unter bestimmten Bedingungen Aufrufe von systemeigenem Code zu einem verwalteten Typ, der IStringable implementiert oder seine ToString-Implementierung verbirgt, zu unerwartetem Verhalten führen können.

Asynchrone Vorgänge

Für die Implementierung einer asynchronen Methode in Ihrer Komponente müssen Sie "Async" am Ende des Methodennamens hinzufügen und eine der Windows-Runtime-Schnittstellen zurückgeben, die asynchrone Aktionen oder Operationen darstellen: IAsyncAction, IAsyncActionWithProgress<TProgress>, IAsyncOperation<TResult> oder IAsyncOperationWithProgress<TResult, TProgress>.

Sie können .NET Framework-Aufgaben (die Task-Klasse und generische Klasse Task<TResult>) verwenden, um die asynchrone Methode zu implementieren. Sie müssen eine Aufgabe zurückgeben, die eine laufende Operation darstellt, wie 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 wurde. Wenn Sie für die Aufgabenerstellung einen Konstruktor verwenden, müssen Sie seine Task.Start-Methode aufrufen, bevor Sie sie zurückgeben.

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

Für asynchrone Aktionen und Vorgänge, die weder die Abbruch- noch die Fortschrittsberichterstattung unterstützen, können Sie die Erweiterungsmethoden WindowsRuntimeSystemExtensions.AsAsyncAction oder AsAsyncOperation<TResult> verwenden, um die Aufgabe in der entsprechenden Schnittstelle zu umschließen. Beispielsweise implementiert der folgende Code eine asynchrone Methode, indem er die Task.Run-Methode für den Aufgabenstart nutzt. Die Erweiterungsmethode AsAsyncOperation<TResult> gibt die Aufgabe als asynchronen Windows-Runtime-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 mit einem WinJS.Promise-Objekt aufgerufen werden kann. Die Funktion, die an die then-Methode übergeben wird, wird nach Abschluss des asynchronen Aufrufs ausgeführt. Der stringList-Parameter enthält die Liste von Zeichenfolgen, die von der DownloadAsStringAsync-Methode zurückgegeben werden. Die Funktion übernimmt die erforderliche Verarbeitung.

function asyncExample(id) {

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

Für asynchrone Aktionen und Vorgänge, die die Abbruch- oder die Fortschrittsberichterstattung unterstützen, können Sie die AsyncInfo-Klasse verwenden, um eine angefangene Aufgabe zu generieren und die Abbruch- und Fortschrittsberichterstattungsfunktionen der Aufgabe mit den Abbruch- und Fortschrittsberichterstattungsfunktionen der entsprechenden Windows-Runtime-Schnittstelle zu verknüpfen. Sie finden ein Beispiel für die Unterstützung der Abbruch- und Fortschrittsberichterstattung unter Exemplarische Vorgehensweise: Erstellen einer einfachen Komponente in C# oder Visual Basic und Aufrufen dieser Komponente über JavaScript.

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

        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 das Hinzufügen von Überladungen erwä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 Store-Apps – APIs enthalten ist. Sie können keine eigenen öffentlichen Ausnahmetypen in einer Windows-Runtime-Komponente deklarieren, 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 Windows-Runtime-Unterstützung der aufrufenden Sprache bestimmt, wie die Ausnahme dem Aufrufer angezeigt wird.

  • In JavaScript tritt die Ausnahme als Objekt auf, in dem die Ausnahmemeldung durch eine Stapelüberwachung ersetzt ist. Wenn Sie Ihre App in Visual Studio debuggen, wird der Originaltext der Meldung im Ausnahmedialogfeld des Debuggers unter "WinRT Information" angezeigt. Sie können mit JavaScript-Code nicht auf den Originaltext der Meldung zugreifen.

    Hinweis

    Momentan enthält die Stapelüberwachung den verwalteten Ausnahmetyp, aber es ist nicht empfehlenswert, diese zu untersuchen, um den Ausnahmetyp zu identifizieren. Verwenden Sie statt dessen einen HRESULT-Wert (wie weiter unter in diesem Abschnitt beschrieben).

  • In C++ tritt die Ausnahme als Plattformausnahme auf. Wenn die Eigenschaft HResult der verwalteten Ausnahme dem HRESULT einer bestimmten Plattformausnahme zugeordnet werden kann, wird diese verwendet. Andernfalls wird eine Platform::COMException-Ausnahme ausgelöst. Auf den Meldungstext der verwalteten Ausnahme kann im C++-Code nicht zugegriffen werden. Wenn eine bestimmte Plattformausnahme ausgelöst wurde, erscheint der Meldungstext für diesen Ausnahmetyp. Andernfalls wird kein Meldungstext ausgegeben. Informationen hierzu finden Sie unter Ausnahmen (C++/CX).

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

Wenn Sie in Ihrer Komponente eine Ausnahme auslösen, sollten Sie einen nicht öffentlichen Ausnahmetyp verwenden, dessen HResult-Eigenschaft speziell für Ihre Komponente gilt, damit die Ausnahme leichter von einem JavaScript- oder C++-Aufrufer verwaltet werden kann. HRESULT ist für einen JavaScript-Aufrufer über die Eigenschaft number des Ausnahmeobjekts verfügbar, und für einen C++-Aufrufer über die Eigenschaft COMException::HResult.

Hinweis

Verwenden Sie einen negativen Wert für Ihr HRESULT. Ein positiver Wert wird als Erfolg interpretiert, sodass im JavaScript- oder C++-Aufrufer keine Ausnahme ausgelöst wird.

Deklarieren und Auslösen von Ereignissen

Wenn Sie einen Typ deklarieren, um die Daten für das Ereignis aufzunehmen, leiten Sie dies von Object und nicht von EventArgs ab, da EventArgs kein Windows-Runtime-Typ ist. Verwenden Sie EventHandler<TEventArgs> als Typ des Ereignisses, und verwenden Sie den Ereignisargumenttyp als das allgemeine Typargument. Lösen Sie das Ereignis ebenso wie in einer .NET Framework-Anwendung aus.

Wenn die Windows-Runtime Komponente von JavaScript oder C++ verwendet wird, folgt das Ereignis dem Windows-Runtime-Ereignismuster, das diese Sprachen erwarten. Wenn Sie die Komponente von C# oder Visual Basic verwenden, erscheint das Ereignis als normales .NET Framework-Ereignis. Unter Exemplarische Vorgehensweise: Erstellen einer einfachen Komponente in C# oder Visual Basic und Aufrufen dieser Komponente über JavaScript finden Sie ein entsprechendes Beispiel.

Wenn Sie benutzerdefinierte Ereignisaccessoren implementieren (in Visual Basic ein Ereignis mit dem Schlüsselwort Custom deklarieren), müssen Sie dem Windows-Runtime-Ereignismuster in der Implementierung folgen. Weitere Informationen finden Sie unter Benutzerdefinierte Ereignisse und Ereignisaccessoren der Windows-Runtime-Komponenten. Beachten Sie, dass das Ereignis auch dann als einfaches .NET Framework-Ereignis erscheint, wenn Sie C#- oder Visual Basic-Code verwenden.

Nächste Schritte

Nach Erstellen einer Komponente für Windows-Runtime für eigene Zwecke stellen Sie möglicherweise fest, dass die Funktionalität, die diese kapselt, für andere Entwickler nützlich ist. Zum Verpacken einer Komponente für die Verteilung an andere Entwickler stehen zwei Möglichkeiten zur Verfügung. Weitere Informationen finden Sie unter Verteilen einer verwalteten Windows-Runtime-Komponente.

Weitere Informationen zu Visual Basic- und C#-Sprachfunktionen und .NET Framework-Unterstützung für Windows-Runtime finden Sie unter Sprachreferenz zu Visual Basic und C#.

Siehe auch

Konzepte

.NET für Windows Store-Apps – Übersicht

.NET für Windows Store-Apps – APIs

Exemplarische Vorgehensweise: Erstellen einer einfachen Komponente in C# oder Visual Basic und Aufrufen dieser Komponente über JavaScript

Erstellen von Windows-Runtime-Komponenten

Benutzerdefinierte Ereignisse und Ereignisaccessoren der Windows-Runtime-Komponenten

Übergeben von Arrays an eine Windows-Runtime-Komponente

.NET Framework-Zuordnungen von Windows-Runtime-Typen

Diagnostizieren von Fehlerbedingungen der Windows-Runtime-Komponente

Sprachreferenz zu Visual Basic und C#