Dieser Artikel wurde maschinell übersetzt.

XAML und C++

Einführung in C++/CX und XAML

Andy Rich

Code zuerst eignet sich hervorragend für einen schnellen Sortieren-Algorithmus entwerfen aber es ist nicht unbedingt der beste Weg, eine gut aussehende UI zu machen und die UI-Technologie von Microsoft für C++-Entwickler bereitgestellt hat diese Voreinstellung übernommen. Das letzte bedeutende Upgrade auf Microsoft-UI-Technologie für C++, veröffentlicht im Jahr 2008 wurde eine neue Reihe von MFC-Steuerelemente, die gestylten Multifunktionsleisten-Steuerelemente bereitgestellt. Davor eine Technologie von Microsoft .NET Framework-basierte Benutzeroberfläche Windows Forms mit Visual Studio .NET im Februar 2002 erschien. Wenn leistungsfähig, konzentrierten beide Technologien in erster Linie auf den zugrunde liegenden Code, die Elemente der Benutzeroberfläche erstellt und forderten enge Kopplung der Daten und der Benutzeroberfläche.

In den letzten Jahren haben die c#- und Visual Basic-Entwickler bedeutende Upgrades auf ihre UI-Technologie in Form von XAML-basierte UI-Frameworks (Windows Presentation Foundation oder WPF und Silverlight) genossen. Diese Frameworks brachte Entwickler neue Optionen im UI-Design, gibt ihnen die Freiheit, ihre Algorithmen zu codieren, ohne sich Gedanken über das wie die Benutzeroberfläche dargestellt werden würde und die Freiheit ihrer Benutzeroberfläche zu entwickeln, ohne sich Gedanken über den Code hinter sich. Endlich können mit Windows 8, C++-Entwickler eine moderne, XAML-basierte UI-Framework zum Erstellen von Anwendungen für Windows 8 nutzen.

Warum XAML?

XAML ist eine XML-basierte Markup-Sprache, mit dem Sie das Aussehen Ihrer Anwendung zu definieren, ohne zu verstehen, wie die Benutzeroberfläche im Code erstellt wird. Windows Runtime (WinRT) analysiert diese Informationen zur Laufzeit, die entsprechende Steuerelement-Klassen erstellt und erstellt die UI-Struktur. Code kann diese Objekte bearbeiten und, wenn richtig erstellt, das Look And Feel der Benutzeroberfläche können erheblich geändert werden ohne Codebehind überhaupt zu berühren. Dies erleichtert eine Arbeitsteilung zwischen einem Entwickler, der an den Code hinter den Kulissen arbeitet und ein UI-Designer, konzentriert sich auf das Erscheinungsbild der Anwendung selbst.

Visuelle Studio 2012 auch ist eng mit Mischung, eine macht­Ful Designertools speziell optimiert für das Arbeiten mit XAML und HTML. Blend bietet mehr WYSIWYG-Kontrolle (einschliesslich Animation) und weitere Eigenschaften auf XAML-Objekte als integrierte Visual Studio-Designer verfügbar.

Warum C + + / CX?

Entwickler haben eine Reihe von Technologien zur Auswahl, wenn Sie eine Windows-Speicher-app schreiben: HTML und JavaScript, c# oder Visual Basic mit XAML und C++. In C++ können Sie Anwendungen mit C + bauen + / CX und XAML oder DirectX, oder eine Kombination aus beidem. Darüber hinaus können Sie erstellen eine Anwendung, die eine Mischung aus diesen Technologien, z. B. eine Komponente in C++ schreiben ist + / CX, die dann, von einem Windows-Speicher-app mit JavaScript/HTML gebaut verwendet wird.

Es gibt eine Reihe von Gründen für Sie C++ können für das Schreiben einer Windows-Speicher-app. Erstens, die C + + / CX Bindung an die Windows-Runtime ist 100 Prozent native und Verweiszählung. Dies bedeutet, dass es sehr wenig Overhead. Zweitens hat C++ die Fähigkeit, vorhandene Bibliotheken (z. B. Boost) zu nutzen. Schließlich unterstützt C++ systemeigene Direct3D und Direct2D Oberflächen innerhalb Windows Store apps, die ermöglicht es Ihnen, Spiele und andere grafikintensive Anwendungen mit großer Leistung zu bauen. Mit geringen Overhead und hohe Leistung bedeutet nicht nur, dass die Anwendung schneller ausgeführt wird; Es kann auch schlanker, weniger Anweisungen verwenden, um die gleichen Aufgaben, die reduziert den Stromverbrauch und gibt Ihre Benutzer Längere Batterielaufzeit.

Hallo Welt von C + + / CX und XAML

Visuelle Studio 2012 bietet eine Reihe von Vorlagen, die erweiterte Funktionen von Windows Store apps zu demonstrieren. Die Grid-Vorlage ist eine Eigenschaft-verpackten Anwendung mit mehreren Ansichten, Unterstützung für quer- und Hochformat Übergänge, Erweiterte Datenbindung, und unterbrechen und fortsetzen Fähigkeiten. Es ist jedoch nicht sehr geeignet für den Nachweis der Grundlagen. Stattdessen erstellen Sie eine neue C++ Windows-Speicher-app, die mithilfe der Vorlage leere App (XAML).

Nachdem die Anwendung erstellt wurde, finden Sie MainPage.xaml im Projektmappen-Explorer, und öffnen Sie sie. Es öffnet sich zur Bearbeitung in der integrierte XAML-Designer, die in zwei Bereiche aufgeteilt ist: die Entwurfsansicht zeigt eine Darstellung der Benutzeroberfläche und die XAML-Ansicht zeigt den Code. Aktualisieren von Fensterbereichen aktualisiert das andere auch. Dies gibt Ihnen die Freiheit, die Steuerelemente zur einfacheren Bearbeitung ziehen oder genau das Layout steuern, indem Sie den Code bearbeiten.

Öffnen Sie die Toolbox, erweitern Sie Common Controls in XAML zu und ziehen Sie ein TextBlock-Steuerelement auf der Entwurfsoberfläche. Öffnen Sie das Eigenschaften-Fenster, und finden Sie die Optionen für diese Instanz von TextBlock-Steuerelement formatieren. Im Feld Name den Namen Sie TextBlock "MyText." Dies korreliert die X: Name-Attribut in XAML. Dieses Attribut können Sie auf den TextBlock mit Namen, an anderer Stelle in der XAML-Datei und im Codebehind verweisen. Und da dies das einzige Steuerelement auf der Seite ist, Sie könnte genauso gut machen es sehr groß: Erweitern Sie die Kategorie Text, und ändern Sie den Schriftgrad auf 72px. Das Ergebnis sollte wie folgt aussehen Abbildung 1. Sie werden bemerken, dass Sie diese Änderungen im Eigenschafteninspektor vornehmen, das XAML-Markup auch aktualisiert wird.

Abbildung 1-TextBlock-Steuerelement und zugehörige XAML

Anschließend ziehen Sie ein Button-Steuerelement aus der Toolbox, und legen Sie sie auf der linken Seite des TextBlock. Zeigen Sie im Fenster Eigenschaften die verfügbaren Ereignisse für das Steuerelement Schaltfläche durch Klicken auf das Blitz Symbol rechts neben dem Feld Name an, und doppelklicken Sie auf das Feld für das Click-Ereignis. Visual Studio automatisch generiert einen entsprechenden Rückruf und schaltet die Ansicht auf das Codebehind für dieses Ereignis. In der XAML-Quellansicht sollte das generierte Tag etwa wie folgt aussehen:

<Button Click="Button_Click_1" />

Sie leisten konnte, die gleiche Sache in Code durch Hinzufügen des Klick = Attribut für die XAML-Tag und dann einen Namen oder so dass AutoVervollständigen für Sie auswählen. In jedem Fall können mit der rechten Maustaste des Ereignis und wählen Sie navigieren auf Ereignishandler mit dem Codebehind zu navigieren.

Nun fügen Sie den folgenden Code an den Rückruf:

this->myText->Text =
    "Hello World from XAML!";

Erstellen Sie und führen Sie die Anwendung, um sicherzustellen, dass wenn Sie auf die Schaltfläche klicken, der Rückruf den Text im TextBlock ändert (Abbildung 2).

Abbildung 2 aktualisiert TextBlock

Eine Menge geht hinter den Kulissen hier, so möchte ich verbringen einige Zeit Dekonstruktion die Magie, die dieses geschehen macht.

Was ist C + + / CX?

C + + / CX ist die Spracherweiterung, die Interoperabilität von systemeigenem C++ und der Windows-Runtime bereitstellt. Es ist eine vollständig native Bindung, mit der Sie definieren, instanziieren und Objekte in die Common Language Runtime verwenden, während Sie noch den Zugriff auf native C++ Funktionalität und Syntax, mit denen Sie vertraut sind. Abbildung 3 listet die grundlegenden Konzepte. (Obwohl C + + / CX ähnelt in vielerlei Hinsicht mit dem C + + / Common Language Infrastructure oder CLI, Syntax, es ist eine separate und vollständig native Spracherweiterung.)

Abbildung 3 C + + / CX-Konzepte

Begriff	Description
Schnittstellenklasse	Eine abstrakte Erklärung der Methoden, der eine Objekt die Schnittstelle implementiert Aufrufe unterstützen wird.
Ref-Klasse	C + + / CX-Schlüsselwort, das verwendet wird, um eine Verweiszählung Klasse in der Windows-Runtime zu deklarieren, die zum Implementieren von Schnittstellen verwendet wird.
^	"Hut" oder "Griff" genannt, ist dies ein intelligenter Zeiger für die Verwendung mit Ref-Klassen und Schnittstellen; es automatisch inkrementiert und dekrementiert verweisen zählt entsprechend.
neue Ref	Ausdruck, der "(Konstrukten) ein WinRT-Klasse aktiviert".
Standard-namespace	Enthält grundlegende Typdefinitionen (uint32, float64), die WinRT Typen zuordnen.
Plattform-namespace	Enthält Typdefinitionen, die das grundlegende Interoperabilität-Modell mit Windows Runtime (Object ^, String ^).
Eigenschaft	Ein Pseudo-field für eine Klasse; Es besteht aus eine Getter-Funktion und eine optionale Einstellungsfunktion und verhält sich wie ein Feld. (Z. B. ein TextBlock-Objekt hat eine Text-Eigenschaft.)

Partielle Klassen und XAML-Code Generation im Projektmappen-Explorer, navigieren Sie zu MainPage.xaml.h, die eine partielle Definition der Klasse MainPage XAML enthält:

public ref class MainPage sealed
{
public:
  MainPage();
protected:
  virtual void OnNavigatedTo(
    Windows::UI::Xaml::Navigation::NavigationEventArgs^ e) override;
private:
  void Button_Click_1(
    Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
};

Dies ist der Teil der Definition, die Sie bearbeiten und bearbeiten können (beispielsweise, wenn Sie einige Daten Mitglieder der Page-Klasse hinzufügen möchten). Beachten Sie, dass die Deklaration des Ereignishandlers Button_Click_1 von Visual Studio in diese Klassendefinition eingefügt wurde, wenn Sie das Click-Ereignis zuvor doppelgeklickt.

Maustaste auf den Namen der Klasse MainPage und wählen Sie Gehe zu Definition. Sie sollten zwei Ergebnisse sehen: die Definition im MainPage.xaml.h und eine partielle Definition in MainPage.g.h. Die zweite Definition wird während eines Buildvorgangs generiert, wenn der XAML-Compiler MainPage.xaml analysiert und MainPage.g.h generiert. MainPage.xaml.cpp enthält MainPage.xaml.h, die wiederum diese Datei enthält. Diese Klassendefinitionen werden kombiniert, um die Finale-Klasse zu produzieren. Diese Technik ermöglicht sowohl Benutzer als auch der Codegenerator, um Informationen in der Klassendefinition zu injizieren.

Navigieren Sie zu der partiellen Definition der MainPage im MainPage.g.h gefunden:

partial ref class MainPage : public ::Windows::UI::Xaml::Controls::Page,
  public ::Windows::UI::Xaml::Markup::IComponentConnector
{
public:
  void InitializeComponent();
  virtual void Connect(int connectionId, ::Platform::Object^ target);
private:
  bool _contentLoaded;
  private: ::Windows::UI::Xaml::Controls::TextBlock^ myText;
};

Sie können sehen, dass in dieser Datei, X: Name generiert = "MyText" Attribut für den TextBlock den XAML-Compiler generiert einen Klassenmember mit dem Namen MyText verursacht hat. Hier können Sie auch beobachten, dass MainPage von der Basisklasse Windows XAML Page erbt und die IComponentConnector-Schnittstelle implementiert. (IComponent­Connector und die zugeordnete Methode Connect sind was das Click-Ereignis an den Button_Click_1-Rückruf verbinden.)

Datenbindung in C + + / CX Datenbindung ist ein leistungsfähiges Konzept, das Ihnen zu leicht Draht von Code und Daten an die Benutzeroberfläche ermöglicht. Es ermöglicht auch hochrangige Entwurfsmuster wie die Model-View-ViewModel (MVVM), die hervorragende Abstraktion zwischen Daten, Code und der Benutzeroberfläche sein.

In C + + / CX, Sie können eine Klasse, um Daten in verschiedener Weise gebunden werden:

• Attribut der Klasse mit dem Bindable-Attribut
• Die ICustomPropertyProvider-Schnittstelle implementieren
• Implementieren das IMap < String ^, Objekt ^ > Schnittstelle

Ich konzentriere mich auf das Bindable-Attribut, aber ich habe die anderen Schnittstellen erwähnt, weil sie in einigen Szenarios besser geeignet sind. Insbesondere generiert das bindbare Attribut entsprechenden Datenbindung Informationen nur dann, wenn die datengebundenen Klasse öffentliche gekennzeichnet ist. Wenn Sie eine private Klasse gebunden werden soll, müssen Sie eine der anderen aufgeführten Schnittstellen implementieren.

Fügen Sie eine neue Klasse in der Anwendung durch Rechtsklick auf das Projekt und wählen Sie hinzufügen, Klasse, um den Assistenten zum Hinzufügen von Klasse aufzurufen. Es gibt keine Option für eine C + + / CX-Klasse (das ist, was Sie brauchen), so fügen Sie eine systemeigene Klasse Person zu benennen. Visual Studio sollte eine Person.h und Person.cpp-Klasse zu generieren und dem Projekt hinzufügen.

Die Person-Klasse benötigt einige Modifikationen (gezeigt Abbildung 4):

Abbildung 4 Definition der Klasse Person

// person.h
#pragma once
namespace App12 {
  [Windows::UI::Xaml::Data::Bindable]
  public ref class Person sealed
  {
  public:
    Person(void);
    property Platform::String^ Name;
    property Platform::String^ Phone;
  };
}
// person.cpp
#include "pch.h"
#include "person.h"
using namespace App12;
Person::Person(void)
{
  Name = "Maria Anders";
  Phone = "030-0074321";
}

• Die Klassendefinition ist von Klasse zu Ref-Klasse geändert.
• Die Ref-Klasse wird als public und sealed gekennzeichnet. "Öffentlich" ist notwendig für die XAML-Compiler zu finden diese Klasse und Datenbindung Informationen generieren. Auch, C + + / CX unterstützt keine öffentliche Unversiegelte Klassen ohne eine Basisklasse, also die Klasse versiegelt werden muss.
• Der Destruktor-~Person(void) wurde entfernt, da kein Destruktor für diese Klasse notwendig.
• Die Klasse wird in den von der Anwendung verwendeten Namespace verschoben (in dem Beispiel in Abbildung 4, der Namespace ist "App12", aber dies variiert basierend auf den Namen gab Sie Ihr Projekt). Für die Bindable-Attribut zu arbeiten (und WinRT Metadaten Regeln erfüllen), muss die Klasse in einem Namespace sein.
• Die Klasse wird mit zugeschrieben [Windows::UI::Xaml::Data::Bin­Dable]. Dieses Attribut weist den XAML-Compiler, dass es Datenbindungsinformationen für die Klasse generieren soll.
• Zwei Eigenschaften des Typs Platform::String ^: Name und Telefonnummer werden hinzugefügt. (Nur Eigenschaften können datengebunden sein.)

Jetzt in MainPage.xaml, fügen Sie einen zweiten TextBlock unterhalb der ersten und style es ähnlich. Im XAML ändern Sie das Text-Attribut den zwei TextBlocks in Text = "{Binding Name}" und Text = "{Binding Telefon}", beziehungsweise. Dies erzählt das UI Eigenschaften mit dem Namen Name und Telefonnummer auf dem datengebundenes Objekt zu finden und auf das Text-Feld der Klasse anwenden. Das XAML sollte ähnlich aussehen Abbildung 5. (Wenn die Textattribute zu datengebunden sein geändert werden, müssen sie nicht mehr Inhalt Wenn sie im Designer; ausgewiesen sind Dies dürfte.)

Abbildung 5-Datenbindung in XAML

Als nächstes in MainPage.xaml.h, Person.h und fügen Sie eine private Datamember des Typs Person ^ auf die MainPage-Klasse. Nennen Sie es M_Person. Schließlich in MainPage.xaml.cpp, in die OnNavigatedTo-Methode, fügen Sie folgenden Code:

m_Person = ref new Person;
this->DataContext = m_Person;

Die XAML-Runtime ruft die OnNavigatedTo-Methode, kurz bevor diese Seite auf dem Bildschirm angezeigt wird, so ist es eine geeignete Stelle zum Einrichten dieser Datacontext. Dieser Code wird eine neue Instanz der Klasse Person erstellen und binden Sie es an Ihre MainPage-Objekt. Führen Sie die Anwendung erneut, und Sie sollten sehen, dass die Eigenschaften Name und Telefon auf die TextBlock-Text-Attribute angewendet wurden.

Die Datenbindungsinfrastruktur sieht auch die datengebundenen Objekte benachrichtigt werden, wenn die Eigenschaft Inhalt ändern. Ändern Sie die Button_Click_1-Methode den folgenden Code:

this->m_Person->Name = "Anders, Maria";

Wenn Sie das Programm erneut ausführen und klicken Sie auf, sehen Sie, dass der TextBlock-Inhalt nicht verändern. Für diese Inhalte aktualisiert werden, muss die Person-Klasse die INotify umsetzen­PropertyChanged-Schnittstelle.

INotifyPropertyChanged hat ein Element drin: ein Ereignis namens PropertyChanged, vom Typ PropertyChangedEventHandler ^. Die Name-Eigenschaft muss auch von eine triviale Eigenschaft in eine vollständig definierte Eigenschaft (einschließlich Benutzer bereitgestellte Sicherungsspeicher) geändert werden, um unterstützen, feuern dieses Ereignis, wenn die Eigenschaft geändert wird. Zusätzlich fügte ich eine Komfort-Funktion mit dem Namen NotifyPropertyChanged, die löst dieses Ereignis aus, wenn diese aufgerufen wird. Dies ist ein Gemeinplatz refactoring, da mehrere Eigenschaften oft Benachrichtigung erfordern. Die Implementierung ist dargestellt Abbildung 6. (In diesem Beispiel bietet nur für die Eigenschaft Name anzeigepflichtig sein. Eine ähnliche Veränderung müsste für die Telefon-Eigenschaft erfolgen.)

Abbildung 6 Person-Klasse mit anzeigepflichtigen Name-Eigenschaft

// person.h
#pragma once
namespace App12 {
  namespace WUXD = Windows::UI::Xaml::Data;
  [WUXD::Bindable]
  public ref class Person sealed : WUXD::INotifyPropertyChanged
  {
  public:
    Person(void);
    property Platform::String^ Name {
      Platform::String^ get();
      void set(Platform::String^ value);
    }
    property Platform::String^ Phone;
    virtual event WUXD::PropertyChangedEventHandler^ PropertyChanged;
  private:
    void NotifyPropertyChanged(Platform::String^ prop);
    Platform::String^ m_Name;
  };
}
// person.cpp
#include "pch.h"
#include "person.h"
using namespace App12;
using namespace Platform;
using namespace WUXD;
Person::Person(void)
{
  Name = "Maria Anders";
  Phone = "030-0074321";
}
String^ Person::Name::get(){ return m_Name; }
void Person::Name::set(String^ value) {
  if(m_Name != value) {
    m_Name = value;
    NotifyPropertyChanged("Name");
  }
}
void Person::NotifyPropertyChanged(String^ prop) {
  PropertyChangedEventArgs^ args = 
    ref new PropertyChangedEventArgs(prop);
  PropertyChanged(this, args);
}

Ausführen der Anwendung erneut mit der INotifyPropertyChanged-Modifikationen sollte in die Namensänderung führen, wenn die Schaltfläche geklickt wird.

ItemsControls und Sammlungen in C + + / CX und XAML

XAML stellt reichen UI-Steuerelemente, einschließlich der Steuerelemente, die Daten können an eine Auflistung von Objekten zu binden. Diese werden zusammenfassend als ItemsControls bezeichnet. Ich werde vor allem auf einen konzentrieren namens ListView.

Öffnen Sie MainPage.xaml, und löschen Sie den Inhalt des Stammobjekts Raster, mit nur einer ListView-Klasse ersetzen. Name dieser Klasse MyListView, wie hier gezeigt:

<!-- ListView inside MainPage -->
<Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">*
  <ListView x:Name="myListView" />
</Grid>

Sammlungen in C + + / CX The Windows Runtime bietet keine Auflistungsklassen; Es bietet nur Schnittstellen für die Sammlungen. Jede Projektion (JavaScript, c# / Visual Basic und C + + / CX) ist verantwortlich für die Bereitstellung eigener Auflistungsklassen. In C + + / CX, diese Implementierungen finden sich in den collection.h-Header (die bereits in der pch.h der Anwendungsvorlage leere enthalten ist). Es gibt zwei große Auflistungsklassen im Platform::Collections-Namespace definiert: Platform::Collections::Vector <T> zur Darstellung von Listen von Daten und Platform::Collections::Map < T, U > für die Darstellung von Wörterbüchern. ItemsControls in der Regel erwarten eine abzählbaren Liste von Objekten, also Vektor <T> in diesem Szenario geeignet ist.

In MainPage.xaml.cpp, ändern Sie die OnNavigatedTo-Methode "ref neue" einen Vektor < Person ^ > und füllen Sie es mit mehreren Person-Klassen. Dann weisen Sie ihn der ItemsSource-Eigenschaft des MyListView:

void MainPage::OnNavigatedTo(NavigationEventArgs^ e)
{
  (void) e; // Unused parameter
  auto vec =
    ref new Platform::Collections::Vector<Person^>;
  vec->Append(ref
    new Person("Maria Anders","030-0074321"));
  vec->Append(ref new Person("Ana Trujillo","(5) 555-4729"));
  // etc. ...
  myListView->ItemsSource = vec;
}

Das ListView-Steuerelement formatieren schließlich müssen wir der ListView zu sagen, wie Sie jedes einzelne Element formatieren. Die ListView iteriert dann über seine ItemsSource und für jedes Element in der Auflistung die entsprechende Benutzeroberfläche zu generieren und den DataContext auf dieses Element zu binden. Um die ListView können, müssen Sie seine ItemTemplate definieren, wie im Abbildung 7. Beachten Sie, dass die Text-Eigenschaften innerhalb der Vorlage die Datenbindungen für ein Person-Objekt geeignet.

Abbildung 7 ListView innen MainPage mit gestylten ItemTemplate

<Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
  <ListView x:Name="myListView">
    <ListView.ItemTemplate>
      <DataTemplate>
        <StackPanel Orientation="Vertical">
          <TextBlock Text="{Binding Name}" FontSize="20" />
          <TextBlock Text="{Binding Phone}" FontSize="12" />
        </StackPanel>
      </DataTemplate>
    </ListView.ItemTemplate>
  </ListView>
</Grid>

Wenn Sie erstellen und führen Sie diese Anwendung, sollte es aussehen Abbildung 8.

Abbildung 8 fertige ListView

Weitere Informationen

Verweise auf XAML für Windows 8 und C + + / CX sind im Moment etwas knapp. Erfahren Sie mehr über XAML, ich empfehle suchen Referenzen, die XAML in Silverlight sprechen, da viele der gleichen Konzepte anwenden und viele Steuerelemente sind ebenso benannt oder gleich und haben die gleiche Funktionalität. Das Codebehind für diese Verweise werden c# so manche Übersetzung oder Deutung ist notwendig. Dies ist hauptsächlich ein mechanischer Vorgang, aber wo Sie in Funktionen ausführen, die durch die .NET Base Class Library, dargestellt wird, müssen Sie auf die C-Laufzeit-Bibliotheken, Standard Template Library oder andere C++-Bibliotheken (oder Windows Runtime) für diese Aufgaben freuen. Glücklicherweise alle diese Bibliotheken spielen schön mit C + + / CX.

Andere großen Ressourcen sind die Vorlagen in Visual Studio 2012 verfügbar für Windows Store apps, insbesondere die Grid-App und Split-App erstellen. Diese Vorlagen zeigen viele erweiterte Funktionen, ein gut gemachtes Anwendung und ihre Geheimnisse entschlüsseln zu einem größeren Verständnis der zugrunde liegenden Frameworks führen kann.

Abschließend empfehle ich, dass Sie Projekt "Hilo" eine groß angelegte Anwendung geschrieben, mit C++ und XAML betrachten. Der Code und die Dokumentation zu dieser Anwendung finden Sie unter hilo.codeplex.com. Dieses Projekt wurde entwickelt von der Microsoft Patterns & Praxis-Team und zeigt moderne, standard C++; die Portierung von bestehenden C++-Bibliotheken, sodass sie in Windows-Speicher-Anwendungen verwendet werden können; und viele best Practices bei der Verwendung von C + + / CX.

Ich hoffe, ich habe euch gegeben, einen Einblick, was Sie tun können, mit C + + / CX und mit XAML, aber das ist nur die Oberfläche. Wie bei jeder neuen Technologie, Sie erwarten können, viele späte Nächte Surfen Dokumentation und Foren zu verbringen und mit der Nase in Fachbücher begraben. Aber die Kraft und die Fähigkeit des C + + / CX und XAML lernen mehr über lohnen. Sie ermöglicht es Ihnen, viel weniger Zeit reiche, schnelle Anwendungen schreiben.

Andy Rich ist Software Development Engineer bei Microsoft und hat die letzten neun Jahren Testen des Front-End-C++-Compilers ausgegeben. Bis vor kurzem war er einer der primären Tester des C + + / CX-Spracherweiterungen und arbeitete eng mit dem XAML-Team bei der Prüfung des kombinierten XAML/C++-Szenarios.

Unser Dank gilt den folgenden technischen Experten für die Durchsicht dieses Artikels: Tim Heuer, Marian Luparu und Tarek Madkour