Windows 10-Entwicklung - Kurzanleitung

Dieses Tutorial richtet sich an Personen, die lernen möchten, wie Windows 10-Anwendungen entwickelt werden. In diesem Tutorial lernen wir -

  • Windows 10-Anwendungsentwicklung
  • Von Microsoft veröffentlichte Updates des neuen Betriebssystems
  • Neue Funktionen für die Entwickler in den Updates

Es sind jetzt viele interessante App-Szenarien möglich, die uns in der ersten Version nicht zur Verfügung standen. Microsoft hat nicht nur neue APIs hinzugefügt, sondern auch die vorhandenen APIs erweitert.

Universelle Windows App

Eine universelle Windows-App wurde erstmals in Windows 8 als Windows Runtime eingeführt, die auf der universellen Anwendungsplattform basiert.

In Windows 10 wurde der Name der Universal Application Platform in Universal Windows Platform (UWP) geändert. Sie können moderne und umfassende Apps erstellen, indem Sie auf Windows 10-Geräte für den Windows Store wie PC, Tablet, Telefon usw. abzielen.

In Windows 10 können Sie problemlos Anwendungen entwickeln, um alle unter Windows 10 unterstützten Geräte mit nur - zu erreichen.

  • Ein API-Satz
  • Ein App-Paket
  • Und ein Geschäft

Die universelle Windows-Plattform unterstützt auch verschiedene Bildschirmgrößen und verschiedene Interaktionsmodelle wie Touchpad, Maus und Tastatur, einen Gamecontroller oder einen Stift.

Eigenschaften von UWP-Apps

Im Folgenden sind einige der Merkmale von Universal Windows-Apps aufgeführt, die Windows 10 überlegen machen.

  • Sie können auf Gerätefamilien und nicht auf Betriebssysteme wie Windows 8.1 abzielen.

  • Apps werden mit dem Paket gepackt und verteilt .AppX Verpackungsformat, das sicherstellt, dass Ihre Apps nahtlos bereitgestellt und aktualisiert werden können.

  • Sie können Ihre Anwendung an den Windows Store senden und sie wird für alle Gerätefamilien oder nur für die von Ihnen ausgewählten Geräte verfügbar sein. Sie können alle Ihre Apps für Windows-Geräte einfach an einem Ort verwalten.

  • Sie können die Verfügbarkeit Ihrer Anwendung auf die jeweilige Gerätefamilie beschränken.

  • Die Kern-APIs der Universal Windows Platform (UWP) sind für alle Windows-Gerätefamilien gleich. Ihre App kann also auf allen Windows 10-Geräten ausgeführt werden, wenn nur die Kern-APIs verwendet werden.

  • Mithilfe von Erweiterungs-SDKs können Sie Ihre Anwendung für bestimmte Geräte beleuchten.

Entwicklungsoptionen

Universelle Windows-Anwendungen können in einer der folgenden Sprachen erstellt werden:

  • C # oder Visual Basic mit XAML
  • JavaScript mit HTML
  • C ++ mit DirectX und / oder XAML

Sie können Komponenten auch in einer Sprache schreiben und in einer Anwendung verwenden, die in einer anderen Sprache entwickelt wurde.

Windows Runtime (WinRT) ist eine plattformhomogene Anwendungsarchitektur, die die Entwicklung in C ++ / CX, C #, VB.NET und JavaScript unterstützt. WinRT-Anwendungen unterstützen nativ sowohl die x86- als auch die ARM-Architektur. Einige wichtige Funktionen sind.

  • Es wurde erstmals im September 2012 in Windows Server 2012 eingeführt.

  • WinRT-APIs bieten Zugriff auf alle Kernfunktionen der Plattform mithilfe von JavaScript, C #, Visual Basic und C ++.

  • WinRT-Komponenten unterstützen mehrere Sprachen und APIs wie native, verwaltete und Skriptsprachen.

Universelle Windows-Plattform (UWP)

Eine Universal Windows-App basiert auf der Universal Windows Platform (UWP), die erstmals in Windows 8 als Windows Runtime eingeführt wurde. In Windows 10 wurde die Universal Windows Platform (UWP) eingeführt, mit der das Windows Runtime (WinRT) -Modell weiterentwickelt wird.

  • In Windows 8.1 wurde WinRT zum ersten Mal mithilfe von universellen Windows 8-Anwendungen zwischen Windows Phone 8.1-Anwendungen und Windows 8.1-Anwendungen ausgerichtet, um sowohl Windows Phone- als auch Windows-Anwendungen mithilfe einer gemeinsam genutzten Codebasis als Ziel festzulegen.

  • Windows 10 Unified Core, das jetzt als Windows Core bezeichnet wird, hat einen Punkt erreicht, an dem UWP jetzt eine gemeinsame App-Plattform bereitstellt, die auf jedem Gerät verfügbar ist, das unter Windows 10 ausgeführt wird.

  • UWP kann nicht nur die WinRT-APIs aufrufen, die allen Geräten gemeinsam sind, sondern auch APIs (einschließlich Win32- und .NET-APIs), die für die Gerätefamilie spezifisch sind, auf der die App ausgeführt wird.

Von Windows 10 unterstützte Geräte

Windows 8.1- und Windows Phone 8.1-Apps zielen auf ein Betriebssystem ab. entweder Windows oder Windows Phone. Windows 10-Anwendungen zielen nicht auf ein Betriebssystem ab, sondern auf eine oder mehrere Gerätefamilien.

Gerätefamilien haben auch ihre eigenen APIs, die Funktionen für diese bestimmte Gerätefamilie hinzufügen. Sie können auf einfache Weise alle Geräte innerhalb einer Gerätefamilie ermitteln, auf denen Ihre Anwendungen installiert und im Windows Store ausgeführt werden können. Hier ist die hierarchische Darstellung der Gerätefamilie.

Vorteile von UWP

Die universelle Windows-Plattform (UWP) bietet Entwicklern eine Handvoll Dinge. Sie sind -

  • Ein Betriebssystem und ein Unified Core für alle Geräte.
  • Eine App-Plattform zum Ausführen der Anwendungen für jede Familie.
  • Ein Dev Center zum Einreichen eines Antrags und eines Dashboards.
  • Ein Store für alle Geräte.

Setup für die UWP-Entwicklung

Die folgenden Schritte müssen ausgeführt werden, um Ihre eigenen UWP-Apps (Universal Windows Platform) für Windows 10 zu erstellen.

  • Windows 10 OS- UWP-Apps benötigen zur Entwicklung die neueste Version von Windows. Sie können auch UWP-Anwendungen unter Windows 8.1 entwickeln, das UI-Designer-Fenster wird jedoch nicht unterstützt.

  • Windows 10 developer tools- In Visual Studio 2015 können Sie Ihre UWP-Apps entwerfen, codieren, testen und debuggen. Sie können die kostenlose Microsoft Visual Studio Community 2015 von herunterladen und installierenhttps://dev.windows.com/en-us/downloads

  • Enable development mode for Windows 10 - -

    • Gehe zu Start > Settings.

    • Wählen Update & security.

    • Dann wählen Sie "For developers".

    • Klick auf das Developer mode

Für UWP-Apps ist es wichtig, Ihre Anwendungen auf Geräten zu testen.

  • Register as an app developer- Sie können mit der Entwicklung von Apps beginnen. Um Ihre Apps jedoch an den Store zu senden, benötigen Sie ein Entwicklerkonto. Hier können Sie Ihr Entwicklerkonto erstellenhttps://msdn.microsoft.com/enus/library/windows/apps/bg124287.aspx

Nachdem Sie die obigen Schritte ausgeführt haben, können Sie jetzt mit der Entwicklung einer UWP-Anwendung (Universal Windows Platform) beginnen.

In diesem Kapitel erstellen wir unsere erste einfache Anwendung "Hello world" in Universal Windows Platform (UWP) unter Verwendung von XAML und C # unter Windows 10. Wir werden zeigen, wie eine einzelne in Visual Studio erstellte UWP-Anwendung auf jedem Windows 10-Gerät ausgeführt und ausgeführt werden kann.

Beginnen wir mit der Erstellung der App, indem wir die folgenden Schritte ausführen.

  • Starten Sie Visual Studio 2015.

  • Klick auf das File Menü und wählen New > Project.

  • Folgende New ProjectDas Dialogfenster wird angezeigt. Sie können die verschiedenen Arten von Vorlagen im linken Bereich des Dialogfelds sehen.

  • Im linken Bereich sehen Sie die Baumansicht. WählenUniversal template von Templates > Visual C# > Windows.

  • Wählen Sie im mittleren Bereich die Option aus Blank App (Universal Windows) Vorlage

  • Geben Sie dem Projekt einen Namen, indem Sie schreiben UWPHelloWorld in dem Name field.

  • Klicken OK um ein neues UWP-Projekt zu erstellen.

  • Sie können das neu erstellte Projekt im sehen Solution Explorer.

  • Dies ist eine leere App, die jedoch viele Dateien enthält. Dies ist die Mindestanforderung für jede UWP-Anwendung.

  • MainPage.xaml und MainPage.xaml.cs Ausführen, wenn Sie Ihre Anwendung ausführen.

  • Standardmäßig, MainPage.xaml Datei enthält die folgenden Informationen.

<Page 
   x:Class = ”UWPHellowWorld.MainPage” 
   xmlns = ”http://schemas.microsoft.com/winfx/2006/xaml/presentation” 
   xmlns:x = ”http://schemas.microsoft.com/winfx/2006/xaml” 
   xmlns:local = ”using:UWPHellowWorld” 
   xmlns:d = ”http://schemas.microsoft.com/expression/blend/2008” 
   xmlns:mc = ”http://schemas.openxmlformats.org/markup-compatibility/2006” 
   mc:Ignorable = ”d”>  
	
   <Grid Background = ”{ThemeResource ApplicationPageBackgroundThemeBrush}”>
   </Grid>
	
</Page>
  • Im Folgenden sind die Standardinformationen aufgeführt, die in verfügbar sind MainPage.xaml.cs.

using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Linq; 
using System.Runtime.InteropServices.WindowsRuntime; 

using Windows.Foundation; 
using Windows.Foundation.Collections; 

using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
using Windows.UI.Xaml.Controls.Primitives; 
using Windows.UI.Xaml.Data; 
using Windows.UI.Xaml.Input; 
using Windows.UI.Xaml.Media; 
using Windows.UI.Xaml.Navigation;

// The Blank Page item template is documented at 
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409

namespace UWPHellowWorld {
 
   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class MainPage : Page {
      public MainPage(){ 
         this.InitializeComponent(); 
      } 
   } 
	
}
  • Fügen wir einige Textblöcke, ein Textfeld und eine Schaltfläche hinzu, wie im folgenden XAML-Code gezeigt.

<Page 
   x:Class = ”UWPHellowWorld.MainPage” 
   xmlns = ”http://schemas.microsoft.com/winfx/2006/xaml/presentation” 
   xmlns:x = ”http://schemas.microsoft.com/winfx/2006/xaml” 
   xmlns:local = ”using:UWPHellowWorld” 
   xmlns:d = ”http://schemas.microsoft.com/expression/blend/2008”
   xmlns:mc = ”http://schemas.openxmlformats.org/markup-compatibility/2006” 
   mc:Ignorable = ”d”>  
   
   <Grid Background = ”{ThemeResource ApplicationPageBackgroundThemeBrush}”> 
	
      <StackPanel HorizontalAlignment = ”Center”> 
         <TextBlock Text = ”Hello, world!”  Margin = ”20”  Width = ”200” 
            HorizontalAlignment = ”Left”/> 
				
         <TextBlock Text = ”Write your name.” Margin = ”20” Width = ”200” 
            HorizontalAlignment = ”Left”/> 
				
         <TextBox x:Name = ”txtbox”  Width = ”280” Margin = ”20” 
            HorizontalAlignment = ”Left”/> 
				
         <Button x:Name = ”button” Content = ”Click Me” Margin = ”20” 
            Click = ”button_Click”/> 
				
         <TextBlock x:Name = ”txtblock” HorizontalAlignment = ”Left” 
            Margin = ”20”/> 
      </StackPanel> 
		
   </Grid> 
	
</Page>
  • Unten ist die Schaltfläche für das Klickereignis in C # angegeben.
using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Linq; 

using System.Runtime.InteropServices.WindowsRuntime; 
using Windows.Foundation; 
using Windows.Foundation.Collections;
 
using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
using Windows.UI.Xaml.Controls.Primitives; 
using Windows.UI.Xaml.Data; 
using Windows.UI.Xaml.Input; 
using Windows.UI.Xaml.Media; 
using Windows.UI.Xaml.Navigation; 
 
// The Blank Page item template is documented at
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409  

namespace UWPHellowWorld {

   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class MainPage : Page {
      public MainPage() {
         this.InitializeComponent(); 
      }  
		
      private void button_Click(object sender, RoutedEventArgs e) {
         if (txtbox.Text != “”) 
            txtblock.Text = “Hello: “ + txtbox.Text; 
         else 
            txtblock.Text = “You have not write your name”; 
      } 
		
   }	
	
}
  • Im UWP-Projekt device preview Option ist auf der verfügbar Design WindowMit deren Hilfe Sie das Layout einfach ändern können, um es an die Bildschirmgröße aller Geräte in einer Gerätefamilie anzupassen, auf die Sie für Ihre Anwendung abzielen.

  • Sie können Ihre App entweder auf einem lokalen Computer, einem Simulator oder einem Emulator oder auf einem Remote-Gerät ausführen und testen. Sie können das Zielgerät aus dem folgenden Menü auswählen, wie unten gezeigt -

  • Lassen Sie uns den obigen Code auf einem lokalen Computer ausführen, und Sie sehen das folgende Fenster. Schreiben Sie nun einen beliebigen Namen in das Textfeld und klicken Sie auf die SchaltflächeClick Me.

  • Wenn Sie Ihre App jetzt auf einem Emulator testen möchten, können Sie einen bestimmten Emulator aus dem Menü auswählen und Ihre Anwendung ausführen. Sie sehen den folgenden Emulator -

Wir empfehlen Ihnen, die oben genannte Anwendung mit verschiedenen Geräten auszuführen.

Der Vorteil von Windows Store für Entwickler besteht darin, dass Sie Ihre Anwendung verkaufen können. Sie können Ihre einzelne Bewerbung für jede Gerätefamilie einreichen.

  • Im Windows 10 Store werden Anwendungen eingereicht, damit ein Benutzer Ihre Anwendung finden kann.

  • In Windows 8 war der Store nur auf Anwendungen beschränkt, und Microsoft bietet viele Stores an, z. B. Xbox Music Store, Xbox Game Store usw.

  • In Windows 8 waren dies alles verschiedene Stores, in Windows 10 heißt es Windows Store. Es wurde so konzipiert, dass Benutzer eine vollständige Palette von Apps, Spielen, Songs, Filmen, Software und Diensten für alle Windows 10-Geräte an einem Ort finden können.

Monetarisierung

Monetarisierung bedeutet, dass Sie Ihre App auf Desktop-, Mobil-, Tablet- und anderen Geräten verkaufen können. Es gibt verschiedene Möglichkeiten, wie Sie Ihre Anwendungen und Dienste im Windows Store verkaufen können, um Geld zu verdienen.

Sie können eine der folgenden Methoden auswählen:

  • Am einfachsten ist es, Ihre App mit kostenpflichtigen Download-Optionen im Store einzureichen.

  • Die Option Trails, mit der Benutzer Ihre Anwendung testen können, bevor sie sie mit eingeschränkter Funktionalität kaufen.

  • Fügen Sie Ihren Apps mit Microsoft Advertising Werbung hinzu.

Microsoft-Werbung

Wenn Sie Ihrer Anwendung Anzeigen hinzufügen und ein Nutzer auf diese bestimmte Anzeige klickt, zahlt Ihnen der Werbetreibende das Geld. Mit Microsoft Advertising können Entwickler Anzeigen vom Microsoft Advertising Network empfangen.

  • Das Microsoft Advertising SDK für universelle Windows-Apps ist in den von Visual Studio 2015 installierten Bibliotheken enthalten.

  • Sie können es auch über die Visualstudiogallery installieren

  • Jetzt können Sie problemlos Video- und Bannerwerbung in Ihre Apps integrieren.

Schauen wir uns ein einfaches Beispiel in XAML an, mit dem Sie Ihrer Anwendung eine Bannerwerbung hinzufügen können AdControl.

  • Erstellen Sie ein neues leeres Universal Windows-App-Projekt mit dem Namen UWPBannerAd.

  • In dem Solution ExplorerKlicken Sie mit der rechten Maustaste auf References

  • Wählen Add References, die die öffnen wird Reference Manager Dialog.

  • Wählen Sie im linken Bereich die Option aus Extensions Klicken Sie unter Universal Windows auf die Option Microsoft Advertising SDK for XAML.

  • Klicken OK weitermachen.

  • Unten ist der XAML-Code angegeben, in dem AdControl wird mit einigen Eigenschaften hinzugefügt.

<Page 
   x:Class = "UWPBannerAd.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPBannerAd" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   xmlns:UI = "using:Microsoft.Advertising.WinRT.UI" 
   mc:Ignorable = "d">
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <StackPanel HorizontalAlignment = "Center">
         <UI:AdControl ApplicationId = "d25517cb-12d4-4699-8bdc-52040c712cab"  
            AdUnitId = "10043121" HorizontalAlignment = "Left" Height = "580"  
            VerticalAlignment = "Top" Width = "800"/> 
      </StackPanel> 
   </Grid> 
	
</Page>

Wenn der obige Code kompiliert und auf einem lokalen Computer ausgeführt wird, wird das folgende Fenster mit dem MSN-Banner angezeigt. Wenn Sie auf dieses Banner klicken, wird die MSN-Site geöffnet.

Sie können auch eine hinzufügen video bannerin Ihrer Bewerbung. Betrachten wir ein weiteres Beispiel, in dem, wenn dieShow ad Wenn Sie auf die Schaltfläche klicken, wird die Videowerbung von Xbox One abgespielt.

Im Folgenden finden Sie den XAML-Code, in dem gezeigt wird, wie eine Schaltfläche mit einigen Eigenschaften und Ereignissen hinzugefügt wird.

<Page 
   x:Class = "UWPBannerAd.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPBannerAd" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   xmlns:UI = "using:Microsoft.Advertising.WinRT.UI" 
   mc:Ignorable = "d">  
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <StackPanel HorizontalAlignment = "Center"> 
         <Button x:Name = "showAd" Content = "Show Ad" HorizontalAlignment = "Left"  
            Margin = "138,296,0,0" VerticalAlignment = "Top" FontSize = "48" 
            Click = "showAd_Click"/> 
      </StackPanel> 
   </Grid> 
	
</Page>

Im Folgenden wird die Implementierung des Klickereignisses in C # angegeben.

using Microsoft.Advertising.WinRT.UI; 
using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls;
  
// The Blank Page item template is documented at 
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409  

namespace UWPBannerAd {

   /// <summary>
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class MainPage : Page {
      InterstitialAd videoAd = new InterstitialAd();
		
      public MainPage() {
         this.InitializeComponent(); 
      }  
		
      private void showAd_Click(object sender, RoutedEventArgs e) {
         var MyAppId = "d25517cb-12d4-4699-8bdc-52040c712cab"; 
         var MyAdUnitId = "11388823";  
         videoAd.AdReady += videoAd_AdReady; 
         videoAd.RequestAd(AdType.Video, MyAppId, MyAdUnitId); 
      }
		
      void videoAd_AdReady(object sender, object e){ 
         if ((InterstitialAdState.Ready) == (videoAd.State)) {
            videoAd.Show(); 
         } 
      } 
		
   } 
	
}

Wenn der obige Code kompiliert und auf einem lokalen Computer ausgeführt wird, wird das folgende Fenster angezeigt, das a enthält Show Ad Taste.

Nun, wenn Sie auf die klicken Show Ad Klicken Sie auf die Schaltfläche, um das Video in Ihrer App abzuspielen.

XAML steht für Extensible Application Markup Language. Es ist ein Benutzeroberflächen-Framework und bietet eine umfangreiche Bibliothek von Steuerelementen, die die UI-Entwicklung für Windows unterstützen. Einige von ihnen haben eine visuelle Darstellung wie eine Schaltfläche, ein Textfeld und ein TextBlock usw.; Während andere Steuerelemente als Container für andere Steuerelemente oder Inhalte wie Bilder usw. verwendet werden, werden alle XAML-Steuerelemente geerbt“System.Windows.Controls.Control”.

XAML Emerging Story

XAML wird in vielen wichtigen Microsoft-Plattformen wie der Windows Presentation Foundation (WPF), dem Silverlight und jetzt in Windows-Apps verwendet. Microsoft Office 2016 ist jetzt auch eine Familie von UWP-Apps. XAML ist eine umfangreiche Plattform, die sehr coole Funktionen und Steuerelemente bietet, die in UWP-Anwendungen verwendet werden können.

Die vollständige Vererbungshierarchie der Steuerelemente ist unten dargestellt.

Layout-Steuerelemente

Das Layout der Steuerelemente ist sehr wichtig und entscheidend für die Benutzerfreundlichkeit der Anwendung. Es wird verwendet, um eine Gruppe von GUI-Elementen in Ihrer Anwendung anzuordnen. Bei der Auswahl der Layoutfelder sind bestimmte wichtige Punkte zu beachten:

  • Positionen der untergeordneten Elemente.
  • Größen der untergeordneten Elemente.
  • Überlappende übergeordnete Elemente übereinander legen.

Eine Liste von Layout Controls ist unten angegeben -

S.No. Bedienelemente & Beschreibung
1

StackPanel

StackPanelist ein einfaches und nützliches Layoutfenster in XAML. Im Stapelfenster können untergeordnete Elemente je nach Ausrichtungseigenschaft entweder horizontal oder vertikal in einer einzelnen Linie angeordnet werden.

2

WrapPanel

Im WrapPanelUntergeordnete Elemente werden basierend auf der Ausrichtungseigenschaft in aufeinanderfolgender Reihenfolge von links nach rechts oder von oben nach unten positioniert. Der einzige Unterschied zwischen StackPanel und WrapPanel besteht darin, dass nicht alle untergeordneten Elemente in einer einzigen Zeile gestapelt werden, sondern die verbleibenden Elemente in eine andere Zeile eingeschlossen werden, wenn kein Leerzeichen mehr vorhanden ist.

3

DockPanel

DockPanelDefiniert einen Bereich, in dem untergeordnete Elemente horizontal oder vertikal relativ zueinander angeordnet werden. Mit DockPanel können Sie untergeordnete Elemente mit der Dock-Eigenschaft ganz einfach oben, unten, rechts, links und in der Mitte andocken.

Mit LastChildFill Eigenschaft, das letzte untergeordnete Element füllt den verbleibenden Speicherplatz unabhängig von einem anderen Dock-Wert, wenn es für dieses Element festgelegt wird.

4

Canvas

Canvasist das grundlegende Layoutfenster, in dem untergeordnete Elemente explizit mithilfe von Koordinaten positioniert werden können, die sich auf eine beliebige Seite beziehen, z. B. links, rechts, oben und unten. In der Regel wird Canvas für 2D-Grafikelemente (wie Ellipse, Rechteck usw.) verwendet, jedoch nicht für UI-Elemente, da die Angabe absoluter Koordinaten Probleme beim Ändern der Größe, Lokalisierung oder Skalierung in einer XAML-Anwendung verursacht.

5

Grid

Gridbietet einen flexiblen Bereich, der aus Zeilen und Spalten besteht. In Grid können untergeordnete Elemente in Tabellenform angeordnet werden. Elemente können mithilfe von zu einer bestimmten Zeile und Spalte hinzugefügt werdenGrid.Row und Grid.Column Eigenschaften.

6

SplitView

SplitViewstellt einen Container mit zwei Ansichten dar; Eine Ansicht für den Hauptinhalt und eine andere Ansicht, die normalerweise für Navigationsbefehle verwendet wird.

7

RelativePanel

RelativePanel Definiert einen Bereich, in dem Sie untergeordnete Objekte in Bezug zueinander oder zum übergeordneten Bedienfeld positionieren und ausrichten können.

8

ViewBox

ViewBox Definiert einen Inhaltsdekorateur, der ein einzelnes Kind strecken und skalieren kann, um den verfügbaren Platz zu füllen.

9

FlipView

FlipView stellt das Steuerelement eines Elements dar, das jeweils ein Element anzeigt, und aktiviert das "Flip" -Verhalten zum Durchlaufen seiner Elementauflistung.

10

GridView

GridView ist ein Steuerelement, das eine Sammlung von Elementen in Zeilen und Spalten darstellt und horizontal gescrollt werden kann.

UI-Steuerelemente

Hier ist eine Liste der UI-Steuerelemente, die für die Endbenutzer sichtbar sind.

S.No. UI-Steuerelemente und Beschreibung
1

Button

Ein Steuerelement, das auf Benutzereingaben reagiert

2

Calendar

Stellt ein Steuerelement dar, mit dem ein Benutzer ein Datum mithilfe einer visuellen Kalenderanzeige auswählen kann.

3

CheckBox

Ein Steuerelement, das ein Benutzer auswählen oder löschen kann.

4

ComboBox

Eine Dropdown-Liste mit Elementen, aus der ein Benutzer auswählen kann.

5

ContextMenu

Ruft das Kontextmenüelement ab oder legt dieses fest, das angezeigt werden soll, wenn das Kontextmenü über die Benutzeroberfläche innerhalb dieses Elements angefordert wird.

6

DataGrid

Stellt ein Steuerelement dar, das Daten in einem anpassbaren Raster anzeigt.

7

DatePicker

Ein Steuerelement, mit dem ein Benutzer ein Datum auswählen kann.

8

Dialogs

Eine Anwendung kann auch zusätzliche Fenster anzeigen, in denen der Benutzer wichtige Informationen sammeln oder anzeigen kann.

9

Flyout

Stellt ein Steuerelement dar, das eine einfache Benutzeroberfläche anzeigt, die entweder Informationen enthält oder Benutzerinteraktion erfordert. Im Gegensatz zu einem Dialogfeld kann ein Flyout durch Klicken oder Tippen außerhalb des Dialogfelds, Drücken der Zurück-Taste des Geräts oder Drücken der Esc-Taste leicht gelöscht werden.

10

Image

Ein Steuerelement, das ein Bild darstellt.

11

ListBox

Ein Steuerelement, das eine Inline-Liste von Elementen anzeigt, aus denen der Benutzer auswählen kann.

12

Menus

Stellt ein Windows-Menüsteuerelement dar, mit dem Sie die mit Befehlen und Ereignishandlern verknüpften Elemente hierarchisch organisieren können.

13

MenuFlyout

Stellt ein Flyout dar, das ein Befehlsmenü anzeigt.

14

PasswordBox

Ein Steuerelement zur Eingabe von Passwörtern.

15

Popup

Zeigt Inhalte über den vorhandenen Inhalten innerhalb der Grenzen des Anwendungsfensters an.

16

ProgressBar

Ein Steuerelement, das den Fortschritt durch Anzeigen eines Balkens anzeigt.

17

ProgressRing

Ein Steuerelement, das den unbestimmten Fortschritt durch Anzeigen eines Rings anzeigt.

18

RadioButton

Ein Steuerelement, mit dem ein Benutzer eine einzelne Option aus einer Gruppe von Optionen auswählen kann.

19

RichEditBox

Ein Steuerelement, mit dem ein Benutzer Rich-Text-Dokumente mit Inhalten wie formatiertem Text, Hyperlinks und Bildern bearbeiten kann.

20

ScrollViewer

Ein Containersteuerelement, mit dem der Benutzer seinen Inhalt schwenken und zoomen kann.

21

SearchBox

Ein Steuerelement, mit dem ein Benutzer Suchanfragen eingeben kann.

22

Slider

Ein Steuerelement, mit dem der Benutzer aus einem Wertebereich auswählen kann, indem er ein Thumb-Steuerelement entlang einer Spur bewegt.

23

TextBlock

Ein Steuerelement, das den Text anzeigt.

24

TimePicker

Ein Steuerelement, mit dem ein Benutzer einen Zeitwert festlegen kann.

25

ToggleButton

Eine Schaltfläche, die zwischen zwei Zuständen umgeschaltet werden kann.

26

ToolTip

Ein Popup-Fenster, in dem Informationen zu einem Element angezeigt werden.

27

Window

Das Stammfenster mit Minimierungs- / Maximierungsoption, Titelleiste, Rahmen und Schaltfläche zum Schließen.

Im Folgenden finden Sie ein Beispiel, das verschiedene Arten von Steuerelementen in a enthält SplitView. In der XAML-Datei werden verschiedene Steuerelemente mit einigen Eigenschaften und Ereignissen erstellt.

<Page 
   x:Class = "UWPControlsDemo.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPControlsDemo" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <StackPanel Margin = "20"> 
		
         <StackPanel Orientation = "Horizontal"> 
			
            <ToggleButton x:Name = "HamburgerButton" FontFamily = "Segoe MDL2 Assets"
               Content = "" Checked = "HandleCheck" Unchecked = "HandleUnchecked" 
               HorizontalAlignment = "Center"/> 
					
            <AppBarButton Icon = "Like" />
            <AppBarButton Icon = "Dislike" /> 
            <AppBarSeparator/> 
            <AppBarButton Icon = "Accept" /> 
            <AppBarButton Icon = "Add" /> 
				
         </StackPanel> 
			
         <SplitView x:Name = "splitView" DisplayMode = "Inline" 
            OpenPaneLength = "296"> 
				
            <SplitView.Pane> 
               <StackPanel> 
                  <TextBlock Text = "SplitView Pane" FontSize = "36" 
                     VerticalAlignment = "Center" HorizontalAlignment = "Center" 
                     Margin = "10"/> 
							
                  <Button Content = "Options" Margin = "10"> 
						
                     <Button.Flyout> 
                        <MenuFlyout> 
                           <MenuFlyoutItem Text = "Reset"/> 
                           <MenuFlyoutSeparator/> 
                           <MenuFlyoutItem Text = "Repeat"/> 
                           <MenuFlyoutItem Text = "Shuffle"/> 
                        </MenuFlyout> 
                     </Button.Flyout> 
							
                  </Button> 
						
               </StackPanel> 
            </SplitView.Pane> 
					
            <StackPanel>
				
               <TextBlock Text = "SplitView Content" FontSize = "36" 
                  VerticalAlignment = "Center" HorizontalAlignment = "Center" 
                  Margin = "10"/>
						
               <Border BorderThickness = "3" BorderBrush = "Red" Margin = "5"> 
                  <StackPanel Orientation = "Horizontal"> 
                     <TextBlock Text = "Hyperlink example" Margin = "5"/> 
                     <HyperlinkButton Content = "www.microsoft.com" 
                        NavigateUri = "http://www.microsoft.com"/> 
                  </StackPanel> 
               </Border> 
					
               <RelativePanel BorderBrush = "Red" BorderThickness = "2"  
                  CornerRadius = "10" Padding = "12" Margin = "5"> 
						
                  <TextBlock x:Name = "txt" Text = "Relative Panel example" 
                     RelativePanel.AlignLeftWithPanel = "True" 
                     Margin = "5,0,0,0"/> 
							
                  <TextBox x:Name = "textBox1" RelativePanel.RightOf = "btn" 
                     Margin = "5,0,0,0"/> 
							
                  <Button x:Name = "btn" Content = "Name"  
                     RelativePanel.RightOf = "txt" Margin = "5,0,0,0"/> 
							
               </RelativePanel> 
					
               <FlipView Height = "400" Margin = "10" Width = "400"> 
                  <Image Source = "Images/DSC_0104.JPG"/> 
                  <Image Source = "Images/DSC_0080.JPG"/> 
                  <Image Source = "Images/DSC_0076.JPG"/> 
                  <Image Source = "Images/thGTF7BWGW.jpg"/> 
               </FlipView>
					
            </StackPanel> 
				
         </SplitView> 
			
      </StackPanel> 
		
   </Grid> 
	
</Page>

Unten ist die angegeben Events Implementierung in C #.

using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
using Windows.UI.Xaml.Media;
  
// The Blank Page item template is documented at
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409
 
namespace UWPControlsDemo {
 
   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class MainPage : Page {
    
      public MainPage() {
         this.InitializeComponent(); 
      } 
		
      private void HandleCheck(object sender, RoutedEventArgs e) { 
         splitView.IsPaneOpen = true; 
      }
		
      private void HandleUnchecked(object sender, RoutedEventArgs e) {
         splitView.IsPaneOpen = false; 
      }
		
   }
	
}

Wenn der obige Code kompiliert und ausgeführt wird, wird das folgende Fenster angezeigt:

Wenn Sie oben links auf den Hamburger-Button klicken, wird der geöffnet / geschlossen SplitView Feld.

In dem SplitView Fenster, Sie können das sehen Flyout, MenuFlyout und FlipView Kontrollen.

In dem SplitView Inhalt können Sie den Hyperlink, das relative Bedienfeld, die ViewBox und andere Schaltflächen und Textfeldsteuerelemente sehen.

Die Datenbindung ist ein Mechanismus in der XAML-Anwendung, der Windows Runtime-Apps eine einfache Möglichkeit bietet, Daten mithilfe von Teilklassen anzuzeigen und mit ihnen zu interagieren. Die Verwaltung von Daten ist vollständig von der Art und Weise getrennt, wie Daten in diesem Mechanismus angezeigt werden.

Die Datenbindung ermöglicht den Datenfluss zwischen UI-Elementen und Datenobjekt auf der Benutzeroberfläche. Wenn eine Bindung hergestellt wird und sich die Daten oder Ihr Geschäftsmodell ändern, werden die Aktualisierungen der UI-Elemente automatisch wiedergegeben und umgekehrt. Es ist auch möglich, nicht an eine Standarddatenquelle, sondern an ein anderes Element auf der Seite zu binden. Datenbindung kann sein -

  • Einweg-Datenbindung
  • Zweiwege-Datenbindung
  • Elementbindung

Einweg-Datenbindung

Bei der Einwegbindung werden die Daten von ihrer Quelle (dem Objekt, das die Daten enthält) an ihr Ziel (das Objekt, das die Daten anzeigt) gebunden.

Schauen wir uns ein einfaches Beispiel für die Einweg-Datenbindung an. Im Folgenden ist der XAML-Code angegeben, in dem vier Textblöcke mit einigen Eigenschaften erstellt werden.

<Page 
   x:Class = "OneWayDataBinding.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:OneWayDataBinding" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">  
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <StackPanel Name = "Display"> 
         <StackPanel Orientation = "Horizontal" Margin = "50, 50, 0, 0"> 
            <TextBlock Text = "Name: " Margin = "10" Width = "100"/> 
            <TextBlock Margin = "10" Width = "100" Text = "{Binding Name}"/> 
         </StackPanel>
			
         <StackPanel Orientation = "Horizontal" Margin = "50,0,50,0"> 
            <TextBlock Text = "Title: " Margin = "10" Width = "100"/> 
            <TextBlock Margin = "10" Width = "200" Text = "{Binding Title}" /> 
         </StackPanel> 
			
      </StackPanel> 
   </Grid>
	
</Page>

Die Texteigenschaften von zwei Textblöcken sind auf festgelegt “Name” und “Title” statisch, während die anderen beiden Texteigenschaften der Textblöcke an "Name" und "Titel" gebunden sind, die Klassenvariablen der Employee-Klasse sind, wie unten gezeigt.

using Windows.UI.Xaml.Controls;  

// The Blank Page item template is documented at  
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409 
 
namespace OneWayDataBinding {
 
   /// <summary>
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class MainPage : Page {
      public MainPage(){ 
         this.InitializeComponent(); 
         DataContext = Employee.GetEmployee(); 
      } 
   } 
	
   public class Employee {
      public string Name { get; set; } 
      public string Title { get; set; }  
		
      public static Employee GetEmployee() {
         var emp = new Employee() {
            Name = "Waqar Ahmed", 
            Title = "Development Manager" 
         }; 
			
         return emp; 
      } 
		
   }  
}

In dem Employee classWir haben Variablen Name und Title und eine statische Methode, bei der die employee objectwird initialisiert und gibt das Mitarbeiterobjekt zurück. Daher sind wir an die Eigenschaft, den Namen und den Titel gebunden, haben jedoch das Objekt, zu dem die Eigenschaft gehört, noch nicht ausgewählt. Der einfache Weg ist, ein Objekt zuzuweisenDataContext, deren Eigenschaften wir in der MainPage Konstrukteur.

Wenn Sie diese Anwendung ausführen, können Sie sofort in Ihrem sehen MainWindow dass Sie erfolgreich an den Namen und den Titel dieses Mitarbeiterobjekts gebunden haben.

Zweiwege-Datenbindung

Bei der bidirektionalen Bindung kann der Benutzer die Daten über die Benutzeroberfläche ändern und diese Daten in der Quelle aktualisieren lassen. Wenn sich beispielsweise die Quelle ändert, während der Benutzer die Ansicht betrachtet, möchten Sie, dass die Ansicht aktualisiert wird.

Schauen wir uns das folgende Beispiel an, in dem zwei Beschriftungen, zwei Textfelder und eine Schaltfläche mit einigen Eigenschaften und Ereignissen erstellt werden.

<Page 
   x:Class = "TwoWayDataBinding.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:TwoWayDataBinding" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006"
   mc:Ignorable = "d">  
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
	
      <Grid.RowDefinitions> 
         <RowDefinition Height = "Auto" /> 
         <RowDefinition Height = "Auto" /> 
         <RowDefinition Height = "*" /> 
      </Grid.RowDefinitions> 
		
      <Grid.ColumnDefinitions> 
         <ColumnDefinition Width = "Auto" /> 
         <ColumnDefinition Width = "200" /> 
      </Grid.ColumnDefinitions> 
		
      <TextBlock Name = "nameLabel" Margin = "200,20,0,0">Name:</TextBlock> 
		
      <TextBox Name = "nameText" Grid.Column = "1" Margin = "10,20,0,0" 
         Text = "{Binding Name, Mode = TwoWay}"/>  
			
      <TextBlock Name = "ageLabel" Margin = "200,20,0,0" 
         Grid.Row = "1">Age:</TextBlock> 
			
      <TextBox Name = "ageText" Grid.Column = "1" Grid.Row = "1" Margin = "10,20,0,0" 
         Text = "{Binding Age, Mode = TwoWay}"/>
			
      <StackPanel Grid.Row = "2" Grid.ColumnSpan = "2"> 
         <Button Content = "Display" Click = "Button_Click"  
            Margin = "200,20,0,0"/> 
         <TextBlock x:Name = "txtblock" Margin = "200,20,0,0"/> 
      </StackPanel>  
		
   </Grid> 
	
</Page>

Wir können folgendes beobachten -

  • Die Texteigenschaften beider Textfelder sind an die gebunden "Name" und "Age" Welches sind Klassenvariablen von Person class Wie nachfolgend dargestellt.

  • Im Person classhaben wir nur zwei Variablen - Name und Alter, und sein Objekt wird in der initialisiert MainWindow Klasse.

  • Im XAML-Code sind wir an die Eigenschaft gebunden - Name und Age, aber wir haben das Objekt, zu dem die Eigenschaft gehört, nicht ausgewählt.

  • Am einfachsten ist es, dem Objekt ein Objekt zuzuweisen DataContext, deren Eigenschaften wir im C # -Code binden, wie unten in der MainWindowconstructor.

using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
 
// The Blank Page item template is documented at 
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409  
	
namespace TwoWayDataBinding {

   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary>
   
   public sealed partial class MainPage : Page {
      Person person = new Person { Name = "Salman", Age = 26 }; 
		
      public MainPage() {
         this.InitializeComponent(); 
         this.DataContext = person; 
      } 
		
      private void Button_Click(object sender, RoutedEventArgs e) {
         string message = person.Name + " is " + person.Age + " years old"; 
         txtblock.Text = message; 
      } 
		
   }  
	
   public class Person {
      private string nameValue;
		
      public string Name {
         get { return nameValue; } 
         set { nameValue = value; } 
      } 
		
      private double ageValue; 
		
      public double Age {
         get { return ageValue; } 
			
         set {
            if (value != ageValue) {
               ageValue = value; 
            } 
         } 
      }
		
   } 
	
}

Wenn der obige Code kompiliert und ausgeführt wird, wird das folgende Fenster angezeigt. Drücke denDisplay Taste.

Lassen Sie uns den Namen und das Alter ändern und auf klicken Display erneut drücken.

Sie können das in der Klick-Schaltfläche sehen ‘Display’wird der Text der Textfelder nicht verwendet, um die Daten anzuzeigen TextBlock Es werden jedoch die Klassenvariablen verwendet.

Ich empfehle Ihnen, den obigen Code in beiden Fällen zum besseren Verständnis auszuführen.

Elementbindung

Es ist auch möglich, nicht an eine Standarddatenquelle, sondern an ein anderes Element auf der Seite zu binden. Lassen Sie uns eine Anwendung namens erstellenElementBindingIn dem ein Schieberegler und ein Rechteck erstellt werden und mit dem Schieberegler die Breite und Höhe des Rechtecks ​​gebunden werden. Unten ist der Code in XAML angegeben.

<Page 
   x:Class = "ElementBinding.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:ElementBinding" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">  
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <StackPanel VerticalAlignment = "Center" HorizontalAlignment = "Center">
		
         <Rectangle Height = "100" Width = "100" Fill = "SteelBlue"  
            RenderTransformOrigin = "0.5,0.5" Margin = "50"> 
				
            <Rectangle.RenderTransform> 
               <CompositeTransform ScaleX = "{Binding Value, ElementName = MySlider}" 
                  ScaleY = "{Binding Value, ElementName = MySlider}"/> 
            </Rectangle.RenderTransform> 
				
         </Rectangle>
			
         <Slider Minimum = ".5" Maximum = "2.0" StepFrequency = ".1"  
            x:Name = "MySlider" /> 
				
      </StackPanel> 
   </Grid> 
	
</Page>

Wenn der obige Code kompiliert und ausgeführt wird, wird das folgende Fenster angezeigt.

Mit einem Schieberegler können Sie die Größe des Rechtecks ​​wie unten gezeigt ändern.

Die Leistung von Anwendungen, z. B. wie schnell Ihre Anwendung beim Start angezeigt wird oder wie sie zum nächsten Inhalt usw. navigiert, ist sehr wichtig.

Die Leistung einer Anwendung kann durch viele Faktoren beeinträchtigt werden, einschließlich der Fähigkeit der XAML-Rendering-Engine, den gesamten XAML-Code in Ihrer Anwendung zu analysieren. XAML ist ein sehr leistungsfähiges Tool zum Erstellen von Benutzeroberflächen. Es kann jedoch mithilfe der neuen Techniken, die jetzt in Windows 10-Anwendungen verfügbar sind, robuster sein.

In Ihren Anwendungen gibt es beispielsweise bestimmte Dinge, die Sie beim Laden der Seite anzeigen möchten und später nicht mehr benötigen. Es ist auch möglich, dass beim Start nicht alle UI-Elemente geladen werden müssen.

In Windows 10-Apps wurden in XAML einige neue Funktionen hinzugefügt, die die XAML-Leistung verbessern.

Die Leistung jeder universellen Windows-Anwendung kann durch die folgenden Techniken verbessert werden:

  • Progressives Rendern
  • Aufgeschobenes Laden

Progressives Rendern

In Windows 10 werden in XAML zwei neue und sehr coole Funktionen eingeführt. Sie sind -

x: Binden

Es ist eine neue Syntax, die in XAML eingeführt wurde und zum Binden verwendet wird. Sie funktioniert fast genauso wie die Binding Syntax tut. x:Bindhat zwei wesentliche Unterschiede; Es bietet eine Validierung der Syntax zur Kompilierungszeit und eine bessere Leistung.

X: Phase

Es bietet die Möglichkeit, das Rendern von XAML-Steuerelementen innerhalb einer Datenvorlage zu priorisieren. Für jedes UI-Element kann nur eine Phase angegeben werden. Wenn ja, gilt dies für alle Bindungen des Elements. Wenn keine Phase angegeben ist, wird Phase 0 angenommen.

In UWP-Anwendungen (Universal Windows Platform) bieten diese beiden neuen Funktionen Leistungsverbesserungen. Es kann auch in vorhandenen Windows 8.x-Anwendungen verwendet werden, die auf Windows 10 migriert werden.

Im Folgenden finden Sie ein Beispiel, an das die Mitarbeiterobjekte gebunden sind GridView durch die Nutzung x:Bind Stichwort.

<Page 
   x:Class = "XAMLPhase.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:local = "using:XAMLPhase" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">  
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <GridView Name = "Presidents" ItemsSource = "{Binding}" Height = "300" 
         Width = "400" Margin = "50"> 
			
         <GridView.ItemTemplate> 
            <DataTemplate x:DataType = "local:Employee"> 
				
               <StackPanel Orientation = "Horizontal" Margin = "2"> 
                  <TextBlock Text = "{x:Bind Name}" Width = "95" Margin = "2" /> 
                  <TextBlock Text = "{x:Bind Title}" Width = "95" Margin = "2"  
                     x:Phase = "1"/> 
               </StackPanel> 
					
            </DataTemplate> 
         </GridView.ItemTemplate>
			
      </GridView> 
		
   </Grid> 
	
</Page>

Im obigen XAML-Code x:Phase = "1"wird mit Titel definiert. Daher wird in der ersten PhaseName wird gerendert und dann Title wird gerendert.

Unten ist die angegeben Employee class Implementierung in C #.

using System.Collections.ObjectModel; 
using System.ComponentModel; 
using System.Runtime.CompilerServices; 
using Windows.UI.Xaml.Controls;
  
// The Blank Page item template is documented at
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409 
	
namespace XAMLPhase {

   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class MainPage : Page {
      public MainPage() {
         this.InitializeComponent(); 
         DataContext = Employee.GetEmployees(); 
      } 
   } 
	
   public class Employee : INotifyPropertyChanged {
      private string name; 
		
      public string Name {
         get { return name; } 
			
         set {
            name = value; 
            RaiseProperChanged(); 
         } 
      } 
		
      private string title; 
		
      public string Title {
         get { return title; }
			
         set {
            title = value; 
            RaiseProperChanged(); 
         } 
      }
		
      public static Employee GetEmployee() {
       
         var emp = new Employee() {
            Name = "Waqas", 
            Title = "Software Engineer" 
         };  
			
         return emp; 
      } 
		
      public event PropertyChangedEventHandler PropertyChanged;
		
      private void RaiseProperChanged( 
         [CallerMemberName] string caller = "") {
			
         if (PropertyChanged != null) {
            PropertyChanged(this, new PropertyChangedEventArgs(caller)); 
         } 
			
      } 
		
      public static ObservableCollection<Employee> GetEmployees() {
         var employees = new ObservableCollection<Employee>(); 
			
         employees.Add(new Employee() { Name = "Ali", Title = "Developer" }); 
         employees.Add(new Employee() { Name = "Ahmed", Title = "Programmer" }); 
         employees.Add(new Employee() { Name = "Amjad", Title = "Desiner" }); 
         employees.Add(new Employee() { Name = "Waqas", Title = "Programmer" }); 
         employees.Add(new Employee() { Name = "Bilal", Title = "Engineer" }); 
         employees.Add(new Employee() { Name = "Waqar", Title = "Manager" }); 
			
         return employees; 
      } 
		
   }
	
}

Wenn der oben angegebene Code ausgeführt wird, wird das folgende Fenster angezeigt.

Das X:Phase mit x:Bind wird verwendet, um die zu rendern ListView und GridView Elemente inkrementell und verbessern das Schwenkerlebnis.

Aufgeschobenes Laden

Das verzögerte Laden ist eine Technik, mit der die Ladezeit beim Start minimiert werden kann, indem die Anzahl der XAML-UI-Elemente beim Start einer Anwendung verringert wird. Wenn Ihre Anwendung 30 Benutzeroberflächenelemente enthält und der Benutzer beim Start nicht alle diese Elemente benötigt, können alle Elemente, die nicht benötigt werden, durch Aufschieben einige Ladezeit sparen.

x:DeferLoadStrategy = "Lazy" verzögert die Erstellung eines Elements und seiner untergeordneten Elemente, wodurch die Startzeit verkürzt, die Speichernutzung jedoch geringfügig erhöht wird.

Das zurückgestellte Element kann durch Aufrufen realisiert / erstellt werden FindName mit dem Namen, der für das Element definiert wurde.

Sobald ein zurückgestelltes Element erstellt wurde, passieren mehrere Dinge -

  • Das Loaded-Ereignis für das Element wird ausgelöst.

  • Alle Bindungen am Element werden ausgewertet.

  • Wenn der Antrag registriert ist, um Benachrichtigungen über Eigenschaftsänderungen für die Eigenschaft zu erhalten, die die zurückgestellten Elemente enthält, wird die Benachrichtigung ausgelöst.

Unten ist ein Beispiel angegeben, in dem x:DeferLoadStrategy = "Lazy" wird für ein Raster verwendet, das vier Textblöcke enthält und beim Start Ihrer Anwendung erst geladen wird, wenn Sie sie laden.

<Page 
   x:Class = "UWPDeferredLoading.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPDeferredLoading" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d"> 
	
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <Grid x:Name = "DeferredGrid" x:DeferLoadStrategy = "Lazy" Margin = "50"> 
         <Grid.RowDefinitions> 
            <RowDefinition Height = "Auto" /> 
            <RowDefinition Height = "Auto" /> 
         </Grid.RowDefinitions> 
			
         <Grid.ColumnDefinitions> 
            <ColumnDefinition Width = "Auto" /> 
            <ColumnDefinition Width = "Auto" /> 
         </Grid.ColumnDefinitions>
			
         <TextBlock Height = "100" Width = "100" Text = "TextBlock 1" Margin = "0,0,4,4" /> 
			
         <TextBlock Height = "100" Width = "100" Text = "TextBlock 2" 
            Grid.Column = "1" Margin = "4,0,0,4" /> 
				
         <TextBlock Height = "100" Width = "100" Text = "TextBlock 3" 
            Grid.Row = "1" Margin = "0,4,4,0" /> 
				
         <TextBlock Height = "100" Width = "100" Text = "TextBlock 4" 
            Grid.Row = "1" Grid.Column = "1" Margin = "4,4,0,0" /> 
      </Grid> 
		
      <Button x:Name = "RealizeElements" Content = "Show Elements"  
         Click = "RealizeElements_Click" Margin = "50"/> 
			
   </Grid>   
	
</Page>

Das folgende Programm ist die Implementierung eines Klickereignisses, bei der das Raster auf der Hauptseite der Anwendung geladen wird.

using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
 
// The Blank Page item template is documented at
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409  
	
namespace UWPDeferredLoading {

   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class MainPage : Page {
      public MainPage() {
         this.InitializeComponent(); 
      }  
		
      private void RealizeElements_Click(object sender, RoutedEventArgs e) {
         this.FindName("DeferredGrid"); // This will realize the deferred grid 
      } 
		
   } 
	
}

Wenn der obige Code eingehalten und ausgeführt wurde, wird nur eine Schaltfläche angezeigt. DasTextblocks werden beim Start nicht geladen.

Nun, wenn Sie auf die klicken Show Elements Mit dieser Schaltfläche werden die Textblöcke geladen, wodurch die Startleistung Ihrer Anwendung verbessert wird.

In Windows 10 können UWP-Anwendungen (Universal Windows Platform) jetzt auf einer Reihe von Gerätefamilien ausgeführt werden, z.

  • Desktop device family - Tablets, Laptops, PCs

  • Mobile device family - Windows-Telefone, Phablets

  • IoT device family - Kompakte Geräte wie Wearables oder Haushaltsgeräte

  • Team device family - Oberflächennabe

Jede Gerätefamilie hat ihre eigene Bildschirm- und Fenstergröße. Wie kann man also eine App entwerfen, die auf mehreren Geräten eine großartige Benutzererfahrung mit dramatisch unterschiedlichen Bildschirmgrößen und Eingabemethoden bietet?

Das Entwerfen Ihrer Anwendung für mehrere Gerätefamilien erfordert zusätzliche Überlegungen, Planung und Design. Windows 10 UWP bietet eine Reihe integrierter Funktionen und universeller Bausteine, die das Entwerfen für mehrere Geräte erheblich vereinfachen und automatisch über die verschiedenen Bildschirm- und Fenstergrößen skalieren, die von den Plattformsteuerelementen unterstützt werden.

Neue integrierte Funktionen

Im Folgenden sind die neuen Funktionen aufgeführt, die die Entwickler beim Erstellen einer UWP-Anwendung verwenden können. Diese Funktionen sind automatisch und kostenlos.

Effektive Pixel- und Plattformskalierung

Wenn Ihre UWP-Anwendung auf einem von Windows 10 unterstützten Gerät ausgeführt wird, gilt Folgendes:

  • Das System verwendet einen Algorithmus, um die Art und Weise zu normalisieren, in der Steuerelemente, Schriftarten und andere Elemente der Benutzeroberfläche auf dem Bildschirm eines Geräts angezeigt werden, auf dem es gerade ausgeführt wird.

  • Der Skalierungsalgorithmus steuert den Betrachtungsabstand und die Bildschirmdichte (Pixel pro Zoll), um die angenommene Größe (anstelle der physischen Größe) zu optimieren.

  • Der Skalierungsalgorithmus stellt sicher, dass eine 36-Pixel-Schrift auf einem 10 Fuß entfernten Surface Hub für den Benutzer genauso lesbar ist wie eine 36-Pixel-Schrift auf einem 5-Zoll-Telefon, das nur wenige Zentimeter entfernt ist.

Universeller Eingang und intelligente Interaktionen

Die universelle Windows-Plattform verfügt über integrierte Eingabesysteme für intelligente Interaktionen, die die Eingabe für alle Geräte verstehen. Wenn Sie beispielsweise eine Klickinteraktion in Ihrer Anwendung entwerfen, müssen Sie nicht wissen, ob der Klick von einem tatsächlichen Mausklick oder einem Fingertipp stammt. Das System erledigt dies automatisch für Sie.

Universelle Bausteine

Es gibt einige wertvolle Bausteine, die das Entwerfen von Anwendungen für mehrere Gerätefamilien in Universal Windows Platform (UWP) erleichtern.

Universelle Bedienelemente

UWP bietet eine Reihe von Universal Controls, die garantiert auf allen Windows 10-Geräten einwandfrei funktionieren.

  • Diese Liste "Universelle Steuerelemente" enthält allgemeine Steuerelemente wie Optionsfelder, Combobox und Textfeld usw.

  • Es enthält auch einige ausgefeilte Steuerelemente wie grid view und list view Dadurch kann eine Liste von Elementen aus einem Datenstrom und einer Vorlage generiert werden.

Universelle Stile

Die UWP-App erhält automatisch einen Standardsatz von Stilen, der Ihnen diese Funktionen bietet:

  • Eine Reihe von Stilen, die Ihrer App automatisch ein helles oder dunkles Thema verleihen.

  • Standardanimationen für Interaktionen.

  • Automatische Unterstützung für kontrastreiche Modi.

  • Automatische Unterstützung für andere Sprachen. Unsere Standardstile wählen automatisch die richtige Schriftart für jede von Windows unterstützte Sprache aus. Sie können sogar mehrere Sprachen in derselben App verwenden und sie werden ordnungsgemäß angezeigt.

Eine Universal Windows Platform (UWP) -Anwendung kann auf vielen verschiedenen Geräten ausgeführt werden, und jedes Gerät verfügt über eine eigene Eingabeform, Bildschirmauflösung, DPI-Dichte und andere einzigartige Merkmale.

In Windows 10 können Sie mithilfe neuer universeller Steuerelemente, Layoutfelder und Tools Ihre Benutzeroberfläche problemlos an die Geräte anpassen, auf denen Ihre Anwendung möglicherweise ausgeführt wird. Wenn Ihre UWP-Anwendung beispielsweise auf einem Desktop-Computer, einem mobilen Gerät oder einem Tablet ausgeführt wird, können Sie die Benutzeroberfläche so anpassen, dass unterschiedliche Bildschirmauflösungen, Bildschirmgrößen und DPI-Dichte genutzt werden.

In Windows 10 können Sie Ihre Benutzeroberfläche mit den folgenden Funktionen problemlos auf mehrere Geräte ausrichten:

  • Sie können Ihre Benutzeroberfläche für verschiedene Bildschirmauflösungen und Bildschirmgrößen verbessern, indem Sie universelle Steuerelemente und Layoutfelder verwenden.

  • Mit der allgemeinen Eingabeverarbeitung können Sie Eingaben über ein Touchpad, einen Stift, eine Maus, eine Tastatur oder einen Controller wie einen Microsoft Xbox-Controller empfangen.

  • Mithilfe von Tools können Sie die Benutzeroberfläche Ihrer Anwendung so gestalten, dass sie sich an unterschiedliche Bildschirmauflösungen anpassen lässt.

  • Die adaptive Skalierung passt sich an die Auflösung und die DPI-Unterschiede zwischen den Geräten an.

In Windows 10 können Sie Anwendungen einfach nach Belieben anordnen, in der Größe ändern und positionieren. Es gibt dem Benutzer auch eine gewisse Flexibilität, um Ihre Anwendung so zu verwenden, wie er es möchte. In Windows 10 gibt es verschiedene Möglichkeiten, um reaktionsschnelle Techniken in Ihrer UWP-Anwendung zu implementieren, sodass sie unabhängig von der Bildschirm- oder Fenstergröße hervorragend aussehen.

VisualStateManager

In Windows 10 wird die VisualStateManagerclass verfügt über zwei neue Mechanismen, mit deren Hilfe Sie ein responsives Design in Ihren UWP-Anwendungen implementieren können. Das neueVisualState.StateTriggers ermöglicht es dem Entwickler, bestimmte Bedingungen wie die Fensterhöhe oder -breite und dann die zu überprüfen VisualState.Setters APIs definieren visuelle Zustände als Reaktion auf diese bestimmten Bedingungen.

Schauen wir uns das folgende Beispiel an, in dem einige Steuerelemente im Stapelfenster hinzugefügt werden.

<Page 
   x:Class = "UWPAdaptiveUI.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPAdaptiveUI" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008"
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d"> 
	
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}">
      <VisualStateManager.VisualStateGroups>
		
         <VisualStateGroup>
			
            <VisualState>
				
               <VisualState.StateTriggers>
                  <!-- VisualState to be triggered when window 
                     width is >=720 effective pixels. -->
                  <AdaptiveTrigger MinWindowWidth = "720" />
               </VisualState.StateTriggers>
					
               <VisualState.Setters>
                  <Setter Target = "myPanel.Orientation" Value = "Horizontal" />
               </VisualState.Setters>
					
            </VisualState>
				
         </VisualStateGroup>
			
      </VisualStateManager.VisualStateGroups>
		
      <StackPanel x:Name = "myPanel" Orientation = "Vertical">
		
         <TextBlock Text = "Windows 10 Tutorials: Text block 1. " 
            Style = "{ThemeResource BodyTextBlockStyle}"/>
				
         <TextBlock Text = "Windows 10 Tutorials: Text block 2. " 
            Style = "{ThemeResource BodyTextBlockStyle}"/>
				
         <TextBlock Text = "Windows 10 Tutorials: Text block 3. " 
            Style = "{ThemeResource BodyTextBlockStyle}"/>
				
      </StackPanel> 
		
   </Grid>
	
</Page>

Jetzt VisualStateManager, passt die Ausrichtung des Stapelfelds basierend auf der Fensterbreite an. Wenn die Breite> = 720 ist, wird die Ausrichtung horizontal, andernfalls bleibt sie vertikal. Wenn der obige Code kompiliert und ausgeführt wird, wird das folgende Fenster angezeigt, das drei Textblöcke in vertikaler Reihenfolge enthält.

Lassen Sie uns die Breite des obigen Fensters ändern und Sie werden das folgende Fenster sehen -

Jetzt können Sie sehen, dass die Textblöcke in horizontaler Reihenfolge sind.

RelativePanel

RelativePanelkann verwendet werden, um die UI-Elemente anzuordnen, indem räumliche Beziehungen zwischen den Elementen ausgedrückt werden. Nehmen wir ein Beispiel, in dem einige Rechtecke im relativen Bereich erstellt werden.

<Page 
   x:Class = "UWPAdaptiveUI.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPAdaptiveUI" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d"> 
	
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
	
      <VisualStateManager.VisualStateGroups> 
		
         <VisualStateGroup> 
			
            <VisualState> 
				
               <VisualState.StateTriggers> 
                  <AdaptiveTrigger MinWindowWidth = "720" /> 
               </VisualState.StateTriggers> 
					
               <VisualState.Setters> 
                  <Setter Target = "GreenRect.(RelativePanel.RightOf)"
                     Value = "BlueRect" /> 
                  <Setter Target = "GreenRect.(RelativePanel.AlignRightWithPanel)" 
                     Value = "True" /> 
               </VisualState.Setters> 
					
            </VisualState> 
				
         </VisualStateGroup>
			
      </VisualStateManager.VisualStateGroups>
		
      <RelativePanel BorderBrush = "Gray" BorderThickness = "10"> 
         <Rectangle x:Name = "RedRect" Fill = "Red" MinHeight = "100" 
            MinWidth = "100"/> 
				
         <Rectangle x:Name = "BlueRect" Fill = "Blue" MinHeight = "100" 
            MinWidth = "100" RelativePanel.RightOf = "RedRect" /> 
				
         <!-- Width is not set on the green and yellow rectangles. 
            It's determined by the RelativePanel properties. --> 
				
         <Rectangle x:Name = "GreenRect" Fill = "Green" MinHeight = "100" 
            RelativePanel.Below = "BlueRect" RelativePanel.AlignLeftWith = "RedRect" 
            RelativePanel.AlignRightWith = "BlueRect"/> 
				
         <Rectangle Fill = "Yellow" MinHeight = "100" RelativePanel.Below = "GreenRect" 
            RelativePanel.AlignLeftWith = "BlueRect"
            RelativePanel.AlignRightWithPanel = "True"/> 
				
      </RelativePanel> 
		
   </Grid> 
	
</Page>

Wenn der obige Code kompiliert und ausgeführt wird, wird das folgende Fenster angezeigt.

Wenn Sie die Größe des obigen Fensters ändern, sehen Sie, dass das grüne Rechteck jetzt in der oberen Reihe links vom blauen Rechteck wie unten gezeigt angepasst wird.

In diesem Kapitel werden wir die Übernahme Ihrer Anwendung auf verschiedene von Windows 10 unterstützte Geräte demonstrieren. Wir haben bereits gelernt, wie Sie Ihre Benutzeroberfläche und alle in UWP-Anwendungen verwendeten Tricks, Techniken und Steuerelemente übernehmen.

Jetzt lernen wir, wie Sie Ihren Code übernehmen, weil

  • Anwendungscodes sind nicht für alle Geräte gleich.

  • APIs, insbesondere für Xbox, sind für mobile Geräte nicht verfügbar. Das gleiche gilt für HoloLens usw.

Adaptive Code kann Ihre Anwendung bedingt beleuchten und Code nur ausführen, wenn er auf einer bestimmten Gerätefamilie und / oder auf einer bestimmten Version der Plattform- / Erweiterungs-APIs ausgeführt wird.

Code schreiben

In Windows 10 können Sie die UWP-Anwendungen in Visual Studio mithilfe von C ++, C #, Visual Basic oder JavaScript implementieren.

  • Mit C # und Visual Basic können Sie XAML für das UI-Design verwenden.

  • Mit C ++ können Sie entweder DirectX anstelle von XAML verwenden.

  • Für JavaScript können Sie HTML für Ihre Präsentationsebene verwenden, bei der es sich um plattformübergreifende Webstandards handelt.

Die Windows Core-APIs werden für alle Geräte auf dieselbe Weise ausgeführt, die die meisten Funktionen enthalten, die Sie für Ihren Code und Ihre Benutzeroberfläche benötigen. Für den Code und die Benutzeroberfläche, die auf bestimmte Gerätefamilien zugeschnitten sind, müssen Sie jedoch den adaptiven Code und die adaptive Benutzeroberfläche verwenden.

Calling an API that is NOT implemented by the target device family −

Die Benutzeroberfläche lässt sich leicht an verschiedene Bildschirme anpassen, aber verschiedene Gerätefamilien haben nicht nur unterschiedliche Bildschirmgrößen, sondern auch viel mehr.

  • Beispielsweise verfügen die Mobiltelefone über einige Hardwaretasten wie Zurück und Kamera, die auf anderen Geräten wie dem PC möglicherweise nicht verfügbar sind.

  • Standardmäßig enthalten die Kern-APIs den größten Teil der Funktionalität, die für alle Geräte funktioniert. Die gerätespezifische Funktionalität kann jedoch verwendet werden, indem auf die Erweiterungs-SDKs in Ihren UWP-Anwendungen wie bei externen Assemblys verwiesen wird.

Führen Sie die folgenden Schritte aus, um ein bestimmtes Erweiterungs-SDK hinzuzufügen, das in Ihrer Anwendung benötigt wird.

  • Klicken Sie mit der rechten Maustaste auf References.

  • Wählen “Add References..”. Der folgende Dialog wird geöffnet.

  • Das Hinzufügen einer Erweiterung ist so einfach wie das Hinzufügen einer Projektreferenz.

  • Jetzt können Sie ein beliebiges Erweiterungs-SDK aus der Liste hinzufügen, das Desktop-Erweiterung, IoT-Erweiterung und mobile Erweiterung usw. enthält.

Desktop- und Mobile-Erweiterungen sind die beiden am häufigsten verwendeten Plattform-Erweiterungs-SDKs. Die Mobile-Erweiterung aktiviert beispielsweise die APIs, die zur Verwendung der Hardware-Kamerataste erforderlich sind.

Sie können die Gerätefunktionen mithilfe von überprüfen Windows.Foundation.Metadata.ApiInformationKlassenmethode, die eine boolesche Ausgabe zurückgibt, wenn der Typ auf dem aktuellen Gerät unterstützt wird. Sie können beispielsweise Ihre Windows-App aktivieren, um die Schaltfläche Kamera mit dem folgenden Code zu verwenden:

bool isHardwareButtonsAPIPresent = 
   Windows.Foundation.Metadata.ApiInformation.
   IsTypePresent("Windows.Phone.UI.Inpu t.HardwareButtons");  
		
if (isHardwareButtonsAPIPresent) { 
   Windows.Phone.UI.Input.HardwareButtons.CameraPressed += HardwareButtons_CameraPressed; 
}

Der Tastencode der Telefonkamera wird nur ausgeführt, wenn das Mobile Extension SDK auf dem Gerät aktiviert ist. In ähnlicher Weise können Sie mithilfe der aktuellen API-Version auch nach bestimmten Ereignissen, Methoden oder Eigenschaften suchenIsEventPresent, IsMethodPresent, IsPropertyPresent, Anstatt von IsTypePresent Wie nachfolgend dargestellt.

bool isHardwareButtons_CameraPressedAPIPresent = 
   Windows.Foundation.Metadata.ApiInformation.IsEventPresent 
   ("Windows.Phone.UI.Input.HardwareButtons", "CameraPressed");

Win32-APIs im UWP

Eine UWP-Anwendung (Universal Widows Platform) oder eine Windows Runtime-Komponente, die in C ++ / CX geschrieben sind, können auf Win32-APIs zugreifen, die jetzt auch Teil von UWP sind. Alle Windows 10-Gerätefamilien können Win32-APIs implementieren, indem Sie Ihre Anwendung mit verknüpfenWindowsapp.lib.

Windowsapp.libist eine "Umbrella" -Bibliothek, die die Exporte für die UWP-APIs bereitstellt. Verknüpfen mitWindowsapp.lib wird zu Ihrer App Abhängigkeiten hinzufügen dlls die auf allen Windows 10-Gerätefamilien vorhanden sind.

Schauen wir uns ein einfaches Beispiel an, in dem die Anwendung sowohl auf den Desktop als auch auf das Telefon abzielt. Wenn die Anwendung auf dem Desktop ausgeführt wird, wird daher nicht die Statusleiste angezeigt. Wenn dieselbe Anwendung jedoch auf dem Telefon ausgeführt wird, wird die Statusleiste angezeigt.

Unten ist der XAML-Code angegeben, in dem verschiedene Steuerelemente hinzugefügt werden.

<Page 
   x:Class = "UWPAdoptiveCode.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPAdoptiveCode" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008"
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">  

   <Page.Background> 
      <SolidColorBrush Color = "Green"/> 
   </Page.Background>
	
   <Page.BottomAppBar> 
      <CommandBar x:Name = "commandBar" > 
         <AppBarButton Icon = "Accept" Label = "appbarbutton"/> 
         <AppBarButton Icon = "Cancel" Label = "appbarbutton"/> 
      </CommandBar> 
   </Page.BottomAppBar>
	
   <Grid Background = "AliceBlue"> 
	
      <VisualStateManager.VisualStateGroups> 
		
         <VisualStateGroup> 
			
            <VisualState> 
               <VisualState.StateTriggers> 
                  <local:DeviceFamilyTrigger DeviceFamily = "Desktop" /> 
               </VisualState.StateTriggers> 
					
               <VisualState.Setters> 
                  <Setter Target = "StatusBarControls.Visibility" 
                     Value = "Collapsed"/> 
               </VisualState.Setters>  
					
            </VisualState> 
				
         </VisualStateGroup> 
			
      </VisualStateManager.VisualStateGroups> 
		
      <StackPanel HorizontalAlignment = "Left" Margin = "75,164,0,0"
         VerticalAlignment = "Top" > 
			
         <RadioButton x:Name = "ShowAppBarRadioButton" Content = "Show AppBar"
            HorizontalAlignment = "Stretch" VerticalAlignment = "Stretch"
            IsChecked = "True" Checked = "RadioButton_Checked"/>
				
         <RadioButton x:Name = "ShowOpaqueAppBarRadioButton" 
            Content = "Show Transparent AppBar" HorizontalAlignment = "Stretch"
            VerticalAlignment = "Stretch" Checked = "RadioButton_Checked"/> 
				
         <RadioButton x:Name = "HideAppBarRadioButton" Content = "Hide AppBar"
            HorizontalAlignment = "Stretch" VerticalAlignment = "Stretch" 
            Checked = "RadioButton_Checked"/>
				
      </StackPanel> 
		
      <StackPanel x:Name = "StatusBarControls" Orientation = "Vertical" 
         Margin = "75,350,0,0" Visibility = "Visible">
			
         <CheckBox x:Name = "StatusBarBackgroundCheckBox" 
            Content = "Set StatusBar Background"
            Checked = "StatusBarBackgroundCheckBox_Checked" 
            Unchecked = "StatusBarBackgroundCheckBox_Unchecked"/>
				
         <CheckBox x:Name = "StatusBarHiddenCheckBox" 
            Content = "Set StatusBar Hidden" Checked = "StatusBarHiddenCheckBox_Checked"
            Unchecked = "StatusBarHiddenCheckBox_Unchecked"/> 
				
      </StackPanel> 
		
   </Grid> 
	
</Page>

Im Folgenden ist die C # -Implementierung für verschiedene Ereignisse angegeben.

using Windows.UI; 
using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls;  

// The Blank Page item template is documented at
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409  

namespace UWPAdoptiveCode { 
   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class MainPage : Page { 
     
      private Color? DefaultTitleBarButtonsBGColor; 
      private Color? DefaultTitleBarBGColor;
		
      public MainPage() {
         this.InitializeComponent();
			
         //Windows.UI.ViewManagement.ApplicationView.GetForCurrentView().
            VisibleBoundsCh anged += MainPage_VisibleBoundsChanged;
				
         var viewTitleBar = Windows.UI.ViewManagement.ApplicationView.
            GetForCurrentView().TitleBar; 
				
         DefaultTitleBarBGColor = viewTitleBar.BackgroundColor; 
         DefaultTitleBarButtonsBGColor = viewTitleBar.ButtonBackgroundColor; 
      } 
		
      private void RadioButton_Checked(object sender, RoutedEventArgs e) {
        
         // Bottom AppBar shows on Desktop and Mobile 
         if (ShowAppBarRadioButton != null) {
			  
            if (ShowAppBarRadioButton.IsChecked.HasValue &&
               (ShowAppBarRadioButton.IsChecked.Value == true)) {
                 commandBar.Visibility = Windows.UI.Xaml.Visibility.Visible; 
                 commandBar.Opacity = 1; 
            } else {
               commandBar.Visibility = Windows.UI.Xaml.Visibility.Collapsed; 
            } 
         } 
			
         if (ShowOpaqueAppBarRadioButton != null) {
             
            if (ShowOpaqueAppBarRadioButton.IsChecked.HasValue &&
               (ShowOpaqueAppBarRadioButton.IsChecked.Value == true)){ 
                  commandBar.Visibility = Windows.UI.Xaml.Visibility.Visible; 
                  commandBar.Background.Opacity = 0; 
            } else{ 
               commandBar.Background.Opacity = 1; 
            } 
         } 
			
      } 
		
      private void StatusBarHiddenCheckBox_Checked(object sender, RoutedEventArgs e){
        
         // StatusBar is Mobile only 
         if (Windows.Foundation.Metadata.ApiInformation.
            IsTypePresent("Windows.UI.ViewManag ement.StatusBar")){ 
               var ignore = Windows.UI.ViewManagement.StatusBar.GetForCurrentView().HideAsync(); 
         } 
      } 
		
      private void StatusBarHiddenCheckBox_Unchecked(object sender, RoutedEventArgs e){
	  
         // StatusBar is Mobile only 
         if (Windows.Foundation.Metadata.ApiInformation.
            IsTypePresent("Windows.UI.ViewManag ement.StatusBar")){
               var ignore = Windows.UI.ViewManagement.StatusBar.GetForCurrentView().ShowAsync(); 
         } 
      }  
		
      private void StatusBarBackgroundCheckBox_Checked(object sender, RoutedEventArgs e){
       
         // StatusBar is Mobile only 
         if (Windows.Foundation.Metadata.ApiInformation.
            IsTypePresent("Windows.UI.ViewManag ement.StatusBar")){ 
				
               Windows.UI.ViewManagement.StatusBar.GetForCurrentView().
                  BackgroundColor = Windows.UI.Colors.Blue; 
					
               Windows.UI.ViewManagement.StatusBar.GetForCurrentView().
                   BackgroundOpacity = 1; 
         } 
      }  
		
      private void StatusBarBackgroundCheckBox_Unchecked(object sender, RoutedEventArgs e){
         
         // StatusBar is Mobile only 
         if (Windows.Foundation.Metadata.ApiInformation.
            IsTypePresent("Windows.UI.ViewManag ement.StatusBar")){
               Windows.UI.ViewManagement.StatusBar.GetForCurrentView().
                  BackgroundOpacity = 0; 
         } 
      } 
		
   } 
	
   public class DeviceFamilyTrigger : StateTriggerBase{
    
      //private variables 
      private string _deviceFamily;
	  
      //Public property 
      public string DeviceFamily {
         
         get {
            return _deviceFamily; 
         } 
         set{
            _deviceFamily = value; 
            var qualifiers = Windows.ApplicationModel.Resources.Core.ResourceContext.
               GetForCurrentView().Qua lifierValues; 
					
            if (qualifiers.ContainsKey("DeviceFamily")) 
               SetActive(qualifiers["DeviceFamily"] == _deviceFamily); 
            else 
               SetActive(false); 
         } 
      } 
   } 
}

Wenn der oben angegebene Code kompiliert und auf einem Mobiltelefon ausgeführt wird, wird das folgende Fenster angezeigt.

Sie können die Hintergrundfarbe der Statusleiste mit dem Kontrollkästchen wie im Bild gezeigt ändern.

Sie können auch die Statusleiste ausblenden.

Wenn Sie jetzt dieselbe Anwendung auf einem Desktop-Gerät ausführen, wird das folgende Fenster angezeigt, in dem die Statusleiste und die für die Statusleiste spezifischen Kontrollkästchen nicht sichtbar sind.

In jeder Anwendung sind die Daten eines der wichtigsten Dinge. Wenn du bist.net Entwickler kennen Sie möglicherweise den isolierten Speicher, und dasselbe Konzept wird in den UWP-Anwendungen (Universal Windows Platform) angewendet.

Dateispeicherorte

In diesen Bereichen kann Ihre Anwendung auf die Daten zugreifen. Die Anwendung enthält einen Bereich, der für diese bestimmte Anwendung privat ist und für die anderen nicht zugänglich ist. Es gibt jedoch viele andere Bereiche, in denen Sie Ihre Daten in einer Datei speichern und speichern können.

Nachfolgend finden Sie die kurzen Beschreibungen der einzelnen Ordner.

S.No. Ordner & Beschreibung
1

App package folder

Der Paketmanager installiert alle zugehörigen Dateien der App im App-Paketordner, und die App kann nur Daten aus diesem Ordner lesen.

2

Local folder

Anwendungen speichern lokale Daten in einem lokalen Ordner. Es kann Daten bis zum Limit auf dem Speichergerät speichern.

3

Roaming folder

Einstellungen und Eigenschaften in Bezug auf die Anwendung werden im Roaming-Ordner gespeichert. Andere Geräte können ebenfalls auf Daten aus diesem Ordner zugreifen. Die Größe ist auf bis zu 100 KB pro Anwendung begrenzt.

4

Temp Folder

Verwendung von temporärem Speicher und es gibt keine Garantie dafür, dass dieser weiterhin verfügbar ist, wenn Ihre Anwendung erneut ausgeführt wird.

5

Publisher Share

Gemeinsamer Speicher für alle Apps desselben Herausgebers. Es wird im App-Manifest deklariert.

6

Credential Locker

Wird zur sicheren Speicherung von Objekten mit Kennwortanmeldeinformationen verwendet.

7

OneDrive

OneDrive ist ein kostenloser Online-Speicher, der mit Ihrem Microsoft-Konto geliefert wird.

8

Cloud

Speichern Sie Daten in der Cloud.

9

Known folders

Diese Ordner sind bereits Ordner wie Meine Bilder, Videos und Musik bekannt.

10

Removable storage

USB-Speichergerät oder externe Festplatte usw.

APIs für die Dateiverwaltung

In Windows 8 wurden neue APIs für die Dateiverwaltung eingeführt. Diese APIs befinden sich in derWindows.Storage und Windows.Storage.StreamsNamespaces. Sie können diese APIs anstelle von verwendenSystem.IO.IsolatedStorageNamespace. Durch die Verwendung dieser APIs ist es einfacher, Ihre Windows Phone-App in den Windows Store zu portieren, und Sie können Ihre Anwendungen problemlos auf zukünftige Windows-Versionen aktualisieren.

Um auf lokale, Roaming- oder temporäre Ordner zuzugreifen, müssen Sie diese APIs aufrufen -

StorageFolder localFolder = ApplicationData.Current.LocalFolder; 
StorageFolder roamingFolder = ApplicationData.Current.RoamingFolder; 
StorageFolder tempFolder = ApplicationData.Current.TemporaryFolder;

Verwenden Sie den folgenden Code, um eine neue Datei in einem lokalen Ordner zu erstellen:

StorageFolder localFolder = ApplicationData.Current.LocalFolder; 
StorageFile textFile = await localFolder.CreateFileAsync(filename, 
   CreationCollisionOption.ReplaceExisting);

Hier ist der Code zum Öffnen der neu erstellten Datei und zum Schreiben von Inhalten in diese Datei.

using (IRandomAccessStream textStream = await textFile.OpenAsync(FileAccessMode.ReadWrite)) { 
	
   using (DataWriter textWriter = new DataWriter(textStream)){
      textWriter.WriteString(contents); 
      await textWriter.StoreAsync(); 
   } 
		
}

Sie können dieselbe Datei erneut aus dem lokalen Ordner öffnen, wie im folgenden Code gezeigt.

using (IRandomAccessStream textStream = await textFile.OpenReadAsync()) { 

   using (DataReader textReader = new DataReader(textStream)){
      uint textLength = (uint)textStream.Size; 
      await textReader.LoadAsync(textLength); 
      contents = textReader.ReadString(textLength); 
   } 
	
}

Schauen wir uns ein einfaches Beispiel an, um zu verstehen, wie das Lesen und Schreiben der Daten funktioniert. Unten ist der XAML-Code angegeben, in dem verschiedene Steuerelemente hinzugefügt werden.

<Page
   x:Class = "UWPFileHandling.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPFileHandling" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">  
	
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
	
      <Button x:Name = "readFile" Content = "Read Data From File"  
         HorizontalAlignment = "Left" Margin = "62,518,0,0"  
         VerticalAlignment = "Top" Height = "37" Width = "174"  
         Click = "readFile_Click"/> 
			
      <TextBox x:FieldModifier = "public" x:Name = "textBox"  
         HorizontalAlignment = "Left" Margin = "58,145,0,0" TextWrapping = "Wrap"  
         VerticalAlignment = "Top" Height = "276" Width = "245"/>.
			
      <Button x:Name = "writeFile" Content = "Write Data to File"
         HorizontalAlignment = "Left" Margin = "64,459,0,0"  
         VerticalAlignment = "Top" Click = "writeFile_Click"/>
			
      <TextBlock x:Name = "textBlock" HorizontalAlignment = "Left"  
         Margin = "386,149,0,0" TextWrapping = "Wrap"  
         VerticalAlignment = "Top" Height = "266" Width = "250"  
         Foreground = "#FF6231CD"/> 
			
   </Grid> 
	 
</Page>

Im Folgenden ist die C # -Implementierung für verschiedene Ereignisse sowie die Implementierung des angegeben FileHelper Klasse zum Lesen und Schreiben von Daten in die Textdatei.

using System; 
using System.IO; 
using System.Threading.Tasks; 

using Windows.Storage; 
using Windows.Storage.Streams; 
using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls;
  
// The Blank Page item template is documented at 
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409 
 
namespace UWPFileHandling {
 
   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public partial class MainPage : Page {
      const string TEXT_FILE_NAME = "SampleTextFile.txt"; 
		
      public MainPage(){ 
         this.InitializeComponent(); 
      }  
		
      private async void readFile_Click(object sender, RoutedEventArgs e) {
         string str = await FileHelper.ReadTextFile(TEXT_FILE_NAME); 
         textBlock.Text = str; 
      }
		
      private async void writeFile_Click(object sender, RoutedEventArgs e) {
         string textFilePath = await FileHelper.WriteTextFile(TEXT_FILE_NAME, textBox.Text); 
      }
		
   } 
	
   public static class FileHelper {
     
      // Write a text file to the app's local folder. 
	  
      public static async Task<string> 
         WriteTextFile(string filename, string contents) {
         
         StorageFolder localFolder = ApplicationData.Current.LocalFolder; 
         StorageFile textFile = await localFolder.CreateFileAsync(filename,
            CreationCollisionOption.ReplaceExisting);  
				
         using (IRandomAccessStream textStream = await 
            textFile.OpenAsync(FileAccessMode.ReadWrite)){ 
             
               using (DataWriter textWriter = new DataWriter(textStream)){ 
                  textWriter.WriteString(contents); 
                  await textWriter.StoreAsync(); 
               } 
         }  
			
         return textFile.Path; 
      }
		
      // Read the contents of a text file from the app's local folder.
	  
      public static async Task<string> ReadTextFile(string filename) {
         string contents;  
         StorageFolder localFolder = ApplicationData.Current.LocalFolder; 
         StorageFile textFile = await localFolder.GetFileAsync(filename);
			
         using (IRandomAccessStream textStream = await textFile.OpenReadAsync()){
             
            using (DataReader textReader = new DataReader(textStream)){
               uint textLength = (uint)textStream.Size; 
               await textReader.LoadAsync(textLength); 
               contents = textReader.ReadString(textLength); 
            }
				
         }
			
         return contents; 
      } 
   } 
}

Wenn der obige Code kompiliert und ausgeführt wird, wird das folgende Fenster angezeigt.

Jetzt schreiben Sie etwas in das Textfeld und klicken auf “Write Data to File”Taste. Das Programm schreibt die Daten in die Textdatei in einem lokalen Ordner. Wenn Sie auf klicken“Read Data from File” Mit dieser Schaltfläche liest das Programm die Daten aus derselben Textdatei, die sich im lokalen Ordner befindet, und zeigt sie im Textblock an.

In vielen Anwendungen gibt es bestimmte Datentypen, die in irgendeiner Beziehung zueinander stehen. Diese Datentypen, die schwer in einer Datei zu speichern sind, können in einer Datenbank gespeichert werden.

Wenn Sie mit den Datenbanktypen wie SQL Server- oder Oracle-Datenbanken in einer Anwendung vertraut sind, ist dies sehr einfach zu verstehen SQLite database.

Was ist SQLite?

SQLite ist eine Softwarebibliothek, die ein eigenständiges, serverloses, transaktionsfreies SQL-Transaktionsdatenbankmodul implementiert.

Wichtige Funktionen sind -

  • SQLite ist das am weitesten verbreitete Datenbankmodul der Welt.

  • Der Quellcode für SQLite ist Open Source.

  • Aufgrund seiner Portabilität und seines geringen Platzbedarfs hat es einen großen Einfluss auf die Entwicklung von Spielen und mobilen Anwendungen.

Vorteile von SQLite

Das Folgende sind die Vorteile von SQLite -

  • Es ist eine sehr leichte Datenbank.
  • Es ist plattformunabhängig und funktioniert auf allen Plattformen.
  • Es hat einen kleinen Speicherbedarf.
  • Es ist zuverlässig.
  • Keine Einrichtung und Installation erforderlich.
  • Es hat keine Abhängigkeiten.

Benutzen SQLite In Ihren UWP-Anwendungen (Universal Windows Platform) müssen Sie die folgenden Schritte ausführen.

  • Erstellen Sie eine neue leere Universal Windows-App mit dem Namen UWPSQLiteDemo.

  • Gehe zum ToolsMenü und wählen Sie Erweiterungen und Updates. Der folgende Dialog wird geöffnet.

  • Nach Auswahl von Erweiterungen und Updates wird das folgende Fenster geöffnet.
  • Wählen Sie nun die Online Option und suchen Sie im linken Bereich nach SQLite.

  • Laden Sie SQLite für Universal App Platform herunter und installieren Sie es.

  • Gehen Sie nun erneut zum Menü Extras und wählen Sie NuGet Package Manager > Package Manager Console Menüoption wie unten gezeigt.

  • Schreiben Sie den folgenden Befehl in die Package Manager-Konsole und drücken Sie die Eingabetaste, um diesen Befehl auszuführen:

Install-Package SQLite.Net-PCL

  • Klicken Sie nun mit der rechten Maustaste auf References im Lösungs-Explorer und wählen Sie Add References.

  • Der folgende Dialog wird geöffnet.
  • Wählen Extensions von der linken Scheibe unter Universal WindowsÜberprüfen Sie im mittleren Bereich SQLite für Universal App Platform und klicken Sie auf OK.

  • Jetzt können Sie SQLite in Ihren UWP-Anwendungen verwenden.

Sie können eine Datenbank mit dem folgenden Code erstellen.

string path = Path.Combine(Windows.Storage.ApplicationData.
   Current.LocalFolder.Path, "db.sqlite"); 

SQLite.Net.SQLiteConnection conn = new SQLite.Net.SQLiteConnection(new 
   SQLite.Net.Platform.WinRT.SQLitePlatformWinRT(), path);

Um eine Tabelle zu erstellen, müssen Sie aufrufen CreateTable Methode mit Tabellennamenobjekt.

conn.CreateTable<Customer>();

Sie können die Daten mit dem folgenden Code in Ihre Tabelle einfügen.

conn.Insert(new Customer(){
   Name = textBox.Text, 
   Age = textBox1.Text 
});

Im Folgenden finden Sie den Code zum Abrufen von Daten aus der Tabelle.

var query = conn.Table<Customer>(); 
string id = ""; 
string name = ""; 
string age = ""; 
 
foreach (var message in query) { 
   id = id + " " + message.Id; 
   name = name + " " + message.Name; 
   age = age + " " + message.Age; 
}

Lassen Sie uns anhand eines einfachen Beispiels verstehen, wie eine Datenbank, eine Tabelle erstellt und die Daten aus der Datenbank eingefügt und abgerufen werden. Wir werden Name und Alter hinzufügen und dann die gleichen Daten aus der Tabelle abrufen. Unten ist der XAML-Code angegeben, in dem verschiedene Steuerelemente hinzugefügt werden.

<Page 
   x:Class = "UWPSQLiteDemo.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPSQLiteDemo" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d"> 
	
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}" >
      <Button x:Name = "Retrieve" Content = "Retrieve" HorizontalAlignment = "Left"  
         VerticalAlignment = "Top" Margin = "384,406,0,0"  
         Click = "Retrieve_Click"/>
			
      <Button x:Name = "Add" Content = "Add" HorizontalAlignment = "Left"  
         VerticalAlignment = "Top" Margin = "291,406,0,0" Click = "Add_Click"/>
			
      <TextBlock x:Name = "textBlock" HorizontalAlignment = "Left"  
         TextWrapping = "Wrap" Text = "Name" VerticalAlignment = "Top"  
         Margin = "233,280,0,0" Width = "52"/>
			
      <TextBox x:Name = "textBox" HorizontalAlignment = "Left" TextWrapping = "Wrap"  
         VerticalAlignment = "Top" Margin = "289,274,0,0" Width = "370"/>
			
      <TextBlock x:Name = "textBlock1" HorizontalAlignment = "Left"  
         TextWrapping = "Wrap" Text = "Age" VerticalAlignment = "Top"  
         Margin = "233,342,0,0" Width = "52"/>
			
      <TextBox x:Name = "textBox1" HorizontalAlignment = "Left" TextWrapping = "Wrap"  
         VerticalAlignment = "Top" Margin = "289,336,0,0" Width = "191"/>
			
      <TextBlock x:Name = "textBlock2" HorizontalAlignment = "Left"  
         Margin = "290,468,0,0" TextWrapping = "Wrap"  
         VerticalAlignment = "Top" Width = "324" Height = "131"/>
			
   </Grid>
	
</Page>

Im Folgenden ist die C # -Implementierung für Ereignisse und angegeben SQLite database.

using SQLite.Net.Attributes; 

using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Linq; 
using System.Runtime.InteropServices.WindowsRuntime; 

using Windows.Foundation; 
using Windows.Foundation.Collections; 

using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
using Windows.UI.Xaml.Controls.Primitives; 
using Windows.UI.Xaml.Data; 
using Windows.UI.Xaml.Input; 
using Windows.UI.Xaml.Media; 
using Windows.UI.Xaml.Navigation;  

// The Blank Page item template is documented at 
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409 
 
namespace UWPSQLiteDemo {
 
   /// <summary>
      /// An empty page that can be used on its own or navigated to within a Frame.
   /// </summary>
	
   public sealed partial class MainPage : Page {
      string path; 
      SQLite.Net.SQLiteConnection conn; 
		
      public MainPage(){
         this.InitializeComponent();  
         path = Path.Combine(Windows.Storage.ApplicationData.Current.LocalFolder.Path,
            "db.sqlite"); 
         conn = new SQLite.Net.SQLiteConnection(new 
            SQLite.Net.Platform.WinRT.SQLitePlatformWinRT(), path);  
         conn.CreateTable<Customer>(); 
      }
		
      private void Retrieve_Click(object sender, RoutedEventArgs e) { 
         var query = conn.Table<Customer>(); 
         string id = ""; 
         string name = ""; 
         string age = "";  
			
         foreach (var message in query) {
            id = id + " " + message.Id; 
            name = name + " " + message.Name; 
            age = age + " " + message.Age; 
         }
			
         textBlock2.Text = "ID: " + id + "\nName: " + name + "\nAge: " + age; 
      }  
		
      private void Add_Click(object sender, RoutedEventArgs e){ 
       
         var s = conn.Insert(new Customer(){
            Name = textBox.Text, 
            Age = textBox1.Text 
         }); 
			
      } 
   } 
	
   public class Customer {
      [PrimaryKey, AutoIncrement] 
      public int Id { get; set; } 
      public string Name { get; set; } 
      public string Age { get; set; } 
   } 
	
}

Wenn der obige Code kompiliert und ausgeführt wird, wird das folgende Fenster angezeigt.

Geben Sie die Name und Age und klicken Sie auf Add Taste.

Klicken Sie nun auf die RetrieveTaste. Sie sehen die folgenden Daten auf derText Block.

Das ID-Feld ist ein Primärschlüssel- und ein automatisches Inkrementfeld, das in der Kundenklasse angegeben ist.

[PrimaryKey, AutoIncrement] 
public int Id { get; set; }

App-zu-App-Kommunikation bedeutet, dass Ihre Anwendung mit einer anderen Anwendung sprechen oder mit dieser kommunizieren kann, die auf demselben Gerät installiert ist. Dies ist keine neue Funktion in der UWP-Anwendung (Universal Windows Platform) und war auch in Windows 8.1 verfügbar.

In Windows 10 werden einige neue und verbesserte Methoden eingeführt, um die Kommunikation zwischen Anwendungen auf demselben Gerät zu vereinfachen. Die Kommunikation zwischen zwei Apps kann auf folgende Arten erfolgen:

  • Eine Anwendung startet eine andere App mit einigen Daten.
  • Apps tauschen einfach Daten aus, ohne etwas zu starten.

Der Hauptvorteil der App-zu-App-Kommunikation besteht darin, dass Sie Anwendungen in kleinere Teile aufteilen können, die einfach gewartet, aktualisiert und verwendet werden können.

Bereiten Sie Ihre App vor

Wenn Sie die folgenden Schritte ausführen, können andere Anwendungen Ihre Anwendung starten.

  • Fügen Sie eine Protokolldeklaration im Anwendungspaketmanifest hinzu.

  • Doppelklicken Sie auf die Package.appxmanifest Datei, die im Projektmappen-Explorer wie unten gezeigt verfügbar ist.

  • Gehe zum Declaration Klicken Sie auf die Registerkarte und schreiben Sie den Namen des Protokolls wie unten gezeigt.

  • Der nächste Schritt ist das Hinzufügen der activation Code, damit die App beim Starten durch die andere Anwendung angemessen reagieren kann.

  • Um auf Protokollaktivierungen zu reagieren, müssen wir das überschreiben OnActivatedMethode der Aktivierungsklasse. Fügen Sie also den folgenden Code hinzuApp.xaml.cs Datei.

protected override void OnActivated(IActivatedEventArgs args) {
 
   ProtocolActivatedEventArgs protocolArgs = args as ProtocolActivatedEventArgs;
	
   if (args != null){ 

      Frame rootFrame = Window.Current.Content as Frame;
	  
      // Do not repeat app initialization when the Window already has content, 
      // just ensure that the window is active
	  
      if (rootFrame == null){ 
		 
         // Create a Frame to act as the navigation context and navigate to the first page
         rootFrame = new Frame(); 
		 
         // Set the default language 
         rootFrame.Language = Windows.Globalization.ApplicationLanguages.Languages[0];  
         rootFrame.NavigationFailed += OnNavigationFailed;
		 
         // Place the frame in the current Window 
         Window.Current.Content = rootFrame; 
      } 
		
      if (rootFrame.Content == null){
	  
         // When the navigation stack isn't restored, navigate to the  
         // first page, configuring the new page by passing required  
         // information as a navigation parameter 
		 
         rootFrame.Navigate(typeof(MainPage), null); 
      } 
		
      // Ensure the current window is active 
      Window.Current.Activate(); 
		
   } 
}
  • Um die Anwendung zu starten, können Sie einfach die verwenden Launcher.LaunchUriAsync Methode, mit der die Anwendung mit dem in dieser Methode angegebenen Protokoll gestartet wird.

await Windows.System.Launcher.LaunchUriAsync(new Uri("win10demo:?SomeData=123"));

Lassen Sie uns dies anhand eines einfachen Beispiels verstehen, in dem wir zwei UWP-Anwendungen mit haben ProtocolHandlerDemo und FirstProtocolHandler.

In diesem Beispiel ist die ProtocolHandlerDemo Anwendung enthält eine Schaltfläche und durch Klicken auf die Schaltfläche wird die geöffnet FirstProtocolHandler Anwendung.

Der XAML-Code in der ProtocolHandlerDemo-Anwendung, die eine Schaltfläche enthält, ist unten angegeben.

<Page 
   x:Class = "ProtocolHandlerDemo.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:ProtocolHandlerDemo" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">  
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <Button x:Name = "LaunchButton" Content = " Launch First Protocol App"
         FontSize = "24" HorizontalAlignment = "Center" 
         Click = "LaunchButton_Click"/> 
   </Grid> 
	
</Page>

Unten ist der C # -Code angegeben, in dem das Schaltflächenklickereignis implementiert ist.

using System; 
using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls;  

// The Blank Page item template is documented at 
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409  

namespace ProtocolHandlerDemo {

   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
   
   public sealed partial class MainPage : Page {
   
      public MainPage(){ 
         this.InitializeComponent(); 
      }
		
      private async void LaunchButton_Click(object sender, RoutedEventArgs e) {
         await Windows.System.Launcher.LaunchUriAsync(new 
            Uri("win10demo:?SomeData=123")); 
      }
		
   }
}

Lassen Sie uns nun einen Blick in die FirstProtocolHandlerAnwendungstabelle. Im Folgenden ist der XAML-Code angegeben, in dem ein Textblock mit einigen Eigenschaften erstellt wird.

<Page 
   x:Class = "FirstProtocolHandler.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:FirstProtocolHandler" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">  
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <TextBlock Text = "You have successfully launch First Protocol Application" 
         TextWrapping = "Wrap" Style = "{StaticResource SubtitleTextBlockStyle}"  
         Margin = "30,39,0,0" VerticalAlignment = "Top" HorizontalAlignment = "Left" 
         Height = "100" Width = "325"/> 
   </Grid> 
	
</Page>

Die C # -Implementierung des App.xaml.cs Datei in der OnActicatedDiese Überschreibung wird unten gezeigt. Fügen Sie den folgenden Code in die App-Klasse einApp.xaml.cs Datei.

protected override void OnActivated(IActivatedEventArgs args) { 
   ProtocolActivatedEventArgs protocolArgs = args as ProtocolActivatedEventArgs;
	
   if (args != null) {
      Frame rootFrame = Window.Current.Content as Frame;  
		
      // Do not repeat app initialization when the Window already has content, 
      // just ensure that the window is active 
		
      if (rootFrame == null) {

         // Create a Frame to act as the navigation context and navigate to 
            the first page 
         rootFrame = new Frame(); 
		 
         // Set the default language 
         rootFrame.Language = Windows.Globalization.ApplicationLanguages.Languages[0];  
         rootFrame.NavigationFailed += OnNavigationFailed; 
		 
         // Place the frame in the current Window 
         Window.Current.Content = rootFrame; 
      }  
		
      if (rootFrame.Content == null) {
		
         // When the navigation stack isn't restored navigate to the 
         // first page, configuring the new page by passing required 
         // information as a navigation parameter 
		 
         rootFrame.Navigate(typeof(MainPage), null); 
      }
		
      // Ensure the current window is active 
      Window.Current.Activate(); 
   } 
}

Wenn Sie das kompilieren und ausführen ProtocolHandlerDemo Anwendung auf einem Emulator, sehen Sie das folgende Fenster.

Wenn Sie nun auf die Schaltfläche klicken, wird die geöffnet FirstProtocolHandler Anwendung wie unten gezeigt.

Windows wird weltweit, in verschiedenen Märkten und für Zielgruppen eingesetzt, die sich in Kultur, Region oder Sprache unterscheiden. Lokalisierung ist die Übersetzung von Anwendungsressourcen in lokalisierte Versionen für die spezifischen Kulturen, die die Anwendung unterstützt.

Wenn Sie eine Anwendung in nur einer Sprache entwickeln, bedeutet dies, dass Sie nur Ihr Unternehmen und Ihre Kunden einschränken. Wenn Sie Ihren Kundenstamm vergrößern möchten, was auch Ihr Geschäft steigert, muss Ihre Anwendung weltweit verfügbar und erreichbar sein. Die kostengünstige Lokalisierung Ihres Produkts ist eine der besten und wirtschaftlichsten Möglichkeiten, um mehr Kunden zu erreichen.

In Windows 10 lassen sich lokalisierbare Anwendungen sehr einfach erstellen resx Datei, die einfachste Lösung für die Lokalisierung.

Lassen Sie uns dies anhand eines einfachen Beispiels verstehen, indem Sie alle unten aufgeführten Schritte ausführen.

UI-Ressourcen übersetzen

Sie können Zeichenfolgenressourcen für Ihre Benutzeroberfläche in die Ressource einfügen (resw) Dateien, anstatt sie direkt in Code oder Markup einzufügen, und dann können Sie diese Zeichenfolgen aus Ihrem Code oder Markup referenzieren. Führen Sie die folgenden Schritte aus, um den Ressourcendateien Zeichenfolgen hinzuzufügen.

  • Erstellen Sie eine neue UWP-Anwendung (Universal Windows Platform).

  • In dem Solution ExplorerKlicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie Add > New Folder.

  • Ändern Sie den Namen des neuen Ordners in "Strings".

  • Klicken Sie mit der rechten Maustaste auf Strings Ordner und fügen Sie einen neuen Ordner mit dem Namen "en-US". Hierbei handelt es sich um Namenskonventionen, die für eine Sprache und einen Namen für ein Land / eine Region spezifisch sind. Sie finden sie auf der Seite msdn.microsoft.com der National Language Support (NLS) API-Referenz .

  • Klicken Sie mit der rechten Maustaste auf en-US Ordner und wählen Sie Add > New Item….

  • Der folgende Dialog wird geöffnet.
  • Wählen "Resources File (.resw)" und Klicken Sie auf Add Taste.

  • Gehen wir nun zur XAML-Datei und fügen ein Hub-Steuerelement mit einigen Eigenschaften hinzu, wie unten gezeigt.

<Page 
   x:Class = "UWPLocalizationDemo.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPLocalizationDemo" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d"> 
	
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <Hub x:Name = "textBlock" x:Uid = "HubControl" Background = "Black" 
         Foreground = "White" Header = "Localization Demo"/>
   </Grid> 
	
</Page>
  • x:Uid = "HubControl" sind die Bezeichner, die für die Lokalisierung verwendet werden

  • Wenn der obige Code kompiliert und ausgeführt wird, wird das folgende Fenster angezeigt.

Alle auf den Hub bezogenen Informationen wie Header, Vordergrund und Hintergrundfarbe werden in der XAML festgelegt.

  • Fügen Sie nun einige Informationen hinzu Resource.resw Datei in der Strings/en-US Ordner wie unten gezeigt.

  • Sie müssen jedes Steuerelement, das lokalisierten Text benötigt, mit dem Steuerelement verknüpfen.reswDatei. Sie können dies tun, indem Sie diex:Uid Attribut auf Ihren XAML-Elementen wie folgt -

    • x:Uid = "HubControl" wird in verwendet resw Datei, um eine Zeichenfolge für die Kopf-, Vordergrund- und Hintergrundfarbe zuzuweisen.

  • Wenn Sie nun Ihre Anwendung auf einem Emulator kompilieren und ausführen, wird das folgende Fenster angezeigt. Sie können sehen, dass die Werte für Kopf-, Vordergrund- und Hintergrundfarbe aus dem ausgewählt werdenResources.resw Datei.

  • Sie können andere hinzufügen Resource.resw Dateien für andere Sprachen wie Französisch, Deutsch und Japanisch usw. manuell, wie wir es für Englisch-USA getan haben, aber Microsoft bietet auch eine Multilingual App Toolkit mit deren Hilfe können Sie Ihre leicht übersetzen Resource.resw in andere Sprachen.

  • Gehe zum Tools > Extensions und Menü aktualisieren und suchen Sie die Multilingual app Toolkit.

  • Laden Sie dieses Toolkit herunter und installieren Sie es. Starten Sie nach Abschluss der Installation Visual Studio neu und öffnen Sie dasselbe Projekt.

  • Aktivieren Sie nun dieses Toolkit aus dem Tools > Multilingual App Toolkit-Menüoption.

  • Jetzt können Sie Übersetzungen für andere Sprachen hinzufügen.

  • Klicken Sie mit der rechten Maustaste auf das Projekt in der Solution Explorer und auswählen Multilingual App Toolkit > Add Translation Sprachoption aus dem Menü.

  • Folgende Translation LanguagesDer Dialog wird geöffnet. Sie können eine beliebige Sprache auswählen, um Ihre Anwendung für diese Kulturen zu lokalisieren.

  • Lassen Sie uns auswählen German Sprache und klicken Sie auf die OK Taste.

  • Sie können auch sehen, dass die Resources.resw Die Datei wird im Ordner erstellt Strings\de.

  • Jetzt wirst du das andere sehen MultiLingualResources wird in der hinzugefügt *.xlfDatei. Doppelklicken Sie auf diese Datei, um die zu öffnenMultilingual Editor, um die übersetzten Zeichenfolgen zu überprüfen und zu verifizieren und bei Bedarf einige Änderungen vorzunehmen.

  • Nehmen Sie die Änderungen vor und überprüfen Sie, ob sich die Hintergrundfarbe in Braun geändert hat und der Kopfzeilentext ordnungsgemäß ins Deutsche übersetzt wurde.

  • Wie im obigen Beispiel hat sich die Hintergrundfarbe von Hub von blauer zu brauner Farbe geändert, und die Vordergrundfarbe ist gleich geblieben.

  • Öffnen Sie nun die Resources.resw, das ist in der Strings\de Mappe.

  • Sie können sehen, dass hier nur zwei Zeichenfolgen erwähnt werden, da wir die Vordergrundfarbe im mehrsprachigen Editor nicht geändert haben.

Ändern Sie die Kultur Ihres Computers, um die lokalisierte Version Ihrer Anwendung zu überprüfen. Befolgen Sie die angegebenen Schritte, um die Kultur Ihrer Maschine zu ändern.

  • Gehen wir zu den PC-Einstellungen und wählen Zeit und Sprache.
  • Wählen Sie im linken Bereich die Option aus Regions & language und klicken Sie auf die Add a language.

  • Wählen Deutsch German Sprache wie oben gezeigt, wodurch ein weiterer Dialog geöffnet wird.

  • Wählen Sie nun die German (Germany) und schließen Sie dieses Dialogfeld.

  • Machen Sie Deutsch als Standardsprache.
  • Führen Sie nun Ihre Anwendung aus, es wird das folgende Fenster angezeigt.
  • Jetzt können Sie die Ausgabe Ihrer Bewerbung in deutscher Sprache sehen.

In der Vergangenheit hatte Windows eine Umgebung, in der Benutzer mehrere Anwendungen gleichzeitig ausführen können. Der Benutzer kann problemlos zwischen verschiedenen Anwendungen wechseln. Dieses Modell eignet sich nicht für Telefon- oder Tablet-Geräte, bei denen die Verwendung in der Regel auf einzelne Anwendungen ausgerichtet ist.

Eine der größten Herausforderungen für Windows 8 Store-Anwendungsprogrammierer besteht darin, den Anwendungslebenszyklus zu verwalten und zu verstehen. Wenn Sie Windows Phone-Anwendungen erstellt haben, ist vieles davon bekannt.

  • Unter Windows 8 verwaltet das Betriebssystem die Lebensdauer einer Anwendung. Während der Benutzer eine Anwendung beenden kann, öffnet der Benutzer normalerweise neue Anwendungen, ohne die laufenden Anwendungen bewusst zu beenden.

  • Die Universal Windows Platform (UWP) für Windows 10 behebt diese Probleme und bietet den Desktop-Benutzern einige coole Dinge, damit mehrere Anwendungen mit mehreren Fenstern ausgeführt werden können.

Windows-Anwendungen können auf der Basisebene in drei Zuständen vorhanden sein (siehe unten).

  • Running

  • Suspended

  • Terminate

  • Wenn ein Benutzer eine Anwendung startet / aktiviert, geht sie in die running Zustand.

  • Anwendungen können angehalten werden, wenn ein Benutzer sie nicht verwendet und sie nicht mehr im Vordergrund stehen.

  • Im angehaltenen Zustand können Anwendungen diese Anwendung entweder fortsetzen oder das Betriebssystem beenden, um Systemressourcen zurückzugewinnen.

Prozesszustandsübergang

Es ist wichtig, die Prozesszustandsübergänge in einer laufenden Anwendung zu verstehen. Wenn der Benutzer die Anwendung zum ersten Mal startet, wird der Begrüßungsbildschirm angezeigt und die Anwendung wird ausgeführt.

Der Prozess kann wie folgt erklärt werden:

  • Wenn die Anwendung angehalten wird, erhält Ihre App fünf Sekunden Zeit, um dieses angehaltene Ereignis zu verarbeiten.

  • Wenn die Anwendung angehalten wird, wird absolut kein Code ausgeführt und es werden keine Ressourcen zugewiesen.

  • Wenn es fortgesetzt wird, wird die App benachrichtigt, dass es fortgesetzt wird. Wenn Sie aus einem suspendierten Zustand kommen, müssen Sie keine Maßnahmen ergreifen.

  • Unter Speicherdruck kann Ihre Anwendung möglicherweise beendet werden.

  • Denken Sie daran, dass Sie zu diesem Zeitpunkt nicht benachrichtigt werden. Wenn Sie also in den Status der angehaltenen Anwendung wechseln, müssen Sie alle Einsparungen vornehmen.

Wenn die Anwendung zwischen hin und her wechselt Running und Suspended Zustände, feuersperrende bzw. wiederaufnehmende Ereignisse.

Manchmal müssen Sie Daten speichern. Dann müssen Sie asynchrone Methoden wie unten gezeigt aufrufen.

Application.Current.Suspending += new SuspendingEventHandler(App_Suspending); 

async void App_Suspending(Object sender, Windows.ApplicationModel.SuspendingEventArgs e){ 
   // Create a simple setting  
   localSettings.Values["FirstName"] = fName.Text; 
   localSettings.Values["LastName"] = lName.Text; 
   localSettings.Values["Email"] = email.Text; 
}

Application.Current.Resuming += new EventHandler<Object>(App_Resuming); 

private void App_Resuming(Object sender, Object e){ 
   fName.Text = localSettings.Values["FirstName"]; 
   lName.Text = localSettings.Values["LastName"]; 
   email.Text = localSettings.Values["Email"]; 
}

Lassen Sie uns ein Beispiel untersuchen, in dem Steuerelemente hinzugefügt werden, wie in der unten angegebenen XAML-Datei gezeigt.

<Page 
   x:Class = "UWPLifeCycleDemo.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPLifeCycleDemo" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d"> 
    
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}">
      <Hub Header = "Details" />
		
      <StackPanel VerticalAlignment = "Top" HorizontalAlignment = "Left" 
         Margin = "12,64,0,0">
			
         <TextBox Header = "First Name" Text = "{Binding FirstName, 
            Mode = TwoWay, UpdateSourceTrigger = PropertyChanged}" 
            Width = "200" />
				
         <TextBox Header = "Last Name" Text = "{Binding LastName, Mode = TwoWay, 
            UpdateSourceTrigger = PropertyChanged}" Width = "200" />
				
         <TextBox Header = "Email" Text = "{Binding Email, Mode = TwoWay, 
            UpdateSourceTrigger = PropertyChanged}" Width = "200" />
				
         <Button Margin = "0,12">Submit</Button>
			
      </StackPanel>
		
   </Grid>
	
</Page>

Im Folgenden ist der C # -Code angegeben, in dem die Ereignisse Suspend und Resume implementiert sind. Die aktuellen Daten werden im gespeichertsuspend event in lokalen Einstellungen und dann werden die Daten in der abgerufen resume event aus den lokalen Einstellungen wie unten gezeigt.

using System; 
using System.ComponentModel; 
using System.Runtime.CompilerServices; 

using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
 
namespace UWPLifeCycleDemo {

   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class MainPage : Page{
      var localSettings = Windows.Storage.ApplicationData.Current.LocalSettings; 
		
      public MainPage() {
         this.InitializeComponent(); 
         Application.Current.Suspending += new SuspendingEventHandler(App_Suspending); 
         Application.Current.Resuming += new EventHandler<Object>(App_Resuming); 
      } 
		
      async void App_Suspending(Object sender, Windows.ApplicationModel.SuspendingEventArgs e){
         
         // Create a simple setting 
         localSettings.Values["FirstName"] = fName.Text; 
         localSettings.Values["LastName"] = lName.Text; 
         localSettings.Values["Email"] = email.Text; 
      } 
		
      private void App_Resuming(Object sender, Object e){
         fName.Text = localSettings.Values["FirstName"]; 
         lName.Text = localSettings.Values["LastName"]; 
         email.Text = localSettings.Values["Email"]; 
      }
		
   } 
	
   public abstract class BindableBase : INotifyPropertyChanged {
      private string _FirstName = default(string);
		
      public string FirstName { 
         get { return _FirstName; } 
         set { Set(ref _FirstName, value); } 
      } 
		
      private string _LastName = default(string);
		
      public string LastName { 
         get { return _LastName; } 
         set { Set(ref _LastName, value); } 
      } 
		
      private string _Email = default(string);
		
      public string Email { 
         get { return _Email; } 
         set { Set(ref _Email, value); } 
      } 
		
      public event PropertyChangedEventHandler PropertyChanged;
		
      public void RaisePropertyChanged([CallerMemberName]string propertyName = null) {
         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); 
      } 
		
      public void Set<T>(ref T storage, T value, 
         [CallerMemberName()]string propertyName = null){ 

         if (!object.Equals(storage, value)){
            storage = value; 
            RaisePropertyChanged(propertyName); 
         } 
      } 
   } 
}

Wenn der obige Code kompiliert und ausgeführt wird, wird das folgende Fenster angezeigt. Schreiben Sie nun die gewünschten Informationen.

Lass uns zum gehen Lifecycle Dropdown-Menü Ereignisse und auswählen suspended. Jetzt wird Ihre Anwendung ausgesetzt und die gewünschten Informationen werden in den lokalen Einstellungen gespeichert. Siehe den Screenshot unten.

Wenn Sie nun Ihre Bewerbung fortsetzen möchten, wählen Sie die Option Resume von dem Lifecycle Events Speisekarte.

Jetzt sehen Sie, dass die gespeicherten Informationen aus den lokalen Einstellungen abgerufen werden und die Anwendung in demselben Zustand fortgesetzt wird, in dem sie angehalten wurde.

Die Universal Windows Platform (UWP) führt neue Mechanismen ein, mit denen die Anwendungen einige Funktionen ausführen können, während die Anwendung nicht im Vordergrund ausgeführt wird. UWP erhöht auch die Fähigkeit der Anwendungen, ihre Ausführungszeit im Hintergrund für zu verlängernBackground Tasks and Triggers. Die Hintergrundausführung ist die eigentliche Ergänzung zum Anwendungslebenszyklus.

Wichtige Merkmale von Hintergrundaufgaben sind -

  • Eine Hintergrundaufgabe wird durch ein System- oder Zeitereignis ausgelöst und kann durch eine oder mehrere Bedingungen eingeschränkt werden.

  • Wenn eine Hintergrundaufgabe ausgelöst wird, wird der zugehörige Handler ausgeführt und führt die Arbeit der Hintergrundaufgabe aus.

  • Eine Hintergrundaufgabe kann auch dann ausgeführt werden, wenn die App, die die Hintergrundaufgabe registriert hat, angehalten ist.

  • Sie sind Teil der Standardanwendungsplattform und bieten einer App im Wesentlichen die Möglichkeit, sich für ein Systemereignis (Trigger) zu registrieren. Wenn dieses Ereignis eintritt, führen sie im Hintergrund einen vordefinierten Codeblock aus. Systemauslöser umfassen Ereignisse wie Änderungen der Netzwerkkonnektivität oder der Systemzeitzone.

  • Die Hintergrundausführung kann nicht garantiert werden und ist daher nicht für kritische Funktionen und Merkmale geeignet.

  • Das Betriebssystem hat eine Einschränkung hinsichtlich der Anzahl der Hintergrundaufgaben, die gleichzeitig ausgeführt werden können. Selbst wenn der Auslöser ausgelöst wird und die Bedingungen erfüllt sind, kann die Aufgabe immer noch nicht ausgeführt werden.

Hintergrundaufgabe erstellen und registrieren

Erstellen Sie eine Hintergrundaufgabenklasse und registrieren Sie sie für die Ausführung, wenn Ihre App nicht im Vordergrund steht. Sie können Code im Hintergrund ausführen, indem Sie Klassen schreiben, die das implementierenIBackgroundTaskSchnittstelle. Der folgende Beispielcode zeigt einen sehr grundlegenden Ausgangspunkt für eine Hintergrundaufgabenklasse.

public sealed class MyBackgroundTask : IBackgroundTask { 
   public void Run(IBackgroundTaskInstance taskInstance){ 
      // write code 
   } 
}

Sie können den Zugriff für die Hintergrundaufgabe wie folgt anfordern.

var access = await BackgroundExecutionManager.RequestAccessAsync();
 
switch (access) {
 
   case BackgroundAccessStatus.Unspecified: 
      break; 
   case BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity: 
      break; 
   case BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity: 
      break; 
   case BackgroundAccessStatus.Denied: 
      break; 
   default: 
      break; 
}

Verwenden Sie den folgenden Code, um die Hintergrundaufgabe zu erstellen und zu registrieren.

var task = new BackgroundTaskBuilder {
   Name = "My Task", 
   TaskEntryPoint = typeof(BackgroundStuff.MyBackgroundTask).ToString() 
}; 

var trigger = new ApplicationTrigger(); 
task.SetTrigger(trigger);  
task.Register(); 
 
await trigger.RequestAsync();

Lassen Sie uns ein einfaches Beispiel für eine Hintergrundaufgabe verstehen, indem Sie alle unten angegebenen Schritte ausführen.

  • Erstellen Sie ein neues leeres UWP-Projekt ‘UWPBackgroundDemo’ und fügen Sie eine Schaltfläche in die XAML-Datei ein.

<Page 
   x:Class = "UWPBackgroundDemo.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPBackgroundDemo" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d"> 
	
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}">
      <Button x:Name = "button" Content = "Button" 
         HorizontalAlignment = "Left" Margin = "159,288,0,0" 
         VerticalAlignment = "Top" Click = "button_Click"/> 
   </Grid>
	
</Page>
  • Unten ist die angegeben button click Ereignisimplementierung, in der die Hintergrundaufgabe registriert ist.

using System; 

using Windows.ApplicationModel.Background; 
using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
 
// The Blank Page item template is documented at 
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409  

namespace UWPBackgroundDemo {
 
   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary>
	
   public sealed partial class MainPage : Page {

      public MainPage() {
         this.InitializeComponent(); 
      }  
		
      private async void button_Click(object sender, RoutedEventArgs e) {
         var access = await BackgroundExecutionManager.RequestAccessAsync(); 
		 
         switch (access){ 
            case BackgroundAccessStatus.Unspecified: 
               break; 
            case BackgroundAccessStatus.AllowedMayUseActiveRealTimeConnectivity: 
               break; 
            case BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity: 
               break; 
            case BackgroundAccessStatus.Denied: 
               break; 
            default: 
               break; 
         } 
			
         var task = new BackgroundTaskBuilder {  
            Name = "My Task", 
            TaskEntryPoint = typeof(BackgroundStuff.MyBackgroundTask).ToString() 
         }; 
			
         var trigger = new ApplicationTrigger(); 
         task.SetTrigger(trigger);  
			
         var condition = new SystemCondition(SystemConditionType.InternetAvailable);  
         task.Register(); 
			
         await trigger.RequestAsync(); 
      } 
   } 
}
  • Erstellen Sie nun ein anderes Projekt, wählen Sie diesmal jedoch Windows Runtime Component (Universal Windows) aus dem Menü und geben Sie den Namen an Background stuff zu diesem Projekt.

  • Unten ist der C # -Code angegeben. was beinhaltetMyBackgroundTask Klassenimplantation und es wird die Hintergrundaufgabe ausgeführt.

using Windows.ApplicationModel.Background; 
using Windows.UI.Notifications; 
 
namespace BackgroundStuff { 
   public sealed class MyBackgroundTask : IBackgroundTask { 
	
      public void Run(IBackgroundTaskInstance taskInstance) {
         SendToast("Hi this is background Task"); 
      } 
		
      public static void SendToast(string message) { 
         var template = ToastTemplateType.ToastText01; 
         var xml = ToastNotificationManager.GetTemplateContent(template); 
         var elements = xml.GetElementsByTagName("Test"); 
         var text = xml.CreateTextNode(message); 
			
         elements[0].AppendChild(text); 
         var toast = new ToastNotification(xml); 
         ToastNotificationManager.CreateToastNotifier().Show(toast); 
      } 
   } 
}
  • Um dieses Projekt in der zugänglich zu machen UWPBackgroundDemo Projekt, Rechtsklick auf References > Add References im Projektmappen-Explorer und fügen Sie hinzu BackgroundStuff Projekt.

  • Nun gehen wir zum Package.appxmanifest Datei von UWPBackgroundDemo Projizieren Sie und fügen Sie die folgenden Informationen auf der Registerkarte Deklarationen hinzu.

  • Erstellen Sie zuerst das Hintergrundprojekt, dann erstellen Sie das und führen Sie es aus UWPBackgroundDemo Projekt.

  • Wenn der obige Code kompiliert und ausgeführt wird, wird das folgende Fenster angezeigt.

  • Wenn Sie auf die klicken buttonwird die Hintergrundaufgabe ausgeführt und am rechten Ende Ihres Fensters eine Benachrichtigung angezeigt.

In diesem Kapitel erfahren Sie, wie UWP-Apps anderen UWP-Anwendungen (Universal Windows Platform) helfen oder Dienste für sie bereitstellen können. Eigentlich ist dieses Kapitel eine Erweiterung des KapitelsBackground execution und ist ein Sonderfall davon.

  • In Windows 10 ist ein App-Dienst eine Möglichkeit oder ein Mechanismus für eine App, um Dienste für andere Apps bereitzustellen.

  • Ein App-Service arbeitet in Form einer Hintergrundaufgabe.

  • Vordergrund-Apps können einen App-Dienst in einer anderen App aufrufen, um Aufgaben im Hintergrund auszuführen.

App-Dienste sind wie Webdienste, aber App-Dienste werden auf Windows 10-Geräten verwendet.

UWP-Anwendungen (Universal Windows Platform) können auf verschiedene Weise mit einer anderen UWP-Anwendung interagieren.

  • URI-Zuordnung mit LaunchUriAsync
  • Dateizuordnung mit LaunchFileAsync
  • Starten Sie die Ergebnisse mit LaunchUriForResultsAsync
  • App-Dienste

Die ersten drei Möglichkeiten werden verwendet, wenn beide Anwendungen im Vordergrund stehen, die App-Dienste jedoch in verwendet werden background task In diesem Fall muss die Clientanwendung im Vordergrund stehen und verfügbar sein, um den App-Dienst nutzen zu können.

App-Dienste sind sehr nützlich in Anwendungen, in denen nicht visuelle Dienste bereitgestellt werden, z. B. ein Barcode-Scanner, in dem eine Vordergrund-App das Bild aufnimmt und diese Bytes an die App-Dienste sendet, um den Barcode zu identifizieren.

Um all diese Konzepte zu verstehen, erstellen wir ein neues UWP-Projekt mit dem Namen AppServiceProvider in Microsoft Visual Studio 2015.

Jetzt in der Package.appmenifest Datei, fügen Sie die folgenden Informationen hinzu.

Fügen Sie einen neuen hinzu, um einen App-Service zu erstellen, der von Vordergrundanwendungen aufgerufen werden kann Windows Runtime Komponentenprojekt zur Lösung mit MyAppService Name, weil App-Services als Hintergrundaufgabe implementiert sind.

Fügen Sie einen Verweis auf die hinzu MyAppService Projekt in der AppServiceProvider Projekt.

Löschen Sie nun die class1.cs Datei von MyAppService projizieren und fügen Sie eine neue Klasse mit dem Inventarnamen hinzu, die das implementiert IBackgrounTask Schnittstelle.

Das IBackgrounTask Schnittstelle hat nur eine Methode “Run” die für Hintergrundaufgabe implementiert werden muss.

public sealed class Inventory : IBackgroundTask { 
   public void Run(IBackgroundTaskInstance taskInstance) { 
      
   } 
}

Wenn die Hintergrundaufgabe erstellt wird, Run() methodwird aufgerufen und wenn die Run-Methode abgeschlossen ist, werden Hintergrundaufgaben beendet. Um einer Hintergrundaufgabe gerecht zu werden und Anforderungen zu bearbeiten, wird der Code verschoben.

Der App Services Code ist in OnRequestedReceived(). In diesem Beispiel wird ein Index für einen Inventargegenstand an den Service übergeben, um den Namen und den Preis des angegebenen Inventargegenstands abzurufen.

private async void OnRequestReceived(AppServiceConnection sender, 
   AppServiceRequestReceivedEventArgs args) {
      // Get a deferral because we use an awaitable API below to respond to the message 
}

Im Folgenden wird die vollständige Implementierung der Inventarklasse in C # angegeben.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 

using Windows.ApplicationModel.AppService; 
using Windows.ApplicationModel.Background; 
using Windows.Foundation.Collections;  

namespace MyAppService{
   public sealed class Inventory : IBackgroundTask { 
	
      private BackgroundTaskDeferral backgroundTaskDeferral; 
      private AppServiceConnection appServiceconnection; 
		
      private String[] inventoryItems = new string[] { "Robot vacuum", "Chair" }; 
      private double[] inventoryPrices = new double[] { 129.99, 88.99 };
		
      public void Run(IBackgroundTaskInstance taskInstance) {
         this.backgroundTaskDeferral = taskInstance.GetDeferral(); 
         taskInstance.Canceled += OnTaskCanceled;  
         var details = taskInstance.TriggerDetails as AppServiceTriggerDetails;
			
         appServiceconnection = details.AppServiceConnection;
         appServiceconnection.RequestReceived += OnRequestReceived; 
      } 
		
      private async void OnRequestReceived(AppServiceConnection sender,
         AppServiceRequestReceivedEventArgs args) {
        
            var messageDeferral = args.GetDeferral(); 
            ValueSet message = args.Request.Message; 
            ValueSet returnData = new ValueSet();  
				
            string command = message["Command"] as string; 
            int? inventoryIndex = message["ID"] as int?;  
            if (inventoryIndex.HasValue && 
				
            inventoryIndex.Value >= 0 && 
            inventoryIndex.Value < inventoryItems.GetLength(0)) {
		 
               switch (command) {
			
                  case "Price": {
                     returnData.Add("Result", inventoryPrices[inventoryIndex.Value]); 
                     returnData.Add("Status", "OK"); 
                     break; 
                  } 
					
                  case "Item": {
                     returnData.Add("Result", inventoryItems[inventoryIndex.Value]); 
                     returnData.Add("Status", "OK"); 
                     break; 
                  }  
					
                  default: {
                     returnData.Add("Status", "Fail: unknown command"); 
                     break; 
                  }
               } else {
                  returnData.Add("Status", "Fail: Index out of range"); 
               } 
            }			
            await args.Request.SendResponseAsync(returnData); 
            messageDeferral.Complete(); 
      } 
		
      private void OnTaskCanceled(IBackgroundTaskInstance sender,
         BackgroundTaskCancellationReason reason){ 
            if (this.backgroundTaskDeferral != null) {
               // Complete the service deferral. 
               this.backgroundTaskDeferral.Complete(); 
            } 
      } 
   } 
}

Lassen Sie uns eine Client-App erstellen, indem Sie ein neues leeres UWP-Projekt hinzufügen ClientApp und fügen Sie eine Schaltfläche, ein Textfeld und zwei Textblöcke hinzu, wie unten in der XAML-Datei gezeigt.

<Page 
   x:Class = "ClientApp.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:ClientApp" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d"> 
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <TextBlock HorizontalAlignment = "Left" Text = "Enter Item No." 
         Margin = "52,40,0,0" TextWrapping = "Wrap"
         VerticalAlignment = "Top" Height = "32" Width = "268"/> 
			
      <Button x:Name = "button" Content = "Get Info" HorizontalAlignment = "Left"  
         Margin = "255,96,0,0" VerticalAlignment = "Top" Click = "button_Click"/>
			
      <TextBox x:Name = "textBox" HorizontalAlignment = "Left" Margin = "52,96,0,0"  
         TextWrapping = "Wrap" VerticalAlignment = "Top" Width = "168"/>
			
      <TextBlock x:Name = "textBlock" HorizontalAlignment = "Left"  
         Margin = "52,190,0,0" TextWrapping = "Wrap"  
         VerticalAlignment = "Top" Height = "32" Width = "268"/> 
   </Grid> 
	
</Page>

Im Folgenden wird die Implementierung des Button-Click-Ereignisses angegeben, bei der App-Services angefordert werden.

using System; 

using Windows.ApplicationModel.AppService; 
using Windows.Foundation.Collections;
 
using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls;
  
// The Blank Page item template is documented at 
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409  

namespace ClientApp {

   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class MainPage : Page {
   
      private AppServiceConnection inventoryService; 
	  
      public MainPage() {
         this.InitializeComponent(); 
      } 
		
      private async void button_Click(object sender, RoutedEventArgs e){
	  
         // Add the connection. 
         if (this.inventoryService == null) {
		 
            this.inventoryService = new AppServiceConnection(); 
            this.inventoryService.AppServiceName = "com.microsoft.inventory"; 
            this.inventoryService.PackageFamilyName = 
               "bb1a8478-8005-46869923-e525ceaa26fc_4sz2ag3dcq60a"; 
					
            var status = await this.inventoryService.OpenAsync();
				
            if (status != AppServiceConnectionStatus.Success) {
               button.Content = "Failed to connect"; 
               return; 
            } 
         } 
			
         // Call the service. 
         int idx = int.Parse(textBox.Text); 
         var message = new ValueSet(); 
			
         message.Add("Command", "Item"); 
         message.Add("ID", idx); 
			
         AppServiceResponse response = await 
            this.inventoryService.SendMessageAsync(message); 
         string result = ""; 
			
         if (response.Status == AppServiceResponseStatus.Success) { 
            // Get the data  that the service sent  to us. 
            if (response.Message["Status"] as string == "OK") {
               result = response.Message["Result"] as string; 
            } 
         } 
			
         message.Clear(); 
         message.Add("Command", "Price"); 
         message.Add("ID", idx); 
			
         response = await this.inventoryService.SendMessageAsync(message);
			
         if (response.Status == AppServiceResponseStatus.Success){
            // Get the data that the service sent to us. 
            if (response.Message["Status"] as string == "OK") {
               result += " : Price = " + "$"+ response.Message["Result"] as string; 
            } 
         }
			
         textBlock.Text = result;  
      } 
   } 
}

Um diese Anwendung auszuführen, müssen Sie die festlegen ClientApp Projekt, um das Startprojekt im Projektmappen-Explorer zu sein, und stellen Sie diese Lösung dann von bereit Build > Deploy Lösung.

Wenn der obige Code kompiliert und ausgeführt wird, wird das folgende Fenster angezeigt. In den App-Diensten haben wir gerade Informationen zu zwei Elementen hinzugefügt. Sie können also entweder 0 oder 1 eingeben, um Informationen zu diesen Elementen zu erhalten.

Wenn Sie 0 eingeben und auf die Schaltfläche klicken, wird der App-Dienst als Hintergrundaufgabe ausgeführt und die Elementinformationen auf dem angezeigt textblock.

In Windows 10 ist es für Entwickler sehr einfach, eine UWP-Anwendung (Universal Windows Platform) zu erstellen und ihre Website auf dieser Anwendung zu hosten, die dann zum Herunterladen im Windows Store veröffentlicht werden kann.

Vorteile

  • Mit dieser neuen Funktion in Windows 10 können Webentwickler problemlos Komponenten ihrer Websites in Windows-Apps konvertieren.

  • Alle diese Komponenten werden jedoch weiterhin remote auf ihren eigenen Webservern gehostet.

  • Darüber hinaus können sie auch auf universelle APIs zugreifen, mit denen die Entwickler auf einige coole Dinge wie Benachrichtigungen, Kamera, Kalender, Cortana und mehr zugreifen können.

Microsoft hofft, dass diese Funktion und Fähigkeit mehr Entwickler dazu bringen wird, Apps für die Windows 10-Plattform zu schreiben, einschließlich.

  • Desktops
  • Smartphones
  • Xbox
  • Tablets
  • HoloLens und andere Geräte

Derzeit gibt es nur ein Problem mit dieser Funktion, nämlich die Sicherheit. Microsoft muss dies natürlich so schnell wie möglich beheben.

Lassen Sie uns anhand eines Beispiels verstehen, in dem wir eine Website hosten und diese Website in eine Windows-App konvertieren.

Befolgen Sie die unten angegebenen Schritte.

  • Erstellen Sie ein neues universelles Windows-Projekt aus File > New > Project.

  • Wählen JavaScript > Windows > Universal Option aus dem linken Bereich des neuen Projekts und Dialogfelds.

  • Wählen Sie im mittleren Bereich die Option aus Blank App (Universal Windows).

  • Schreiben Sie in das Namensfeld, UWPWebApp und klicken Sie auf OK Taste.

  • Wenn Sie sich die ansehen Solution Explorer Im Fenster sehen Sie einige Dateien und Ordner.

  • Löschen Sie die css, js, WinJS Ordner und die default.htmlDatei, da wir in diesem Beispiel nur eine Website hosten und davon ausgehen, dass sich alle Inhalte auf dem Remote-Server befinden. Daher benötigen wir die meisten lokalen Dateien nicht.

  • Nachdem Sie die oben genannten Dateien und Ordner gelöscht haben, doppelklicken Sie nun auf package.appxmanifest Datei und Sie sehen das folgende Fenster.

  • Geben Sie nun die Website-URL an, indem Sie die ersetzen default.htmlim Feld Startseite durch die URL. Zu Demonstrationszwecken verwenden wir die URLhttps://www.google.com.pk/ Webseite.

  • Nun geh zum Content URIs Klicken Sie auf die Registerkarte und definieren Sie die Regel und die Zugriffsberechtigung für Ihre Web-App.

  • Geben Sie im Feld URI Ihren Website-Link an und wählen Sie dann Include von dem Rule dropdown und All von WinRT Access.

  • Wenn Sie diese Anwendung ausführen, wird die Google-Startseite Ihrer App wie unten gezeigt angezeigt.

Wie wir bereits wissen, können wir in Windows 10 eine Anwendung erstellen, die auf mehreren Windows 10-Geräten ausgeführt und ausgeführt werden kann. Nehmen wir an, wir haben diese verschiedenen Geräte und möchten, dass es sich um eine Anwendung handelt, obwohl sie auf verschiedenen Geräten ausgeführt wird.

In der Universal Windows Platform (UWP) können Sie eine einzelne Anwendung auf allen Windows 10-Geräten ausführen und dem Benutzer das Gefühl geben, dass es sich um eine Anwendung handelt. Dies ist bekannt alsconnecting experience.

Wichtige Merkmale der vernetzten Erfahrung -

  • Windows 10 ist der erste Schritt in eine Ära des Personal Computing, in der Ihre Apps, Dienste und Inhalte nahtlos und einfach über Geräte hinweg mit Ihnen übertragen werden können.

  • Mit Connected Experience können Sie Ihre Daten und persönlichen Einstellungen für diese Anwendung problemlos freigeben und sie sind auf allen Geräten verfügbar.

In diesem Kapitel lernen wir -

  • Hier werden diese freigegebenen Daten oder Einstellungen gespeichert, damit sie für diese eine Anwendung auf Ihren Geräten verfügbar sind.

  • wie der Benutzer identifiziert wird; dass es derselbe Benutzer ist, der dieselbe Anwendung auf verschiedenen Geräten verwendet.

Windows 10 macht einen mutigen Schritt nach vorne. Wenn Sie sich mit einem Microsoft-Konto (MSA) oder Ihrem Unternehmens- oder (Arbeits-) Konto bei Windows 10 anmelden, wird davon ausgegangen, dass -

  • Sie haben freien Zugriff auf das OneDrive for MSA-Konto und auf Active Directory (AD) und Azure Active Directory (AAD), eine Cloud-Version mit Ihrem Unternehmenskonto.

  • Sie haben Zugriff auf verschiedene Anwendungen und Ressourcen.

  • Die Geräte und Anwendungen befinden sich im Roaming-Status und in den Einstellungen.

Roaming in Windows 10

Wenn Sie sich an einem PC anmelden, legen Sie einige Einstellungen wie Sperrbildschirm oder Hintergrundfarbe fest oder personalisieren Ihre verschiedenen Einstellungen. Wenn Sie mehr als einen Computer oder ein Gerät haben, das unter Windows 10 ausgeführt wird, werden Ihre Einstellungen und Einstellungen auf einem Gerät aus der Cloud synchronisiert, wenn Sie sich bei anderen Geräten mit demselben Konto anmelden.

Wenn Sie in Windows 10 Ihre Anwendungseinstellungen festgelegt oder personalisiert haben, werden diese Einstellungen mit den in UWP verfügbaren Roaming-APIs geändert. Wenn Sie dieselbe Anwendung erneut auf einem anderen Gerät ausführen, werden zuerst die Einstellungen abgerufen und diese Einstellungen auf die Anwendung auf diesem Gerät angewendet.

Das Hochladen von Roaming-Daten in die Cloud ist auf 100 KB begrenzt. Wenn dieser Grenzwert überschritten wird, wird die Synchronisierung gestoppt und verhält sich wie ein lokaler Ordner.

Das RoamingSettings APIs werden als Wörterbuch angezeigt, in dem eine Anwendung Daten speichern kann.

Windows.Storage.ApplicationDataContainer roamingSettings = 
   Windows.Storage.ApplicationData.Current.RoamingSettings;  
				   
// Retrivve value from RoamingSettings 
var colorName = roamingSettings.Values["PreferredBgColor"].ToString(); 
 
// Set values to RoamingSettings 
roamingSettings.Values["PreferredBgColor"] = "Green";

Wenn sich die Daten ändern RoamingSettings dann feuert es die DataChanged Ereignis, bei dem Sie Ihre Einstellungen aktualisieren können.

Windows.Storage.ApplicationData.Current.DataChanged += RoamingDataChanged;  

private void RoamingDataChanged(Windows.Storage.ApplicationData sender, object args) {
   // Something has changed in the roaming data or settings 
}

Schauen wir uns ein Beispiel an, in dem wir die Hintergrundfarbe der Anwendung festlegen und diese Einstellungen mit den in UWP verfügbaren Roaming-APIs durchlaufen.

Unten ist der XAML-Code angegeben, in dem verschiedene Steuerelemente hinzugefügt werden.

<Page 
   x:Class = "RoamingSettingsDemo.Views.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:RoamingSettingsDemo.Views" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">
   
   <Grid x:Name = "MainGrid" Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}">
      <Grid.RowDefinitions> 
         <RowDefinition Height = "80" /> 
         <RowDefinition /> 
      </Grid.RowDefinitions>
		
      <StackPanel Orientation = "Horizontal" VerticalAlignment = "Top" Margin = "12,12,0,0"> 
         <TextBlock Style = "{StaticResource HeaderTextBlockStyle}"  
            FontSize = "24" Text = "Connected Experience Demo" /> 
      </StackPanel>
		
      <Grid Grid.Row = "1" Margin = "0,80,0,0"> 
         <StackPanel Margin = "62,0,0,0"> 
            <TextBlock x:Name = "textBlock" HorizontalAlignment = "Left"   
               TextWrapping = "Wrap" Text = "Choose your background color:"  
               VerticalAlignment = "Top"/> 
					
            <RadioButton x:Name = "BrownRadioButton" Content = "Brown"  
               Checked = "radioButton_Checked" /> 
					
            <RadioButton x:Name = "GrayRadioButton" Content = "Gray"  
               Checked = "radioButton_Checked"/> 
         </StackPanel> 
      </Grid> 
		
   </Grid> 
	
</Page>

C # -Implementierung für RoamingSettings und verschiedene Ereignisse sind unten angegeben.

using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Linq; 
using System.Runtime.InteropServices.WindowsRuntime; 

using Windows.Foundation; 
using Windows.Foundation.Collections; 

using Windows.UI; 
using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
using Windows.UI.Xaml.Controls.Primitives; 
using Windows.UI.Xaml.Data; 
using Windows.UI.Xaml.Input; 
using Windows.UI.Xaml.Media; 
using Windows.UI.Xaml.Navigation;  

// The RoamingSettingsDemo Page item template is documented at 
   http://go.microsoft.com/fwlink/?LinkId=234238  

namespace RoamingSettingsDemo.Views {

   /// <summary>
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class MainPage : Page {
   
      public MainPage() {
         this.InitializeComponent(); 
      }  
		
      protected override void OnNavigatedTo(NavigationEventArgs e) {
         SetBackgroundFromSettings();  
         Windows.Storage.ApplicationData.Current.DataChanged += RoamingDataChanged; 
      }  
		
      protected override void OnNavigatedFrom(NavigationEventArgs e) {
         Windows.Storage.ApplicationData.Current.DataChanged -= RoamingDataChanged; 
      }  
		
      private void RoamingDataChanged(Windows.Storage.ApplicationData sender, object args) {
	  
         // Something has changed in the roaming data or settings 
         var ignore = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,  
            () ⇒ SetBackgroundFromSettings()); 
      } 
		
      private void SetBackgroundFromSettings() {
	  
         // Get the roaming settings 
         Windows.Storage.ApplicationDataContainer roamingSettings = 
            Windows.Storage.ApplicationData.Current.RoamingSettings;  
				   
         if (roamingSettings.Values.ContainsKey("PreferBrownBgColor")) {
            var colorName = roamingSettings.Values["PreferBrownBgColor"].ToString();
				
            if (colorName == "Gray") {
               MainGrid.Background = new SolidColorBrush(Colors.Gray); 
               GrayRadioButton.IsChecked = true; 
            } else if (colorName == "Brown") {
               MainGrid.Background = new SolidColorBrush(Colors.Brown); 
               BrownRadioButton.IsChecked = true; 
            } 
         } 
			
      } 
		
      private void radioButton_Checked(object sender, RoutedEventArgs e){ 
         if (GrayRadioButton.IsChecked.HasValue && 
            (GrayRadioButton.IsChecked.Value == true)) {
               Windows.Storage.ApplicationData.Current.RoamingSettings.
                  Values["PreferBrownBgCo lor"] = "Gray"; 
         } else {
            Windows.Storage.ApplicationData.Current.RoamingSettings.
               Values["PreferBrownBgCo lor"] = "Brown"; 
         }  
			
         SetBackgroundFromSettings(); 
      } 
		
   } 
}

Wenn der obige Code kompiliert und ausgeführt wird, wird das folgende Fenster angezeigt.

Lassen Sie uns graue Farbe als Hintergrundfarbe wählen und diese App schließen.

Wenn Sie diese App auf diesem oder einem anderen Gerät ausführen, sehen Sie, dass sich die Hintergrundfarbe in Grau geändert hat. Dies zeigt, dass die App die Informationen zur Änderung der Hintergrundfarbe in erfolgreich abgerufen hatRoamingSettings.

In UWP-Anwendungen (Universal Windows Platform) ist die Navigation ein flexibles Modell für Navigationsstrukturen, Navigationselemente und Funktionen auf Systemebene. Es ermöglicht eine Vielzahl intuitiver Benutzererfahrungen beim Wechseln zwischen Apps, Seiten und Inhalten.

Es gibt Situationen und Szenarien, in denen der gesamte Inhalt und die Funktionalität problemlos auf eine einzelne Seite passen und die Entwickler nicht mehrere Seiten erstellen müssen. In den meisten Anwendungen werden jedoch mehrere Seiten für die Interaktion zwischen verschiedenen Inhalten und Funktionen verwendet.

Wenn eine App mehr als eine Seite hat, ist es für die Entwickler sehr wichtig, das richtige Navigationserlebnis zu bieten.

Seitenmodelle

In UWP-Anwendungen (Universal Windows Platform) wird normalerweise ein einseitiges Navigationsmodell verwendet.

Wichtige Funktionen sind -

  • Ein einseitiges Navigationsmodell verwaltet den gesamten Kontext Ihrer Anwendung sowie zusätzliche Inhalte und Daten in einem zentralen Rahmen.

  • Sie können den Inhalt Ihrer Anwendung in mehrere Seiten aufteilen. Wenn Sie jedoch von einer Seite zur anderen wechseln, lädt Ihre Anwendung die Seiten in ein Hauptseitenformular.

  • Weder die Hauptseite Ihrer Anwendung wird entladen, noch der Code und die Daten werden entladen. Dies erleichtert die Verwaltung des Status und bietet flüssigere Übergangsanimationen zwischen den Seiten.

Die mehrseitige Navigation wird auch zum Navigieren zwischen verschiedenen Seiten oder Bildschirmen verwendet, ohne sich um den Anwendungskontext zu kümmern. Bei der mehrseitigen Navigation hat jede Seite ihre eigenen Funktionen, Benutzeroberflächen und Daten usw.

Die mehrseitige Navigation wird normalerweise auf Webseiten innerhalb der Website verwendet.

Navigationsstruktur

Bei der mehrseitigen Navigation verfügt jede Seite über eigene Funktionen, Benutzeroberflächen und Daten usw. Beispielsweise kann eine Fotoanwendung eine Seite zum Aufnehmen von Fotos haben. Wenn der Benutzer das Foto bearbeiten möchte, navigiert er zu einer anderen Seite und um die Bildbibliothek zu pflegen, hat es eine andere Seite.

Die Navigationsstruktur Ihrer Anwendung wird durch die Organisation dieser Seiten definiert.

Im Folgenden finden Sie die Möglichkeiten, die Navigation in Ihrer Anwendung zu strukturieren:

Hierarchie

Bei dieser Art der Navigationsstrukturierung

  • Seiten sind in einer baumartigen Struktur organisiert.

  • Jede untergeordnete Seite hat nur eine übergeordnete Seite, aber eine übergeordnete Seite kann eine oder mehrere untergeordnete Seiten haben.

  • Um eine untergeordnete Seite zu erreichen, müssen Sie durch die übergeordnete Seite reisen.

Peer

In dieser Art der Navigation -

  • Seiten existieren nebeneinander.
  • Sie können in beliebiger Reihenfolge von einer Seite zur anderen wechseln.

In den meisten mehrseitigen Anwendungen werden beide Strukturen gleichzeitig verwendet. Einige der Seiten sind als Peers organisiert, andere in Hierarchien.

Nehmen wir ein Beispiel, das drei Seiten enthält.

  • Erstellen Sie eine leere UWP-Anwendung mit dem Namen UWPNavigation.

  • Fügen Sie zwei weitere leere Seiten hinzu, indem Sie mit der rechten Maustaste auf das Projekt in klicken Solution Explorer und auswählen Add > New Item Option aus dem Menü, das das folgende Dialogfenster öffnet.

  • Wählen Sie im mittleren Bereich die Seite Leer aus und klicken Sie auf Add Taste.

  • Fügen Sie nun eine weitere Seite hinzu, indem Sie die oben angegebenen Schritte ausführen.

Im Projektmappen-Explorer werden drei Seiten angezeigt - MainPage, BlankPage1, und BlankPage2.

Unten ist der XAML-Code für angegeben MainPage in dem zwei Schaltflächen hinzugefügt werden.

<Page 
   x:Class = "UWPNavigation.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPNavigation" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">  
	
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <Hub Header = "Hi, this Main Page"/> 
      <Button Content = "Go to Page 1" Margin = "64,131,0,477" Click = "Button_Click"/>
      <Button Content = "Go to Page 2" Margin = "64,210,0,398" Click = "Button_Click_1"/> 
   </Grid> 
	
</Page>

Unten ist der C # -Code für zwei Schaltflächen angegeben MainPage, die zu den beiden anderen Seiten navigiert.

using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls;
  
// The Blank Page item template is documented at 
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409  

namespace UWPNavigation {

   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class MainPage : Page {
      public MainPage() {
         this.InitializeComponent(); 
      }  
		
      private void Button_Click(object sender, RoutedEventArgs e){ 
         this.Frame.Navigate(typeof(BlankPage1)); 
      } 
		
      private void Button_Click_1(object sender, RoutedEventArgs e) {
         this.Frame.Navigate(typeof(BlankPage2)); 
      } 
		
   } 
}

Der XAML-Code für blank page 1 wird unten gezeigt.

<Page 
   x:Class = "UWPNavigation.BlankPage1" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPNavigation" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d"> 
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
      <Hub Header = "Hi, this is page 1"/> 
      <Button Content = "Go to Main Page" Margin = "64,94,0,514" Click = "Button_Click"/> 
   </Grid> 
	
</Page>

C # -Code für Schaltfläche - Klicken Sie auf Ereignis blank page 1, die zur Hauptseite navigiert, wird unten gezeigt.

using System; 
using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
 
// The Blank Page item template is documented at
   http://go.microsoft.com/fwlink/?LinkId=234238 
	
namespace UWPNavigation {

   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class BlankPage1 : Page {
    
      public BlankPage1() {
         this.InitializeComponent(); 
      }
		
      private void Button_Click(object sender, RoutedEventArgs e) {
         this.Frame.Navigate(typeof(MainPage)); 
      }
		
   } 
}

Unten ist der XAML-Code für angegeben blank page 2.

<Page 
   x:Class = "UWPNavigation.BlankPage2" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPNavigation" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d"> 
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}">
      <Hub Header = "Hi, this is page 2"/>
      <Button Content = "Go to Main Page" Margin = "64,94,0,514" Click = "Button_Click"/> 
   </Grid> 
	
</Page>

Unten ist der C # -Code für das Ereignis zum Klicken auf eine Schaltfläche angegeben blank page 2, die zur Hauptseite navigieren.

using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
 
// The Blank Page item template is documented at  
   http://go.microsoft.com/fwlink/?LinkId=234238
	
namespace UWPNavigation {

   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary>
	
   public sealed partial class BlankPage2 : Page {
   
      public BlankPage2(){ 
         this.InitializeComponent(); 
      } 
		
      private void Button_Click(object sender, RoutedEventArgs e) {
         this.Frame.Navigate(typeof(MainPage)); 
      }
		
   } 
}

Wenn der obige Code kompiliert und ausgeführt wird, wird das folgende Fenster angezeigt.

Wenn Sie auf eine Schaltfläche klicken, werden Sie zur entsprechenden Seite navigiert. Lassen Sie uns auf klickenGo to Page 1 und die folgende Seite wird angezeigt.

Wenn Sie auf die Schaltfläche klicken 'Go to Main Page'wird zur Hauptseite zurück navigiert.

Heutzutage werden Sie viele Anwendungen sehen, die sich irgendwie in Webdienste oder andere Geräte in einem Netzwerk integriert haben. Das Abrufen von Online-Wetterinhalten, neuesten Nachrichten, Chatten oder Peer-to-Peer-Spielen sind einige Beispiele für die Verwendung von Netzwerkdiensten. Diese Apps werden mit einer Vielzahl von Netzwerk-APIs erstellt. In Windows 10 werden die Netzwerk-APIs hinsichtlich ihrer Geschwindigkeit und Speicherleistung sowie der Funktionen und Flexibilität, die sie den Entwicklern bieten, verbessert.

Fähigkeiten

Um sich zu vernetzen, müssen Sie Ihrem App-Manifest entsprechende Funktionselemente hinzufügen. Wenn im Manifest Ihrer App keine Netzwerkfähigkeit angegeben ist, verfügt Ihre App über keine Netzwerkfähigkeit, und jeder Versuch, eine Verbindung zum Netzwerk herzustellen, schlägt fehl.

Im Folgenden sind die am häufigsten verwendeten Netzwerkfunktionen aufgeführt.

S.No. Fähigkeit & Beschreibung
1

internetClient

Bietet ausgehenden Zugang zum Internet und zu Netzwerken an öffentlichen Orten wie Flughäfen und Cafés. Die meisten Apps, die einen Internetzugang benötigen, sollten diese Funktion verwenden.

2

internetClientServer

Ermöglicht der App den eingehenden und ausgehenden Netzwerkzugriff über das Internet und Netzwerke an öffentlichen Orten wie Flughäfen und Cafés.

3

privateNetworkClientServer

Ermöglicht der App den eingehenden und ausgehenden Netzwerkzugriff an den vertrauenswürdigen Orten der Benutzer, z. B. zu Hause und am Arbeitsplatz.

Sehen Sie sich das folgende Bild an, um eine oder mehrere Funktionen in Ihrer App-Manifestdatei zu definieren.

Die Universal Windows Platform (UWP) enthält eine Vielzahl von Netzwerk-APIs, die auf Folgendes abzielen:

  • Abfragen des Konnektivitätsstatus des Geräts und Herstellen einer Verbindung zu den Peer-Geräten.
  • Kommunikation mit REST-Webdiensten und
  • Herunterladen großer Mediendateien im Hintergrund

Netzwerktechnologien

In der Universal Windows Platform (UWP) stehen den Entwicklern die folgenden Netzwerktechnologien zur Verfügung, die in vielen verschiedenen Situationen verwendet werden können.

Steckdosen

Sockets werden verwendet, wenn Sie mit einem anderen Gerät mit Ihrem eigenen Protokoll kommunizieren möchten.

  • Sie können beide verwenden, Windows.Networking.Sockets und Winsock als Entwickler einer Universal Windows Platform (UWP) -App mit anderen Geräten zu kommunizieren.

  • Windows.Networking.Sockets hat den Vorteil, eine moderne API zu sein, die für die Verwendung durch UWP-Entwickler entwickelt wurde.

  • Wenn Sie plattformübergreifende Netzwerkbibliotheken oder anderen vorhandenen Winsock-Code verwenden, verwenden Sie Winsock APIs.

Der folgende Code zeigt, wie Sie einen Socket-Listener erstellen.

try {
 
//Create a StreamSocketListener to start listening for TCP connections. 
   Windows.Networking.Sockets.StreamSocketListener socketListener = new 
      Windows.Networking.Sockets.StreamSocketListener(); 
					  
//Hook up an event handler to call when connections are received. 
   socketListener.ConnectionReceived += SocketListener_ConnectionReceived;
   
//Start listening for incoming TCP connections on the specified port. 
   You can specify any port that's not currently in use. 
	
   await socketListener.BindServiceNameAsync("1337"); 
} catch (Exception e) {
   //Handle exception. 
}

Der folgende Code zeigt die Implementierung des SocketListener_ConnectionReceived Event-Handler.

private async void SocketListener_ConnectionReceived(
   Windows.Networking.Sockets.StreamSocketListen er sender, 
   Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args){ 
 
   //Read line from the remote client. 
   Stream inStream = args.Socket.InputStream.AsStreamForRead(); 
   StreamReader reader = new StreamReader(inStream); 
   string request = await reader.ReadLineAsync(); 
	
   //Send the line back to the remote client. 
   Stream outStream = args.Socket.OutputStream.AsStreamForWrite(); 
   StreamWriter writer = new StreamWriter(outStream); 
	
   await writer.WriteLineAsync(request); 
   await writer.FlushAsync(); 
}

WebSocket

Das WebSocketsDas Protokoll bietet eine schnelle und sichere bidirektionale Kommunikation zwischen einem Client und einem Server über das Web. Entwickler der Universal Windows Platform (UWP) können dieMessageWebSocket und StreamWebSocket Klassen für die Verbindung mit Servern, die das Websocket-Protokoll unterstützen.

Wichtige Funktionen sind -

  • Im Rahmen des WebSocket-Protokolls werden Daten sofort über eine Vollduplex-Single-Socket-Verbindung übertragen.

  • Es ermöglicht das Senden und Empfangen von Nachrichten von beiden Endpunkten in Echtzeit.

  • WebSockets sind ideal für den Einsatz in Echtzeitspielen, bei denen sofortige Benachrichtigungen über soziale Netzwerke und aktuelle Anzeigen von Informationen (Spielstatistiken) sicher sein und eine schnelle Datenübertragung ermöglichen müssen.

Der folgende Code zeigt, wie Sie Nachrichten über eine sichere Verbindung senden und empfangen.

MessageWebSocket webSock = new MessageWebSocket(); 
 
//In this case we will be sending/receiving a string so we need to 
   set the MessageType to Utf8. 
webSock.Control.MessageType = SocketMessageType.Utf8;  

//Add the MessageReceived event handler. 
webSock.MessageReceived += WebSock_MessageReceived;  

//Add the Closed event handler. 
webSock.Closed += WebSock_Closed; 
 
Uri serverUri = new Uri("wss://echo.websocket.org");
  
try {
   //Connect to the server. 
   await webSock.ConnectAsync(serverUri);
	
   //Send a message to the server. 
   await WebSock_SendMessage(webSock, "Hello, world!"); 
} catch (Exception ex) { 
   //Add code here to handle any exceptions 
}

Der folgende Code zeigt die Ereignisimplementierung, die eine Zeichenfolge von einer verbundenen Person empfängt WebSocket.

//The MessageReceived event handler. 
private void WebSock_MessageReceived(MessageWebSocket sender, 
   MessageWebSocketMessageReceivedEventArgs args){ 

   DataReader messageReader = args.GetDataReader(); 
   messageReader.UnicodeEncoding = UnicodeEncoding.Utf8; 
   string messageString = messageReader.ReadString(
      messageReader.UnconsumedBufferLength);  
   //Add code here to do something with the string that is received. 
}

HttpClient

HttpClient und Windows.Web.Http Namespace-APIs bieten dem Entwickler die Möglichkeit, Informationen mithilfe der Protokolle HTTP 2.0 und HTTP 1.1 zu senden und zu empfangen.

Es kann verwendet werden, um -

  • mit einem Webdienst oder einem Webserver kommunizieren.
  • Laden Sie eine Reihe kleiner Dateien hoch oder laden Sie sie herunter.
  • Streamen Sie den Inhalt über das Netzwerk.

Der folgende Code zeigt, wie Sie eine GET-Anforderung mit senden Windows.Web.Http.HttpClient und Windows.Web.Http.HttpResponseMessage.

//Create an HTTP client object 
Windows.Web.Http.HttpClient httpClient = new Windows.Web.Http.HttpClient(); 
 
//Add a user-agent header to the GET request.  
var headers = httpClient.DefaultRequestHeaders;

//The safe way to add a header value is to use the TryParseAdd method 
   and verify the return value is true, 
	
//especially if the header value is coming from user input. 
string header = "ie"; 

if (!headers.UserAgent.TryParseAdd(header)) {
   throw new Exception("Invalid header value: " + header); 
}  

header = "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)";
 
if (!headers.UserAgent.TryParseAdd(header)) {
   throw new Exception("Invalid header value: " + header); 
}  

Uri requestUri = new Uri("http://www.contoso.com"); 
 
//Send the GET request asynchronously and retrieve the response as a string. 
Windows.Web.Http.HttpResponseMessage httpResponse = new
   Windows.Web.Http.HttpResponseMessage(); 
string httpResponseBody = ""; 
 
try {
   //Send the GET request 
   httpResponse = await httpClient.GetAsync(requestUri); 
   httpResponse.EnsureSuccessStatusCode(); 
   httpResponseBody = await httpResponse.Content.ReadAsStringAsync(); 
} catch (Exception ex) {
   httpResponseBody = "Error: " + ex.HResult.ToString("X") + " Message: " + ex.Message; 
}

Als Entwickler benötigen Sie möglicherweise andere Daten als die auf Ihrem Desktop verfügbaren. Cloud-Dienste können Ihnen beim Zugriff auf diese Daten helfen. Dieses Kapitel bietet ein besseres Verständnis der Cloud-Dienste, die Sie möglicherweise benötigen.

Microsoft hat eine Cloud-Computing-Plattform und die Infrastruktur bereitgestellt, die als bekannt ist Microsoft AzureHier können Sie alle Anwendungen und Dienste erstellen, bereitstellen und verwalten.

Azure wurde erstmals am 1. Februar 2010 als Windows Azure veröffentlicht. Später wurde es am 25. März 2014 in Microsoft Azure umbenannt.

Es bietet beides, PaaS and IaaS bietet und unterstützt viele verschiedene Programmiersprachen, Tools und Frameworks, einschließlich Microsoft-spezifischer Software und Systeme von Drittanbietern.

Microsoft hat die Cloud-Dienste mit Windows 10 aktualisiert. Die Microsoft-Kontointegration wurde jedoch in Windows 8 eingeführt OneDrive gibt es seit 2007. Für Windows 10 wurden beide Dienste mit verbesserter Integration und neuen Funktionen aktualisiert, die mehr Benutzer anziehen.

Microsoft-Konto

Sie können die Azure-Cloud-Angebote von Microsoft mit Ihrem Microsoft-Konto verwenden. Natürlich ist es nicht kostenlos, aber Sie können eine kostenlose 30-Tage-Testversion verwenden.

Wenn Sie zum ersten Mal einen Computer mit Windows 10 einrichten und sich mit einem Microsoft-Konto anmelden, können Sie dasselbe Konto für das Microsoft Azure-Abonnement verwenden. Um sich für Microsoft Azure anzumelden, klicken Sie hierhttps://azure.microsoft.com/.

Wechseln Sie nach dem Abonnieren von Microsoft Azure zum Azure-Portal https://portal.azure.com/. Sie sehen die folgende Seite.

Sie können in den Datenbanken speichern, virtuelle Maschinen verwenden usw. Sie können auch das Back-End Ihrer mobilen App erstellen und hosten.

Versuchen wir dies anhand eines Beispiels, indem wir die folgenden Schritte ausführen.

  • Klick auf das New Option im linken Bereich.

  • Wählen Web + Mobile > Mobile App und geben Sie Ihrer Web-App einen Namen.

  • Das Senden und Bereitstellen Ihrer App dauert einige Zeit. Sobald dieser Vorgang abgeschlossen ist, wird die folgende Seite angezeigt. Hier können Sie die verschiedenen Arten von mobilen Apps wie Windows (C #), iOS Android usw. auswählen.

  • Da es sich um Windows 10 handelt, wählen Sie Windows (C #) aus, um die folgende Seite zu öffnen.

  • Hier sehen Sie die beiden Download-Optionen. Hierbei handelt es sich um Beispielprojekte, die Sie einfach herunterladen und in Visual Studio erstellen und anschließend problemlos in Microsoft Azure veröffentlichen können.

  • Laden wir das erste herunter, bei dem es sich um ein Serverprojekt handelt. Es ist eine Zip-Datei.

  • Wenn der Download abgeschlossen ist, entpacken Sie diese und öffnen Sie sie in Visual Studio.

  • Erstellen Sie jetzt diese Anwendung. Wenn einige Fehler aufgelistet sind, erstellen Sie sie erneut.

  • Führen Sie die Anwendung aus. Sie sehen die folgende Webseite, die sich jetzt auf localhost befindet.

  • Um diese Anwendung in der Cloud zu hosten, klicken Sie mit der rechten Maustaste auf Project Option in Solution Explore Wie nachfolgend dargestellt.

  • Wählen PublishOption aus dem Menü. Sie sehen den folgenden Dialog.

  • Wählen Sie die erste Option - Microsoft Azure Web Apps. Das folgende Dialogfeld wird geöffnet.

  • Klicken Sie nun auf die Add an account Option aus dem Menü zum Hinzufügen eines Microsoft Azure-Kontos.

  • Geben Sie Ihre Anmeldeinformationen an und klicken Sie auf Sign in. The following dialog window will open.

  • After signing in, select your application from the menu Existing Web Apps and click Ok.

  • The dialog shown below displays some information related to your application such as name, server name, URL, etc.

  • Now, click on the Validate Connection button. After validation, click the Publish button and you will see that your application is now hosted on Microsoft Azure.

In this chapter, we will talk about the interaction with a user through tiles. It is the iconic part of Windows 10. Tiles are displayed on the Start Screen as well as on the Start Menu. In other words, it is an application icon asset, which appears in a variety of forms throughout the Windows 10 operating system. They are the calling cards for your Universal Windows Platform (UWP) app.

Tile Anatomy

There are three states of tile.

  • Basic State − Basic components of a Start tile consist of a back plate, an icon, and an app title.

  • Semi-Live state − It is the same as the basic tile with the only difference that the badge, which is a number, can display the numbers from 0-99.

  • Live State − This tile contains all the elements of semi-live state tile and also shows additional content plate where you can put anything you want such as photos, text etc.

Updating Tiles

There are four ways to update the tiles.

  • Scheduled − You can set the template and time with ScheduledTileNotification.

  • Periodic − When information is retrieved from a URI and you can specify the time to pull the information after that period of time, such as 30min, 1 hr., 6 hrs. etc.

  • Local − Local one can be updated from your application; either from the foreground or the background app.

  • Push − It is updated from the server by pushing the information from the server.

To create a tile, follow the given code.

var tileXml = 
   TileUpdateManager.GetTemplateContent(TileTemplateType.TileSquare150x150Text01); 
 
var tileAttributes = tileXml.GetElementsByTagName("text"); 
tileAttributes[0].AppendChild(tileXml.CreateTextNode("Hello"));
			
var tileNotification = new TileNotification(tileXml);			
TileUpdateManager.CreateTileUpdaterForApplication().Update(tileNotification);

Update badge is pretty simple because it is just a number and you can set the value of badge as shown below.

var type = BadgeTemplateType.BadgeNumber; 
var xml = BadgeUpdateManager.GetTemplateContent(type);  

var elements = xml.GetElementsByTagName("badge"); 
var element = elements[0] as Windows.Data.Xml.Dom.XmlElement; 
element.SetAttribute("value", "7");
  
var updator = BadgeUpdateManager.CreateBadgeUpdaterForApplication(); 
var notification = new BadgeNotification(xml); 
updator.Update(notification);

Let us create a new UWP project in Visual Studio.

  • You will see the different png files under the Assets folder in Solution Explorer.

  • Let us define a default tile and its image in the package manifest.

  • Double-click on the package.appxmanifest. This opens the manifest editor window.

  • Select Visual Assets tab.

  • You can select the images and icons for your application tile with any of the specified dimensions. Under the Tile Images and Logos, default images are provided for all logos such as

    • Square 71x71 Logo
    • Square 150x150 Logo
    • Square 310x310 Logo
    • Store Logo
  • When you execute your application and then go to your start screen, you will see the tile for your application.

In this chapter, we will learn how to share data between applications. Users often come across information that they are excited to share with someone or use it in another application. Nowadays, users want to use technology to connect and share with other people.

A user may want to share −

  • A link with their social network
  • Copy a picture into a report
  • Upload a file to cloud storage

Applications today, need to ensure that the data they use is also available for users to share and exchange. Share is a lightweight feature, which is easy to add to your UWP application. There are several ways for the apps to exchange data with other apps.

In UWP applications, the share feature can be supported in the following ways;

  • First, application can be a source app that provides content that the user wants to share.

  • Second, the app can be a target app that the user selects as the destination for shared content.

  • An app can also be both a source app and a target app.

Sharing Content

Sharing content from an application, which is a source app is very simple. To perform any sharing operation, you will need the DataPackage class object. This object contains the data, which the user wants to share.

The following types of content can be included in DataPackage object −

  • Plain text
  • Uniform Resource Identifiers (URIs)
  • HTML
  • Formatted text
  • Bitmaps
  • Files
  • Developer-defined data

While sharing data, you can include one or more of the above-mentioned formats. To support sharing in your application, you first need to get the instance of the DataTransferManager class.

It will then register an event handler that is called whenever a DataRequested event occurs.

DataTransferManager dataTransferManager = DataTransferManager.GetForCurrentView(); 
dataTransferManager.DataRequested += new TypedEventHandler<DataTransferManager, 
   DataRequestedEventArgs>(this.ShareTextHandler);

When your app receives a DataRequest object, then your application is ready to add the content that the user wants to share.

private void ShareTextHandler(DataTransferManager sender, DataRequestedEventArgs e){
   DataRequest request = e.Request;
	
   // The Title is mandatory 
   request.Data.Properties.Title = "Share Text Example"; 
   request.Data.Properties.Description = "A demonstration that shows how to share text."; 
   request.Data.SetText("Hello World!"); 
}

Any content that your application shares, must contain two properties −

  • A Title property, which is mandatory and must be set.
  • The content itself.

Receiving Shared Content

If you want that your application can receive shared content then the first thing you need to do is to declare that it supports the Share Contract. After declaration, the system will let your application be available to receive content.

To add support of the Share Contract −

  • Double click on the package.appmanifest file.

  • Go to the Declarations tab. Choose Share Target from the Available Declarations list, and click on the Add button.

  • If you want your application to receive any kind of file as shared content, then you can specify the file types and data formats.

  • To specify the Data Formats that you support go to the Data Formats section, of the Declarations page and click Add New.

  • Type the name of the data format you support. For example, "Text".

  • To specify the file type that you support, in the Supported File Types section of the Declarations page, click Add New.

  • Type the file name extension that you want to support, e.g, .pdf

  • If you want to support All file types, check the SupportsAnyFileType box.

  • When a user selects your application as target application for sharing data then OnShareTargetActivated event is fired.

  • Your app needs to handle this event to process the data, which the user wants to share.

protected override async void OnShareTargetActivated(ShareTargetActivatedEventArgs args) { 
   // Code to handle activation goes here.  
}
  • All the data that the user wants to share with any application is contained in a ShareOperation object. You can also check the format of the data it contains.

Given below is the code snippet that handles shared content in plain text format.

ShareOperation shareOperation = args.ShareOperation;
 
if (shareOperation.Data.Contains(StandardDataFormats.Text)) {
   string text = await shareOperation.Data.GetTextAsync(); 
   
   // To output the text from this example, you need a TextBlock control 
   // with a name of "sharedContent". 
   sharedContent.Text = "Text: " + text; 
}

Let us have look at a simple example by creating a new UWP project, which will share a weblink.

Im Folgenden ist der XAML-Code angegeben, in dem eine Schaltfläche mit einigen Eigenschaften erstellt wird.

<Page 
   x:Class = "UWPSharingDemo.MainPage" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "using:UWPSharingDemo" 
   xmlns:d = "http://schemas.microsoft.com/expression/blend/2008" 
   xmlns:mc = "http://schemas.openxmlformats.org/markup-compatibility/2006" 
   mc:Ignorable = "d">
   
   <Grid Background = "{ThemeResource ApplicationPageBackgroundThemeBrush}"> 
	
      <StackPanel Orientation = "Vertical"> 
         <TextBlock Text = "Share Web Link" Style = "{StaticResource 
            HeaderTextBlockStyle}" Margin = "30"></TextBlock> 
				
         <Button Content = "Invoke share contract" Margin = "10"
            Name = "InvokeShareContractButton" Click = "InvokeShareContractButton_Click"
            ></Button> 
      </StackPanel>
		
   </Grid> 
	
</Page>

Im Folgenden wird ein C # -Code angegeben, in dem ein Ereignis mit Schaltflächenklick implementiert ist und ein URI-Freigabecode angegeben ist.

using System; 

using Windows.ApplicationModel.DataTransfer; 
using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls;  

// The Blank Page item template is documented at 
   http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409  
	
namespace UWPSharingDemo {
 
   /// <summary> 
      /// An empty page that can be used on its own or navigated to within a Frame. 
   /// </summary> 
	
   public sealed partial class MainPage : Page {
    
      DataTransferManager dataTransferManager;
		
      public MainPage() {
         this.InitializeComponent(); 
         dataTransferManager = DataTransferManager.GetForCurrentView();  
         dataTransferManager.DataRequested += dataTransferManager_DataRequested; 
      }
		
      void dataTransferManager_DataRequested(DataTransferManager sender,
         DataRequestedEventArgs args) { 
            Uri sharedWebLink = new Uri("https://msdn.microsoft.com");
				
            if (sharedWebLink != null) {
               DataPackage dataPackage = args.Request.Data; 
               dataPackage.Properties.Title = "Sharing MSDN link"; 
				
               dataPackage.Properties.Description = "The Microsoft Developer Network (MSDN)
                  is designed to help developers write applications using Microsoft 
                  products and technologies.";
					
               dataPackage.SetWebLink(sharedWebLink); 
            } 
      }
		
      private void InvokeShareContractButton_Click(object sender, RoutedEventArgs e) {
         DataTransferManager.ShowShareUI(); 
      }
		
   } 
}

Wenn der obige Code kompiliert und ausgeführt wird, wird die folgende Seite des Emulators angezeigt.

Wenn Sie auf die Schaltfläche klicken, werden die Optionen zum Teilen für welche Anwendung angezeigt.

Klicken Sie auf Messaging. Das folgende Fenster wird angezeigt, von dem aus Sie den Link an jeden senden können.

In diesem Kapitel erfahren Sie, wie Sie Ihre vorhandene Windows 8.1-App auf die Universal Windows Platform (UWP) portieren. Sie können ein einzelnes Windows 10-App-Paket erstellen, das Ihre Kunden auf allen Gerätetypen installieren können.

Nachdem Sie Ihre Anwendung auf Windows 10 UWP portiert haben, profitiert Ihre App von:

  • Spannende neue Hardware
  • Große Monetarisierungsmöglichkeiten
  • Ein modernes API-Set,
  • Adaptive UI-Steuerelemente,
  • Adaptives Design und Code
  • Eine Reihe von Eingabemodalitäten wie Maus, Tastatur, Berührung und Sprache.

Portieren eines Windows 8.x-Projekts in ein UWP-Projekt

Es gibt zwei Möglichkeiten, Ihre vorhandene Windows 8.x-Anwendung auf die Universal Windows Platform (UWP) zu portieren.

Option 1 - Eine Möglichkeit besteht darin, ein neues Windows 10-Projekt in Visual Studio zu erstellen und Ihre Dateien darin zu kopieren.

Option 2 - Die andere Option besteht darin, eine Kopie Ihrer vorhandenen Projektdateien einschließlich des App-Paket-Manifests zu bearbeiten.

Nachfolgend sind die wichtigsten Schritte bei Verwendung der ersten Option aufgeführt.

  • Starten Sie Microsoft Visual Studio 2015 und erstellen Sie ein neues Windows-Projekt (Blank Application) mit dem Namen UWPBookStore.

  • Ihr neues Projekt erstellt ein App-Paket (eine AppX-Datei), das auf allen Gerätefamilien ausgeführt wird.

  • Identifizieren Sie in Ihrem Universal 8.1-App-Projekt alle Quellcodedateien und visuellen Asset-Dateien, die Sie wiederverwenden möchten. Unten sehen Sie eine Beispielanwendung mit drei Projekten. Eines wird für Windows verwendet, das zweite für Mobilgeräte und das dritte ist das gemeinsam genutzte Projekt für Windows und Mobilgeräte.

  • Nachdem Sie diese Anwendung auf dem Telefon ausgeführt haben, wird das folgende Fenster angezeigt.

  • Nach dem Ausführen der Fensteranwendung wird die folgende Anwendung angezeigt.

  • Öffnen Sie nun die neu erstellte UWP-Projektanwendung
  • Kopieren Sie den Ordner aus dem freigegebenen Projekt Assets\CoverImagesenthält die Buchcover-Bilddateien (.png). Kopieren Sie auch dieViewModel Ordner und die MainPage.xaml und ersetzen Sie die Datei im Ziel.

  • Kopieren Sie aus dem Windows-Projekt BookstoreStyles.xaml. Alle Ressourcenschlüssel in dieser Datei werden in einer Windows 10-App aufgelöst. Einige davon im ÄquivalentWindowsPhone Datei wird nicht.

  • In dem Solution Explorer, Stelle sicher Show All Files ist umgeschaltet ON.

  • Wählen Sie die Dateien aus, die Sie kopiert haben, klicken Sie mit der rechten Maustaste darauf und klicken Sie auf Include In Project Wie nachfolgend dargestellt.

  • Dies schließt automatisch die enthaltenen Ordner ein. Sie können dann umschaltenShow All Files ‘OFF’ wenn du möchtest.

  • Jetzt sieht Ihre Projektstruktur in so aus Solution Explorer.

  • Bearbeiten Sie den Quellcode und die Markup-Dateien, die Sie gerade kopiert haben, und ändern Sie alle Verweise auf die Bookstore1_81 Namespace zu UWPBookStore Namespace.

  • Am einfachsten ist es, den Namensraum durch zu ersetzen Replace In FilesMerkmal. Im Ansichtsmodell sind keine Codeänderungen erforderlich.

  • Wenn der obige Code ausgeführt wird, können Sie ihn nun auf einem lokalen Computer sowie auf einem Mobiltelefon ausführen, wie unten gezeigt.

Die zweite Möglichkeit besteht nun darin, eine Kopie Ihrer vorhandenen Projektdateien einschließlich des App-Paket-Manifests zu bearbeiten. Die Projektdatei und diepackage.appmanifest Die Datei muss beim Portieren von Windows / Phone 8.x auf Windows 10 geändert werden.

Microsoft hat das Dienstprogramm zur Aktualisierung von UWP-Projekten bereitgestellt, das beim Portieren Ihrer vorhandenen Anwendung sehr hilfreich ist. Das Dienstprogramm kann von github.com heruntergeladen werden .

Wir empfehlen Ihnen, die obigen Beispiele zum besseren Verständnis Schritt für Schritt zu befolgen.