Dieser Artikel wurde maschinell übersetzt.
Komponenten für Windows-Runtime
Komponenten für Windows-Runtime in einer .NET-Umgebung
Das neuartige Programm bekannt als Windows Store app — optimiert, um auf Windows 8 Geräten ausgeführt — hat den Standardwert ansehen mit einem Vollbild-Fenster und keine störende Chrom, also der Inhalt im Mittelpunkt steht. Windows Store apps unterstützen flüssig-Layouts, die sich anzupassen und zu einer Vielzahl von Bildschirmgrößen und Auflösungen skalieren. Sie bieten eine Note-erste Erfahrung und bietet vollen Unterstützung für die herkömmliche Tastatur und Maus.
Windows Store apps laufen auf einen neuen Satz von APIs namens Windows-Runtime (WinRT). Windows Runtime stellt Komponenten, die als Teil des Betriebssystems Windows 8 zusammen mit Drittanbieter-Komponenten erstellt werden, die Sie selbst entwickeln können. Obwohl einige Kernkomponenten von Windows Runtime von desktop-Anwendungen zugänglich sind, sind Windows-Runtime-Komponenten von Drittanbietern nur von innerhalb der Windows-8-Umgebung verfügbar. WinRT Typen werden mit WinRT-Metadaten-Dateien haben die Erweiterung .winmd beschrieben. Diese Dateien mit dem gleichen standard der Microsoft .NET Framework verwendet für die Bereitstellung von Metadatendefinitionen und Semantik für Klassen, ECMA-335 codiert (siehe bit.ly/sLILI).
Schnell navigieren Sie zu den Typdefinitionen auf einer Windows-8-Maschine in das Verzeichnis mit Systemdateien für Windows (normalerweise c:\windows\system32) ändern. Einen Ordner innerhalb dieser DirecTory namens WinMetadata enthält alle die Typdefinitionen. Sie können das ILDasm.exe-Dienstprogramm verwenden, um die Typen zu erkunden. Öffnen Sie eine Eingabeaufforderung Visual Studio 2012, navigieren Sie zum Ordner c:\windows\system32\WinMetadata, und geben Sie Folgendes in der Befehlszeile:
Ildasm.exe windows.web.winmd
Sie sollten ein Ergebnis ähnlich sehen Abbildung 1. Sie können das ILDasm.exe-Dienstprogramm verwenden, um alle Namespaces und Typen definiert, dass bestimmte Windows-Runtime-Komponente zu überprüfen.
.png)
Abbildung 1 Inspektion WinRT Typen
Was ist interessant, dass kein in der Datei enthalten Code; nur Metadateninformationen sind verfügbar. Die Komponente ist Teil des zugrunde liegenden Betriebssystems. Es ist sehr wahrscheinlich, mit systemeigenen Code geschrieben. Ein einzigartiges Feature namens Sprache Projektion erlaubt Windows-Runtime-Komponenten (systemeigene und verwaltete) aus jeder beliebigen Sprache zugegriffen werden, die Windows Store app Entwicklung unterstützt.
Projektion und Mapping
Viele Sprachen, einschließlich c#, Visual Basic, C++ und JavaScript, wurden aktualisiert mit Windows 8 Sprache Projektion zu unterstützen. Dadurch können Windows-Runtime-Komponenten auf natürliche Weise mit mehreren Sprachen zugegriffen werden. Projektion behandelt Verfügbarmachen eines WinRT-Typs als ein Objekt oder eine Klasse, die die Sprache, die verwendet wird, um die Windows-Speicher-app zu entwickeln ist. Der folgende Code greift eine native Windows-Runtime-Komponente direkt aus einer Windows-Speicher-app mit c# erstellt:
var ui = new CameraCaptureUI();
Die CameraCaptureUI ist eine Windows-Runtime-Komponente. Die Komponente nicht verwalteten c# Typ, aber es problemlos abgerufen und von c#-Code verwiesen wird, als wäre es. Dadurch ist, weil die CLR einen Runtime Callable Wrapper (RCW) für die Windows-Runtime-Komponente über seine Metadaten automatisch generiert und als native CLR-Typ zu verwaltetem Code angezeigt werden. Weitere Informationen hierzu finden Sie in den MSDN Library-Artikel, "Runtime Callable Wrapper," unter bit.ly/PTiAly. Der RCW macht es einfach und unkompliziert mit diesen Komponenten interagieren. Das Gegenteil trifft ebenfalls zu. Projektion ermöglicht mit verwaltetem Code verwiesen werden, wie ein C++ erstellten Windows Runtime-Komponente geben von systemeigenem Code und in ein JavaScript-Objekt in HTML/JavaScript-Projekten.
Grundlegende Typen werden automatisch als c#-Typen angezeigt. Die Windows-Runtime hat einen ELEMENT_TYPE_STRING-Typ, der in .NET Code als String-Objekt angezeigt wird. Der Skalar ELEMENT_TYPE_I4 erscheint als ein Int32. Die CLR wird auch nehmen bestimmte WinRT und ordnen sie als ihre .NET-Entsprechungen im Code angezeigt. Beispielsweise der WinRT-Typ für eine Auflistung mit fester Größe ist IVector <T>, aber diese Art erscheint automatisch als eine IList <T> in .NET-Code. Ein WinRT HRESULT erscheint das .NET Framework als einen Ausnahmetyp. Die CLR wird automatisch diese Typen zwischen verwalteten und systemeigenen Vertretungen gemarshallt. Einige Typen wie Ströme, können explizit mit eine Reihe von Erweiterungsmethoden, die von der CLR bereitgestellte konvertiert werden. Für eine vollständige Liste von Typen, die auf diese Weise zugeordnet sind, finden Sie im MSDN Dev Center Thema ".NET Framework Zuordnungen der WinRT Datentypen" bei bit.ly/PECJ1W.
Diese integrierten Features ermöglichen Entwicklern, ihre eigenen Windows-Runtime-Komponenten mithilfe von verwaltetem Code mit c# und Visual Basic zu erstellen. Visuelle Studio 2012 bietet eine Vorlage zum Erstellen von Windows-Runtime-Komponenten von Visual Basic, c# und C++. Diese Komponenten können verbraucht und aus einer anderen Sprache der Windows Runtime, einschließlich JavaScript aufgerufen werden. Aus diesem Grund müssen Sie einige spezifischen Regeln um eine Windows-Laufzeitkomponente in c# erstellen befolgen.
Nach den Regeln spielen
Im allgemeinen beziehen sich die Regeln für das Erstellen von WinRT Typen in c# auf alle öffentlich sichtbaren Typen und Member, die Ihre Komponente bietet. Die Einschränkungen vorhanden sein, da die Common Language Runtime-Komponente in Windows durch das Typsystem WinRT gebunden werden müssen. Der vollständige Satz von Regeln wird im Thema MSDN Dev Center "erstellen Windows Runtime Komponenten in c# und Visual Basic" aufgeführt, bei bit.ly/OWDe2A. Die Felder, Parameter und Rückgabewerte, die Sie verfügbar machen, müssen alle WinRT Typen sein (es ist gut zu .NET Typen verfügbar machen, die automatisch WinRT Typen zugeordnet sind). Sie erstellen Ihre eigenen WinRT Typen verfügbar machen diese Typen, wiederum, folgen den gleichen Regeln.
Eine weitere Einschränkung ist, dass alle öffentlichen Klassen oder Schnittstellen, die Sie verfügbar machen nicht generisch sein oder jeder nicht-WinRT-Schnittstelle implementieren. Sie müssen nicht von nicht-WinRT Typen abgeleitet werden. Der Stammnamespace für Windows-Runtime-Komponenten muss den Namen den Assembly übereinstimmen, die wiederum mit "Windows" nicht gestartet werden kann Öffentliche Strukturen sind auch auf nur öffentliche Felder verfügen, die Werttypen sind beschränkt. Polymorphismus ist nicht für WinRT Typen verfügbar, und Sie können die nächsten kommen setzt WinRT Schnittstellen; Sie müssen als versiegelt alle Klassen deklarieren, die von Ihrer Windows-Laufzeitkomponente öffentlich verfügbar gemacht werden.
Diese Einschränkungen möglicherweise Grund für einen alternativen Ansatz zur Integration von Komponenten in Ihre apps zu betrachten, besonders wenn man mit Legacycode, die bedeutende Umgestaltung erfordern würde. Mögliche alternative Ansätze wird später erläutert. Die Einschränkungen sind wichtig, damit die Windows-Runtime-Komponenten können Funktion entsprechend innerhalb der WinRT-Umgebung und können verwiesen und aus alle Sprachumgebungen, einschließlich C++ und JavaScript aufgerufen.
Die Thumbnail-Generator
Eine einfache app wird zeigen, wie eine verwaltete Windows-Runtime-Komponente mit c# erstellen und verbrauchen es von einer Windows-Speicher-app mit c#, JavaScript oder C++ gebaut. Die Komponente nimmt einen Verweis auf eine Bilddatei von der WinRT IStorageFile-Schnittstelle übergeben. Anschließend wird eine 100 x 100 Pixel-Miniaturansicht des Bildes erstellt und speichert sie in der Windows-Speicher-app lokalen Speicher. Es gibt schließlich einen URI, der auf die Miniaturansicht zeigt. Die Schritte umfassen:
- Erstellen Sie die Projektmappe in Visual Studio 2012.
- Bauen Sie die Common Language Runtime-Komponente in Windows.
- Erstellen Sie das sprachspezifischen-Projekt in c#, JavaScript oder C++.
- Verweisen Sie die Common Language Runtime-Komponente in Windows.
- Richten Sie die Benutzeroberfläche für jedes Projekt damit den Benutzer ein Bild auswählen.
- Zeigen Sie das Bild.
- Rufen Sie die Windows-Runtime-Komponente.
- Anzeigen der Miniaturansicht.
Erstellen Sie das Projekt und die Lösung
Aus innerhalb von Visual Studio 2012 beginnen Sie mit Angabe der Sprache Ihrer Wahl (in diesem Fall, c#) und wählen Sie die Windows-Speicher-app-Vorlagen. Eine Vorlage, die speziell zur Erzeugung von Windows-Runtime-Komponenten vorhanden ist. Ich wählte diese Vorlage und erstellt eine Komponente namens ThumbnailLibrary mit einer Lösung mit dem gleichen Namen wie im Abbildung 2.
.png)
Abbildung 2 Erstellen der Windows-Komponente Runtime-Projekts
In diesem Beispiel erstellt habe ich eine Klasse namens ThumbnailMaker. Eine private Methode gibt eine Aufgabe, um die Miniaturansicht asynchron zu generieren:
private static async Task<Uri> GenerateThumbnail(IStorageFile file)
{
}
Der erste Schritt innerhalb der Methode ist, öffnen Sie die Datei aus dem Speicher und verwenden die WinRT BitmapDecoder Bild-Stream decodieren:
using (var fileStream = await file.OpenReadAsync())
{
var decoder = await BitmapDecoder.CreateAsync(fileStream);
}
Als nächstes wird eine Datei im lokalen Speicher für die app, die Miniaturansicht zu halten erstellt. Es erhält den Namen "Miniaturansicht" mit der gleichen Erweiterung wie die Quelldatei. Die Option zum Generieren eines eindeutigen Namens wird sicherstellen, dass mehrere Miniaturansichten generiert werden können, ohne zu überschreiben frühere Operationen:
var thumbFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(
string.Format("thumbnail{0}", file.FileType),
CreationCollisionOption.GenerateUniqueName);
Ein Encoder wird aus dem decodierten Stream erstellt. Es einfach zu 100 x 100 Pixel die Bitmap skaliert und anschließend in das Dateisystem geschrieben:
using (var outputStream =
await thumbFile.OpenAsync(FileAccessMode.ReadWrite))
{
var encoder = await BitmapEncoder.CreateForTranscodingAsync(
outputStream,
decoder);
encoder.BitmapTransform.ScaledHeight = 100;
encoder.BitmapTransform.ScaledWidth = 100;
await encoder.FlushAsync();
}
Der letzte Schritt ist eine URL zu erstellen, die auf die Datei verweist. Das spezielle ms-Appdata-Präfix wird verwendet, um auf die Dateien im lokalen Speicher zu verweisen. Weitere Informationen zum weiterführenden Inhalt mithilfe von URIs, lesen Sie das Thema MSDN Dev Center, "Wie auf Verweis Inhalte" an erlernen bit.ly/SS711o. Das Thema für HTML und JavaScript ist zwar die Konvention, die Zugriff auf Ressourcen verwendet unabhängig davon welche Sprachoption, die Sie verwenden:
const string URI_LOCAL = "ms-appdata:///Local/{0}";
var storageUrl = string.Format(URI_LOCAL, thumbFile.Name);
return new Uri(storageUrl, UriKind.Absolute);
In c# geschriebene Windows-Runtime-Komponenten können keine .NET-Funktionalität, die für das Windows-Speicher-app-Profil zulässig ist. Wie bereits erwähnt, müssen jedoch öffentliche Typen und Schnittstellen nur WinRT Typen verfügbar machen. Da Aufgabe nicht gültiger WinRT Typ ist, muss die öffentliche Methode für die Komponente der WinRT IAsyncOperation <T> offen. Geben Sie stattdessen. Glücklicherweise gibt es eine Erweiterungsmethode um die .NET Vorgangsart leicht in der WinRT IAsyncOperation-Typ zu konvertieren, wie hier gezeigt:
public IAsyncOperation<Uri> GenerateThumbnailAsync(IStorageFile file)
{
return GenerateThumbnail(file).AsAsyncOperation();
}
Mit der Komponente können nun komplett, Sie zu machen, bereit für den Verzehr von Windows Store apps kompilieren.
Unter der Haube: Metadaten
Bauen Sie Runtime-Komponente in Windows zu und navigieren Sie dann in das Ausgabeverzeichnis, indem mit der rechten Maustaste auf den Projektnamen im Projektmappen-Explorer und wählen "Ordner in Windows_Explorer öffnen." Wenn Sie zum Unterverzeichnis bin/Debug navigieren, finden Sie, dass eine Datei mit Metadaten für die Komponente mit dem Namen ThumbnailLibary.winmd erstellt wurde. Wenn Sie die Datei mit ILDasm.exe öffnen, sehen Sie, dass eine Schnittstelle für die Komponente mit dem Rückgabetyp generiert wurde:
Windows.Foundation.IAsyncOperation <Windows.Foundation.Uri>
Das sind die WinRT-Typen, die für die Komponente zugeordnet wurden. Es ist möglich, auch die Metadaten zu überprüfen und sehen, wie die CLR WinRT Typen Projekte. Öffnen Sie die gleichen Metadatendatei mit der speziellen/Project-Erweiterung wie folgt:
Ildasm.exe/Project ThumbnailLibrary.winmd
Der Rückgabetyp wird jetzt folgendermaßen angezeigt:
Windows.Foundation.IAsyncOperation <System.Uri>
Beachten Sie, dass die WinRT Version des URI auf .NET umgerechnet projiziert wird. Die Signatur die Methode macht alle gültige WinRT Typen für Windows Store apps zu konsumieren, sondern aus verwaltetem Code die Typen als .NET Klassen angezeigt. Die Erweiterung/Project können Sie prüfen, wie die Projektion die Signatur der verwalteten und nicht verwalteten Windows-Runtime-Komponenten auswirkt.
Verbrauchen aus c#
Verbrauchen die Komponente aus c# sollte vertraut sein, denn es nicht anders ist als Verweis auf eine Bibliothek-Klasse. Hinweis: Es gibt keinen Grund, eine Windows-Runtime-Komponente zu erstellen, wenn Ihr einzige Ziel anderen verwalteten Code ist. Sie einfach auf das WinRT-Projekt verweisen und dann die Klassen zu konsumieren, wie aus einer normalen c#-Klassenbibliothek. Im Beispielcode hat das CSharpThumbnails-Projekt einen Verweis auf die ThumbnailLibrary. Das XAML für die Hauptseite definiert eine Schaltfläche für den Benutzer ein Foto auswählen und enthält zwei Bilder um das Originalbild und die Miniaturansicht zu hosten. Abbildung 3 zeigt das grundlegende XAML-Markup.
Abbildung 3 XAML für Windows-Speicher-App mit c# gebaut
<Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<TextBlock
Text="Tap the button below to choose an image to generate a thumbnail."
Style="{StaticResource BodyTextStyle}"
Margin="12"/>
<Button Content="Pick Image" Grid.Row="1" Margin="12"
Click="Button_Click_1"/>
<TextBlock Text="Thumbnail:" Style="{StaticResource BodyTextStyle}"
Grid.Row="2" Margin="12"/>
<Image x:Name="ThumbnailImage" HorizontalAlignment="Left" Stretch="None"
Grid.Row="3" Margin="12"/>
<TextBlock Text="Source Image:" Style="{StaticResource BodyTextStyle}"
Grid.Row="4" Margin="12"/>
<Image x:Name="SourceImage" HorizontalAlignment="Left" Stretch="None"
Grid.Row="5" Margin="12"/>
</Grid>
Codebehind erstellt eine Instanz der Komponente WinRT FileOpenPicker und konfiguriert, dass Bilder durchsuchen:
var openPicker = new FileOpenPicker
{
ViewMode = PickerViewMode.Thumbnail,
SuggestedStartLocation = PickerLocationId.PicturesLibrary
};
openPicker.FileTypeFilter.Add(".jpg");
openPicker.FileTypeFilter.Add(".jpeg");
openPicker.FileTypeFilter.Add(".png");
Der Picker nennt und ein einfacher Dialog wird angezeigt, wenn keine gültigen Dateien gefunden werden:
var file = await openPicker.PickSingleFileAsync();
if (file == null)
{
var dialog = new MessageDialog("No image was selected.");
await dialog.ShowAsync();
return;
}
Das Bild wird dann für die Anzeige verdrahtet. Die Datei wird in die Windows Runtime-Komponente einen Thumbnail generieren übergeben und wieder übergebene URI wird verwendet, um das thumbnail-Bild für die Anzeige festgelegt:
using (var fileStream = await file.OpenReadAsync())
{
SourceImage.Source = LoadBitmap(fileStream);
var maker = new ThumbnailMaker();
var stream = RandomAccessStreamReference
.CreateFromUri(await maker.GenerateThumbnailAsync(file));
var bitmapImage = new BitmapImage();
bitmapImage.SetSource(await stream.OpenReadAsync());
ThumbnailImage.Source = bitmapImage;
}
Abbildung 4 zeigt das Ergebnis dieses gegen ein Foto nahm ich einen Kürbis ich geschnitzt laufen.
.png)
Abbildung 4 Windows Store ein Bild App gebaut mit c#
Verarbeiten von JavaScript
Im Gegensatz zu normalen c#-Klassenbibliotheken kann Windows-Runtime-Komponenten aus einer beliebigen Sprache aufgerufen werden, die zum Erstellen von Windows-Store apps (Kern, den Windows-Runtime-Komponenten, die Teil des Betriebssystems sind von desktop-Anwendungen aufgerufen werden kann) unterstützt wird. Um dies in Aktion sehen, können Sie die Miniaturansicht app mit HTML und JavaScript erstellen. Dieses Projekt wird JavaScriptThumbnails im Beispiel Codedownload bezeichnet. Der erste Schritt ist die Schaffung eine leere app, mit die leere Vorlage Windows Store für Anwendungen, die mithilfe von JavaScript erstellt. Nachdem die Vorlage erstellt wurde, können Sie einfaches HTML-Markup die Seite mithilfe der vorhandenen default.html Datei definieren:
<p>Tap the button below to choose an image to generate a thumbnail.</p>
<button id="pick">Pick Image</button>
<br/><br/>
<p>Thumbnail:</p>
<img id="thumbnail" src="images/logo.png" alt="Thumbnail"/>
<p>Source Image:</p>
<img id="sourceImage" src="images/logo.png" alt="Image"/>
Fügen Sie anschließend einen Verweis auf die WinRT-Projekt (ThumbnailLibrary), genauso wie auf einem normalen c#-Projekt. Erstellen Sie das Projekt, so dass Sie IntelliSense für die neu referenzierte Komponente verwenden können. Sie können den Quellcode für das Projekt zu sehen, das Äquivalent zum Öffnen der Dateiauswahl und auswählen des Abbilds JavaScript verweisen. Erstellen Sie eine Instanz der Komponente in verwalteten Windows Runtime, generieren die Miniaturansicht und für den Benutzer anzuzeigen, verwenden Sie das folgende JavaScript:
var thumb = new ThumbnailLibrary.ThumbnailMaker();
thumb.generateThumbnailAsync(file).then(function (fileUrl) {
var thumbImage = document.getElementById("thumbnail");
thumbImage.src = fileUrl.rawUri;
thumbImage.alt = thumbImage.src;
});
Wie Sie sehen können, ist der API-Aufruf fast identisch, die in c#-Projekt verwendet. Projektion automatisch die Methodensignatur von Pascal-Schreibweise in geändert Höckerschreibweise (der Aufruf die Miniaturansicht generieren beginnt mit einen Kleinbuchstaben wie die allgemeine Konvention in JavaScript-Code ist), und eine spezielle Bibliothek namens "Versprechen" wird verwendet, um die asynchrone Natur des Codes mit einer dann oder fertig-Anweisung behandeln. Erfahren Sie mehr über Versprechungen durch das Lesen des MSDN Dev Center-Themas "Quickstart: Mit Versprechungen,"am bit.ly/OeWQCQ. Im Image-Tag unterstützt URLs aus der Box, damit die URL übergeben zurück von der Common Language Runtime-Komponente in Windows einfach direkt auf das Src-Attribut auf das Bild gesetzt ist.
Eine wichtige Einschränkung für die Verwendung von verwalteter Komponenten im JavaScript-Code ist, dass Sie gleichzeitig JavaScript und verwalteten Code Debuggen nicht möglich. Wenn Sie Ihre Komponente Debuggen müssen, müssen mit der rechten Maustaste des Projekts und wählen Sie die Registerkarte Debuggen und wählen Sie dann eine Debug-Option, die verwalteten Code enthalten. Dies wird in Abbildung 5 dargestellt.
.png)
Abbildung 5 Einstellen der Debugoptionen für ein JavaScript-Projekt
Verbrauchen von C++
Sie können auch verwaltete Windows-Laufzeitkomponenten von systemeigenen Projekten nutzen. C++ teilt die gleiche Rendering-Engine wie c#, so dass das CPlusPlusThumbnails-Projekt das gleiche XAML als das CSharpThumbnails-Projekt hat. Das Codebehind ist anders, weil das Projekt die systemeigene C++-Sprachoption verwendet. C++ verwendet eine spezielle Parallelität-Bibliothek, um asynchrone Operationen zu behandeln. Erfahren Sie mehr über diese Bibliothek durch das Lesen im MSDN Dev Center-Themas "Asynchrone Programmierung in C++," am bit.ly/MUEqnR. Der resultierende Code sieht ähnlich wie die Versprechungen, die Sie in den JavaScript-Versionen gesehen hast:
ThumbnailMaker^ maker = ref new ThumbnailMaker();
create_task(maker->GenerateThumbnailAsync(file)).then([this](Uri^ uri)
{
RandomAccessStreamReference^ thumbnailStream =
RandomAccessStreamReference::CreateFromUri(uri);
create_task(thumbnailStream->OpenReadAsync()).then([this](
IRandomAccessStream^ imageStream) {
auto image = ref new BitmapImage();
image->SetSource((IRandomAccessStream^)imageStream);
ThumbnailImage->Source = image;
});
});
Wenn Sie die app ausführen, finden Sie es sieht aus und verhält sich genauso wie auf die c#-Version.
Die Kosten zu verstehen
Erstellen von Windows-Runtime-Komponenten mithilfe von verwaltete Sprachen ist ein leistungsstarkes Feature. Diese Funktion kommt zu Kosten, und es ist wichtig, die Kosten zu verstehen, wenn Sie es in Projekten verwenden. Windows Store apps mit systemeigenen Code erstellt benötigen keine die CLR ausgeführt. Diese apps können direkt in der Windows 8-Umgebung ausgeführt. Entsprechend erfordern nicht apps entwickelt mit Hilfe von JavaScript auch eine Abhängigkeit von der CLR. Sie beruhen auf der Rendering-Engine Trident und Chakra-JavaScript-Engine (die gleichen Motoren, dass Laufwerk Internet Explorer 10) zum Rendern von HTML und CSS und JavaScript-Code zu interpretieren. Windows Store apps gebaut mit JavaScript können native Windows-Runtime-Komponenten direkt aufrufen, aber wenn sie verwaltete Windows-Runtime-Komponenten aufrufen, sie nehmen auf eine Abhängigkeit der CLR.
Code für die verwaltete Windows-Runtime-Komponente werden kompilierte just-in-Time (JIT), wenn es von der CLR-JIT-Compiler zuerst zugegriffen wird. Dies könnte einige der ersten Verzögerungszeit verursachen, die darauf zugegriffen wird. Ein Vorkompilierung-Dienst namens NGen Griffe kompilieren Module installiert auf dem Gerät, aber es kann einen ganzen Tag dauern, schließlich alle Module in einem Paket zu kompilieren, nachdem Sie es installiert haben. Die Common Language Runtime verwaltet auch Speicher durch die Garbagecollection durchführt. Der Garbage Collector (GC) den Heap in drei Generationen unterteilt und sammelt nur Teile des Heaps mit einem Algorithmus entwickelt, um die Leistung zu optimieren.
Die GC hält möglicherweise Ihre app, während er Arbeit leistet. Dies führt oft nur eine kleine Verzögerung, die nicht für den Endbenutzer erkennbar ist und intensivere Müll-Sammlung-Operationen können oft im Hintergrund laufen. Haben Sie einen großen genug Heap (wenn der verwaltete Teil des Codes Hunderte von Megabyte oder mehr in Speicherobjekte verweist), hält der Garbagecollection möglicherweise die app lange genug, damit der Benutzer die mangelnde Reaktionsfähigkeit wahrnehmen.
Die meisten dieser Überlegungen sind bereits vorhanden, wenn beim Erstellen einer verwalteten Windows-Speicher-app. Verwalteter Code fügt neue sorgen hinzu, wenn Sie es an einen Windows-Speicher-app gebaut mit C++ oder JavaScript hinzufügen. Es ist wichtig zu erkennen, dass Ihre app zusätzliche CPU verbraucht und Arbeitsspeicher bei der Einführung von Komponenten verwalteten. Es kann auch dauern, eine erkennbare Leistungseinbußen, abhängig von der Komponente (obwohl viele apps auf verwaltete Verweise ohne spürbare Auswirkungen zu nehmen). Der Vorteil ist, dass du musst keinen Speicher selbst verwalten kümmern und natürlich Sie, legacy-Code und Fähigkeiten nutzen können.
Alternativen für verwaltete Projekte
Wenn Sie Windows Store apps mithilfe von verwaltetem Code (c#- oder Visual Basic) erstellen, haben Sie mehrere Alternativen zu Windows-Runtime-Komponenten erstellen, die nicht die gleichen Einschränkungen haben. Sie können leicht wiederverwendbare Komponenten, die durch eine einfache c#-Klassenbibliothek erstellen. Wenn die Klassenbibliothek für Windows Store apps eingebaut ist, können Sie das Projekt aus Ihrem eigenen Windows-Speicher-app verweisen. Die Schaffung einer Klassenbibliothek entfernt auch die Einschränkungen nur WinRT Typen verfügbar machen und nicht könnend Features verwenden, die nicht Teil des Typsystems WinRT wie Generika sind.
Eine andere Alternative zu betrachten ist die Portable Klasse Bibliothek (PCL). Dies ist ein spezieller Typ einer Klassenbibliothek, die aus einer Vielzahl von Plattformen ohne Neukompilierung verwiesen werden kann. Verwenden diese Option, wenn Sie code haben Sie zwischen anderen Plattformen austauschen wollen — wie Windows Presentation Foundation, Silverlight und Windows Phone — und Ihren Windows-Speicher-app. Erfahren Sie mehr über die PCL durch das Lesen meiner dreiteiligen Blog-Serie "Understanding the Portable Bibliothek von Chasing ICommand," am bit.ly/pclasslib.
Wenn Ihre Komponente mehr als nur Code enthält, sollten Sie eine Erweiterung-SDK erstellen. Dies ist eine besondere Form der SDK, die Visual Studio-2012 als ein einzelnes Element behandeln können. Das Paket kann Quellcode, Vermögenswerte, Dateien und sogar Binärdateien, einschließlich Windows-Runtime-Komponenten enthalten. Zusätzlich können Sie die Entwurfszeit-Erweiterungen um es einfacher zu verarbeiten und nutzen Ihre Komponente innerhalb Visual Studio 2012. Erweiterung-SDKs können nicht im Windows-Speicher gebucht werden, weil sie nicht eigenständig sind apps. Erfahren Sie mehr über Erweiterung SDKs im MSDN Library Artikel, "so wird 's gemacht: Erstellen eines Software Development Kit"auf bit.ly/L9Ognt.
Verwalteten Windows-Runtime-Komponenten erstellen
Mit so vielen möglichen Alternativen macht es überhaupt sinnvoll, Windows-Runtime-Komponenten mithilfe von verwaltetem Code zu erstellen? Ja — aber betrachten Sie die folgenden Fragen. Die erste Frage ist, ob Sie Ihre Komponenten von Windows Store apps mit JavaScript oder systemeigenen Code mithilfe von C++ geschrieben verwiesen werden brauchen. Wenn dies nicht der Fall ist, gibt es keinen Grund, eine Windows-Runtime-Komponente verwenden, wenn Klassenbibliotheken und andere Optionen stattdessen arbeiten werden. Wenn dies der Fall ist, legen Sie eine Windows-Runtime-Komponente, um von allen verfügbaren Sprachoptionen genutzt werden.
Die nächste Frage ist, ob Sie Ihre Komponente in C++ erstellen oder verwalteten Code verwenden sollten. Es gibt eine Reihe von Gründen, verwalteten Code zu verwenden. Ein Grund könnte sein, dass Ihr Team mehr Erfahrung in c# oder Visual Basic als in C++ und Nutzung des vorhandenen Know-hows um die Komponenten zu bauen kann. Ein weiterer Grund könnte sein, dass Sie bestehende Algorithmen in einer verwalteten Sprache, die leichter zu Port sein wird, wenn Sie dieselbe Sprachauswahl halten geschrieben. Es gibt einige Aufgaben, die möglicherweise leichter zu schreiben und Verwalten mithilfe von verwalteten Sprachen und Klassenbibliotheken anstelle von systemeigenen Code, und Mannschaften, die zum Entwickeln von verwalteten Sprachen werden weitaus produktiver.
Nachbereitung, in diesem Artikel, die Sie gelernt haben, dass Sie wiederverwendbare Windows-Runtime-Komponenten unter Verwendung erstellen können verwaltet, c#- und Visual Basic-Code. Diese Komponenten problemlos verwiesen und verbraucht aus Windows Store apps in jeder Sprache, einschließlich JavaScript und C++ geschrieben. Während es wichtig, die Regeln zum Erstellen von Windows-Runtime-Komponenten und die Auswirkungen der Wahl mit verwalteten Code zu verstehen ist, bietet diese Option eine einmalige Gelegenheit, die Sprache Ihrer Wahl und nutzen Sie vorhandenen Code zum Erstellen von Komponenten, die von allen Windows-Speicher apps verwendet werden kann.
Jeremy Likness *ist wichtigster Berater für Wintellect LLC in Atlanta. Er ist ein Dreijahres-Microsoft Silverlight MVP und Autor mehrerer Bücher, darunter die bevorstehende "Building Windows 8 Anwendungen mit c# und XAML" (Addison-Wesley Professional, 2012). Lernen Sie mehr online bei bit.ly/win8design und folgen Sie seinen Blog unter csharperimage.jeremylikness.com. *
Unser Dank gilt den folgenden technischen Experten für die Durchsicht dieses Artikels: Layla Driscoll, Shawn Farkas, John Garland, Jeff Prosise und Jeffrey Richter