Windows 10 Geliştirme - Hızlı Kılavuz

Bu eğitim, Windows 10 uygulamalarının nasıl geliştirileceğini öğrenmek isteyen kişiler için tasarlanmıştır. Bu eğitimde öğreneceğiz -

  • Windows 10 uygulama geliştirme
  • Microsoft tarafından yayınlanan yeni işletim sisteminin güncellemeleri
  • Güncellemelerde geliştiriciler için yeni özellikler

İlk sürümde bizim için mevcut olmayan birçok ilginç uygulama senaryosu artık mümkün. Microsoft yalnızca yeni API'ler eklemekle kalmadı, mevcut API'leri de genişletti.

Evrensel Windows uygulaması

Bir Evrensel Windows uygulaması ilk olarak Windows 8'de Evrensel Uygulama Platformu üzerine inşa edilen Windows Çalışma Zamanı olarak tanıtıldı.

Şimdi, Windows 10'da Evrensel Uygulama Platformunun adı Evrensel Windows Platformu (UWP) olarak değiştirildi. Windows Mağazası için PC, tablet, telefon vb. Windows 10 cihazlarını hedefleyerek modern ve tamamen sürükleyici uygulamalar oluşturabilirsiniz.

Windows 10'da, Windows 10'da desteklenen tüm cihazlara ulaşmak için uygulamaları kolayca geliştirebilirsiniz.

  • Bir API seti
  • Bir uygulama paketi
  • Ve bir mağaza

Evrensel Windows Platformu ayrıca farklı ekran boyutlarını ve dokunmatik yüzey, fare ve klavye, oyun denetleyicisi veya kalem gibi farklı etkileşim modellerini destekler.

UWP uygulamalarının özellikleri

İşte Evrensel Windows uygulamalarının onu Windows 10'dan üstün kılan özelliklerinden bazıları.

  • Windows 8.1 gibi işletim sistemlerini değil, cihaz ailelerini hedefleyebilirsiniz.

  • Uygulamalar paketlenir ve dağıtılır .AppX Uygulamalarınızın sorunsuz bir şekilde dağıtılmasını ve güncellenmesini sağlayan paketleme biçimi.

  • Uygulamanızı Windows mağazasına gönderebilirsiniz ve tüm cihaz ailelerinde veya yalnızca seçtiğiniz cihazlarda kullanılabilir hale gelecektir. Windows cihazları için tüm uygulamalarınızı tek bir yerden kolayca yönetebilirsiniz.

  • Uygulamanızın kullanılabilirliğini belirli cihaz ailesiyle sınırlandırabilirsiniz.

  • Evrensel Windows Platformunun (UWP) temel API'leri tüm Windows cihaz ailelerinde aynıdır. Dolayısıyla, uygulamanız yalnızca temel API'leri kullanıyorsa tüm Windows 10 cihazlarında çalışabilir.

  • Uzantı SDK'larının yardımıyla, uygulamanızı belirli cihazlar için aydınlatabilirsiniz.

Geliştirme Seçenekleri

Evrensel Windows uygulamaları aşağıdaki dillerden herhangi birinde oluşturulabilir -

  • XAML ile C # veya Visual Basic
  • HTML ile JavaScript
  • DirectX ve / veya XAML ile C ++

Ayrıca bileşenleri tek bir dilde yazabilir ve bunları başka bir dilde geliştirilmiş bir uygulamada kullanabilirsiniz.

Windows Runtime (WinRT), C ++ / CX, C #, VB.NET ve JavaScript'te geliştirmeyi destekleyen, platform açısından homojen bir uygulama mimarisidir. WinRT uygulamaları hem x86 hem de ARM mimarilerini yerel olarak destekler. Bazı önemli özellikler vardır.

  • İlk olarak Eylül 2012'de Windows Server 2012'de tanıtıldı.

  • WinRT API'leri JavaScript, C #, Visual Basic ve C ++ kullanarak tüm temel platform özelliklerine erişim sağlar.

  • WinRT bileşenleri, yerel, yönetilen ve komut dosyası dilleri gibi birden çok dili ve API'yi destekler.

Evrensel Windows Platformu (UWP)

Evrensel Windows uygulaması, ilk olarak Windows 8'de Windows Çalışma Zamanı olarak tanıtılan Evrensel Windows Platformu (UWP) üzerine kurulmuştur. Windows 10'da, Windows Çalışma Zamanı (WinRT) modelini daha da geliştiren Evrensel Windows Platformu (UWP) tanıtıldı.

  • Windows 8.1'de WinRT, ilk kez Windows Phone 8.1 uygulamaları ile Windows 8.1 uygulamaları arasında, paylaşılan bir kod tabanı kullanarak hem Windows telefonunu hem de Windows uygulamasını hedeflemek için Evrensel Windows 8 uygulamalarının yardımıyla uyumlu hale getirildi.

  • Artık Windows Core olarak bilinen Windows 10 Unified Core, UWP'nin artık Windows 10 üzerinde çalışan her cihazda kullanılabilen ortak bir uygulama platformu sağladığı bir noktaya ulaştı.

  • UWP yalnızca tüm cihazlarda ortak olan WinRT API'lerini değil, aynı zamanda uygulamanın çalıştığı cihaz ailesine özgü API'leri (Win32 ve .NET API'leri dahil) çağırabilir.

Windows 10 Tarafından Desteklenen Cihazlar

Windows 8.1 ve Windows Phone 8.1 uygulamaları bir işletim sistemini hedefler; Windows veya Windows Phone. Windows 10 uygulamaları bir işletim sistemini hedeflemez, ancak bir veya daha fazla cihaz ailesini hedefler.

Cihaz ailelerinin de, söz konusu cihaz ailesi için işlevsellik ekleyen kendi API'leri vardır. Bir cihaz ailesi içinde, uygulamalarınızın yüklenebileceği ve çalıştırılabileceği tüm cihazları Windows Mağazasından kolayca belirleyebilirsiniz. Aygıt ailesinin hiyerarşik temsili burada.

UWP'nin avantajları

Evrensel Windows Platformu (UWP), geliştiriciler için bir dizi şey sağlar. Onlar -

  • Tüm cihazlar için Tek İşletim Sistemi ve Tek Birleşik Çekirdek.
  • Her ailede uygulamaları çalıştırmak için Tek Uygulama Platformu.
  • Başvuru ve kontrol paneli göndermek için bir Geliştirme Merkezi.
  • Tüm cihazlar için Tek Mağaza.

UWP Geliştirme için Kurulum

Windows 10 için kendi Evrensel Windows Platformu (UWP) uygulamalarınızı oluşturmaya başlamak için aşağıdaki adımların izlenmesi gerekir.

  • Windows 10 OS- UWP uygulamalarının geliştirilmesi için Windows'un en son sürümüne ihtiyacı vardır. Windows 8.1'de de UWP uygulamaları geliştirebilirsiniz, ancak UI tasarımcısı Penceresi için destek yoktur.

  • Windows 10 developer tools- Visual studio 2015'te, UWP uygulamalarınızı tasarlayabilir, kodlayabilir, test edebilir ve hatalarını ayıklayabilirsiniz. Ücretsiz Microsoft Visual Studio Community 2015'i şu adresten indirebilir ve yükleyebilirsiniz:https://dev.windows.com/en-us/downloads

  • Enable development mode for Windows 10 -

    • Git Start > Settings.

    • Seçiniz Update & security.

    • Sonra seçin "For developers".

    • Tıkla Developer mode

UWP uygulamaları için, uygulamalarınızı cihazlarda test etmeniz önemlidir.

  • Register as an app developer- Uygulamaları geliştirmeye başlayabilirsiniz, ancak uygulamalarınızı mağazaya göndermek için bir geliştirici hesabına ihtiyacınız vardır. Geliştirici hesabınızı buradan oluşturabilirsinizhttps://msdn.microsoft.com/enus/library/windows/apps/bg124287.aspx

Yukarıdaki adımları izledikten sonra, artık bir Evrensel Windows Platformu (UWP) uygulamasının geliştirilmesine başlamaya hazırsınız.

Bu bölümde, ilk basit uygulamamızı oluşturacağız "Hello world" Windows 10'da XAML ve C # kullanan Evrensel Windows Platformunda (UWP). Visual Studio'da oluşturulan tek bir UWP uygulamasının herhangi bir Windows 10 cihazında nasıl çalıştırılabileceğini ve yürütülebileceğini göstereceğiz.

Aşağıda verilen adımları takip ederek Uygulamayı oluşturmaya başlayalım.

  • Visual Studio 2015'i başlatın.

  • Tıkla File menü ve seçin New > Project.

  • Aşağıdaki New Projectiletişim penceresi görüntülenecektir. İletişim kutusunun sol bölmesinde farklı şablon türlerini görebilirsiniz.

  • Sol bölmede ağaç görünümünü görebilirsiniz. SeçinizUniversal template itibaren Templates > Visual C# > Windows.

  • Orta bölmeden, Blank App (Universal Windows) şablon

  • Yazarak projeye bir isim verin UWPHelloWorld içinde Name field.

  • Tıklayın OK yeni bir UWP projesi oluşturmak için.

  • Yeni oluşturulan projeyi şurada görebilirsiniz: Solution Explorer.

  • Bu boş bir uygulamadır, ancak herhangi bir UWP uygulaması için minimum gereksinim olan birçok dosya içerir.

  • MainPage.xaml ve MainPage.xaml.cs uygulamanızı çalıştırdığınızda çalıştırın.

  • Varsayılan olarak, MainPage.xaml dosyası aşağıdaki bilgileri içerir.

<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>
  • Aşağıda verilen varsayılan bilgilerdir 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(); 
      } 
   } 
	
}
  • Aşağıdaki XAML kodunda gösterildiği gibi bazı Metin Blokları, bir metin kutusu ve bir düğme ekleyelim.

<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>
  • Aşağıda verilen, C #'daki tıklama-olay düğmesidir.
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”; 
      } 
		
   }	
	
}
  • UWP projesinde, device preview seçeneği şurada mevcuttur: Design Window, yardımıyla düzeni kolayca değiştirebileceğiniz, uygulamanız için hedeflediğiniz bir cihaz ailesindeki tüm cihazların ekran boyutuna sığacak şekilde.

  • Uygulamanızı yerel bir makinede, bir simülatörde veya bir emülatörde veya uzak bir cihazda çalıştırabilir ve test edebilirsiniz. Hedef cihazı aşağıdaki menüden aşağıda gösterildiği gibi seçebilirsiniz -

  • Yukarıdaki kodu yerel bir makinede çalıştıralım ve aşağıdaki pencereyi göreceksiniz. Şimdi, metin kutusuna herhangi bir ad yazın ve düğmeyi tıklayınClick Me.

  • Şimdi, uygulamanızı bir emülatörde test etmek istiyorsanız, menüden belirli bir emülatörü seçebilir ve uygulamanızı çalıştırabilirsiniz. Aşağıdaki emülatörü göreceksiniz -

Yukarıdaki uygulamayı farklı cihazlarla çalıştırmanızı tavsiye ederiz.

Windows Mağazası'nın geliştiriciler için avantajı, uygulamanızı satabilmenizdir. Her cihaz ailesi için tek bir başvurunuzu gönderebilirsiniz.

  • Windows 10 Mağazası, bir kullanıcının uygulamanızı bulabilmesi için uygulamaların gönderildiği yerdir.

  • Windows 8'de, Mağaza yalnızca uygulama ile sınırlıydı ve Microsoft, Xbox Müzik Mağazası, Xbox Oyun Mağazası vb.

  • Windows 8'de tüm bunlar farklı mağazalardı ancak Windows 10'da buna Windows Mağazası deniyor. Kullanıcıların tüm Windows 10 cihazları için çok çeşitli uygulamaları, oyunları, şarkıları, filmleri, yazılımları ve hizmetleri tek bir yerde bulabilecekleri şekilde tasarlanmıştır.

Para kazanma

Para kazanma, uygulamanızı masaüstü, mobil, tabletler ve diğer cihazlarda satmak anlamına gelir. Biraz para kazanmak için uygulamalarınızı ve hizmetlerinizi Windows Mağazası'nda satmanın çeşitli yolları vardır.

Aşağıdaki yöntemlerden herhangi birini seçebilirsiniz -

  • En basit yol, uygulamanızı ücretli indirme seçenekleriyle mağazaya göndermektir.

  • Kullanıcıların uygulamanızı satın almadan önce sınırlı işlevsellikle deneyebilecekleri Trails seçeneği.

  • Microsoft Advertising ile uygulamalarınıza reklam ekleyin.

Microsoft Advertising

Uygulamanıza Reklamlar eklediğinizde ve bir kullanıcı söz konusu İlanı tıkladığında, reklamveren size parayı ödeyecektir. Microsoft Advertising, geliştiricilerin Microsoft Advertising Network'ten Reklam almasına olanak tanır.

  • Evrensel Windows uygulamaları için Microsoft Advertising SDK, Visual Studio 2015 tarafından yüklenen kitaplıklara dahildir.

  • Visualstudiogallery'den de kurabilirsiniz

  • Artık video ve banner Reklamları uygulamalarınıza kolayca entegre edebilirsiniz.

Uygulamanıza bir banner Reklam eklemek için XAML'de basit bir örneğe göz atalım. AdControl.

  • Adıyla yeni bir Evrensel Windows boş uygulama projesi oluşturun UWPBannerAd.

  • İçinde Solution Explorer, sağ tıklayın References

  • Seçiniz Add References, açacak Reference Manager iletişim.

  • Sol bölmeden şunu seçin: Extensions Evrensel Windows seçeneği altında ve kontrol edin Microsoft Advertising SDK for XAML.

  • Tıklayın OK devam etmek.

  • Aşağıda verilen XAML kodudur. AdControl bazı özelliklerle eklenir.

<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>

Yukarıdaki kod derlendiğinde ve yerel bir makinede yürütüldüğünde, üzerinde MSN başlığının bulunduğu aşağıdaki pencereyi göreceksiniz. Bu başlığa tıkladığınızda MSN sitesini açacaktır.

Ayrıca bir video banneruygulamanızda. Başka bir örneği ele alalım.Show ad düğmesi tıklandığında Xbox One'ın video reklamını oynatacaktır.

Aşağıda, bir düğmenin bazı özellikler ve olaylarla nasıl eklendiğini gösterdiğimiz XAML kodu verilmiştir.

<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>

Aşağıda, C # 'da tıklama etkinliği uygulaması verilmiştir.

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(); 
         } 
      } 
		
   } 
	
}

Yukarıdaki kod derlendiğinde ve yerel bir makinede yürütüldüğünde, aşağıdaki pencereyi göreceksiniz; Show Ad buton.

Şimdi, tıkladığınızda Show Ad düğmesi, videoyu uygulamanızda oynatacaktır.

XAML, Genişletilebilir Uygulama Biçimlendirme Dili anlamına gelir. Bir Kullanıcı Arabirimi çerçevesidir ve Windows için UI geliştirmeyi destekleyen kapsamlı bir denetim kitaplığı sunar. Bazılarının Düğme, Metin Kutusu ve Metin Bloğu gibi görsel bir temsili vardır; diğer kontroller, görüntüler vb. gibi diğer kontroller veya içerikler için kaplar olarak kullanılırken, tüm XAML kontrolleri“System.Windows.Controls.Control”.

XAML Gelişen Hikayesi

XAML, Windows Presentation Foundation (WPF), Silverlight ve şimdi Windows uygulamaları gibi birçok önemli Microsoft platformunda kullanılmaktadır. Artık Microsoft Office 2016 aynı zamanda bir UWP uygulamaları ailesidir. XAML, UWP uygulamalarında kullanılabilecek çok güzel özellikler ve kontroller sağlayan zengin bir Platformdur.

Kontrollerin tam miras hiyerarşisi aşağıda gösterilmektedir.

Düzen Kontrolleri

Denetim Düzeni, uygulamanın kullanılabilirliği için çok önemlidir ve kritiktir. Uygulamanızda bir grup GUI öğesi düzenlemek için kullanılır. Yerleşim panellerini seçerken dikkate alınması gereken bazı önemli şeyler vardır -

  • Alt öğelerin konumları.
  • Alt öğelerin boyutları.
  • Üst üste binen alt öğelerin üst üste katmanlanması.

Listesi Layout Controls aşağıda verilmiştir -

S.No. Kontroller ve Açıklama
1

StackPanel

StackPanelXAML'de basit ve kullanışlı bir düzen panelidir. Yığın panelinde alt öğeler, yönlendirme özelliğine göre yatay veya dikey olarak tek bir satırda düzenlenebilir.

2

WrapPanel

İçinde WrapPanelalt öğeler, oryantasyon özelliğine göre soldan sağa veya yukarıdan aşağıya sıralı sırayla yerleştirilir. StackPanel ve WrapPanel arasındaki tek fark, tüm alt öğeleri tek bir satırda yığınlamaması, ancak kalan öğeleri boşluk kalmadığında başka bir satıra kaydırmasıdır.

3

DockPanel

DockPanelyatay veya dikey olarak alt öğeleri birbirine göre düzenlemek için bir alan tanımlar. DockPanel ile alt öğeleri Dock özelliği ile kolayca yukarı, aşağı, sağa, sola ve ortaya yerleştirebilirsiniz.

İle LastChildFill özelliği, son alt öğe, o öğe için ayarlandığında diğer dock değerlerinden bağımsız olarak kalan alanı doldurur.

4

Canvas

Canvassol, sağ, üst ve alt gibi herhangi bir tarafa göre olan koordinatlar kullanılarak alt öğelerin açıkça konumlandırılabildiği temel düzen panelidir. Tipik olarak Canvas, 2D grafik öğeleri (Elips, Dikdörtgen vb.) İçin kullanılır, ancak UI öğeleri için kullanılmaz çünkü mutlak koordinatların belirtilmesi, bir XAML uygulamasında yeniden boyutlandırma, yerelleştirme veya ölçekleme sırasında sorun yaratır.

5

Grid

Gridsatır ve sütunlardan oluşan esnek bir alan sağlar. Kılavuzda, alt öğeler tablo biçiminde düzenlenebilir. Öğeler, kullanılarak herhangi bir belirli satır ve sütuna eklenebilirGrid.Row ve Grid.Column özellikleri.

6

SplitView

SplitViewiki görünüme sahip bir kabı temsil eder; ana içerik için bir görünüm ve genellikle gezinme komutları için kullanılan başka bir görünüm.

7

RelativePanel

RelativePanel alt nesneleri birbirlerine veya üst panele göre konumlandırabileceğiniz ve hizalayabileceğiniz bir alanı tanımlar.

8

ViewBox

ViewBox tek bir çocuğu mevcut alanı dolduracak şekilde genişletebilen ve ölçekleyebilen bir içerik tasarımcısı tanımlar.

9

FlipView

FlipView her seferinde bir öğeyi görüntüleyen bir öğenin denetimini temsil eder ve öğe koleksiyonunda gezinmek için "çevirme" davranışını etkinleştirir.

10

GridView

GridView satırlar ve sütunlar halinde bir öğe koleksiyonu sunan ve yatay olarak kaydırılabilen bir kontroldür.

UI Kontrolleri

İşte son kullanıcılar tarafından görülebilen UI Kontrollerinin bir listesi.

S.No. UI Kontrolleri ve Tanımı
1

Button

Kullanıcı girdisine yanıt veren bir denetim

2

Calendar

Bir kullanıcının görsel bir takvim görüntüsü kullanarak bir tarih seçmesini sağlayan bir denetimi temsil eder.

3

CheckBox

Bir kullanıcının seçebileceği veya temizleyebileceği bir denetim.

4

ComboBox

Kullanıcıların seçim yapabileceği bir açılır öğe listesi.

5

ContextMenu

Bu öğe içinden kullanıcı arabirimi (UI) aracılığıyla bağlam menüsü istendiğinde görünmesi gereken bağlam menüsü öğesini alır veya ayarlar.

6

DataGrid

Özelleştirilebilir bir kılavuzda verileri görüntüleyen bir denetimi temsil eder.

7

DatePicker

Kullanıcının bir tarih seçmesine izin veren bir denetim.

8

Dialogs

Bir uygulama ayrıca, kullanıcının önemli bilgileri toplamasını veya görüntülemesini sağlayacak ek pencereler görüntüleyebilir.

9

Flyout

Bilgi olan veya kullanıcı etkileşimi gerektiren hafif kullanıcı arabirimini görüntüleyen bir denetimi temsil eder. Bir iletişim kutusundan farklı olarak, bir Açılır Pencere, tıklanarak veya dışarıya dokunarak, cihazın geri düğmesine veya 'Esc' tuşuna basılarak hafif kapatılabilir.

10

Image

Bir görüntü sunan bir kontrol.

11

ListBox

Kullanıcının seçim yapabileceği bir satır içi öğe listesi sunan bir denetim.

12

Menus

Komutlar ve olay işleyicileriyle ilişkili öğeleri hiyerarşik olarak düzenlemenizi sağlayan bir Windows menü denetimini temsil eder.

13

MenuFlyout

Bir komut menüsü görüntüleyen bir açılır pencereyi temsil eder.

14

PasswordBox

Parolaları girmek için bir kontrol.

15

Popup

İçeriği, uygulama penceresinin sınırları içinde mevcut içeriğin üstünde görüntüler.

16

ProgressBar

Bir çubuk görüntüleyerek ilerlemeyi gösteren bir denetim.

17

ProgressRing

Bir zil sesi görüntüleyerek belirsiz ilerlemeyi gösteren bir denetim.

18

RadioButton

Bir kullanıcının bir grup seçenekten tek bir seçeneği seçmesine izin veren bir denetim.

19

RichEditBox

Bir kullanıcının biçimlendirilmiş metin, köprüler ve görüntüler gibi içeriğe sahip zengin metin belgelerini düzenlemesine olanak tanıyan bir denetim.

20

ScrollViewer

Kullanıcının içeriğini kaydırmasına ve yakınlaştırmasına olanak tanıyan bir kapsayıcı denetimi.

21

SearchBox

Bir kullanıcının arama sorguları girmesine izin veren bir denetim.

22

Slider

Kullanıcının bir parça boyunca Başparmak kontrolünü hareket ettirerek bir dizi değer arasından seçim yapmasını sağlayan bir kontrol.

23

TextBlock

Metni görüntüleyen bir kontrol.

24

TimePicker

Bir kullanıcının bir zaman değeri ayarlamasına izin veren bir denetim.

25

ToggleButton

2 durum arasında geçiş yapılabilen bir düğme.

26

ToolTip

Bir öğeye ilişkin bilgileri görüntüleyen bir açılır pencere.

27

Window

Simge durumuna küçültme / büyütme seçeneği, Başlık çubuğu, kenarlık ve kapat düğmesi sağlayan kök pencere.

Aşağıda verilen, farklı türde kontrolleri içeren bir örnektir. SplitView. XAML dosyasında, bazı özellikler ve olaylarla farklı denetimler oluşturulur.

<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>

Aşağıda verilen Events C # ile uygulama.

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; 
      }
		
   }
	
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki pencereyi göreceksiniz -

Sol üst taraftaki hamburger butonuna tıkladığınızda açılıp kapanacaktır. SplitView bölme.

İçinde SplitView Bölme, görebilirsiniz Flyout, MenuFlyout ve FlipView kontroller.

İçinde SplitView İçerik, Köprü, Göreli Panel, ViewBox ve diğer düğmeleri ve metin kutusu kontrollerini görebilirsiniz.

Veri bağlama, verileri görüntülemek ve etkileşimde bulunmak için kısmi sınıflar kullanan Windows Runtime uygulamaları için basit ve kolay bir yol sağlayan XAML uygulamasındaki bir mekanizmadır. Verilerin yönetimi, bu mekanizmada verilerin görüntülenme biçiminden tamamen ayrıdır.

Veri bağlama, kullanıcı arayüzünde UI öğeleri ile veri nesnesi arasında veri akışına izin verir. Bir bağlanma kurulduğunda ve veriler veya iş modeliniz değiştiğinde, güncellemeleri otomatik olarak UI öğelerine yansıtır ve bunun tersi de geçerlidir. Standart bir veri kaynağına değil, sayfadaki başka bir öğeye bağlanmak da mümkündür. Veri bağlama -

  • Tek yönlü veri bağlama
  • İki yönlü veri bağlama
  • Eleman Bağlama

Tek Yönlü Veri Bağlama

Tek yönlü bağlamada, veriler kaynağından (verileri tutan nesne) hedefine (verileri görüntüleyen nesne) bağlanır.

Tek yönlü veri bağlamanın basit bir örneğine bakalım. Aşağıda, bazı özelliklerle dört metin bloğunun oluşturulduğu XAML kodu verilmiştir.

<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>

İki metin bloğunun Metin özellikleri şu şekilde ayarlanmıştır: “Name” ve “Title” statik olarak, metin bloklarının diğer iki Metin özelliği, aşağıda gösterildiği gibi Employee sınıfının sınıf değişkenleri olan “Ad” ve “Başlık” a bağlanır.

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; 
      } 
		
   }  
}

İçinde Employee classdeğişkenlerimiz var Name ve Title ve bir statik yöntemde employee objectbaşlatılır ve bu çalışan nesnesini döndürür. Bu nedenle, mülkiyet, İsim ve Unvan'a bağlıyız, ancak mülkün ait olduğu nesneyi henüz seçmedik. Kolay yol, bir nesneyiDataContext, kimin mülklerini bağlayıcı olduğumuz MainPage Yapıcı.

Bu uygulamayı çalıştırdığınızda, hemen telefonunuzda görebilirsiniz. MainWindow o Çalışan nesnesinin Adına ve Unvanına başarıyla bağlandığınızı.

İki yönlü Veri Bağlama

Two-Way Binding'de kullanıcı, verileri kullanıcı arayüzü aracılığıyla değiştirebilir ve bu verilerin kaynakta güncellenmesini sağlayabilir. Örneğin, kullanıcı görünüme bakarken kaynak değişirse, görünümün güncellenmesini istersiniz.

Bazı özellikler ve olaylarla iki etiket, iki metin kutusu ve bir düğmenin oluşturulduğu aşağıdaki örneğe bir göz atalım.

<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>

Aşağıdakileri gözlemleyebiliriz -

  • Her iki metin kutusunun Metin özellikleri, "Name" ve "Age" sınıf değişkenleri olan Person class Aşağıda gösterildiği gibi.

  • İçinde Person class, sadece iki değişkenimiz var - İsim ve Yaş ve nesnesi MainWindow sınıf.

  • XAML kodunda, özelliğe bağlıyız - Name ve Age, ancak mülkün ait olduğu nesneyi seçmedik.

  • Daha kolay yol, nesneye bir nesne atamaktır. DataContext, özelliklerini aşağıda gösterildiği gibi C # kodunda bağladığımız 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; 
            } 
         } 
      }
		
   } 
	
}

Yukarıdaki kod derlendiğinde ve çalıştırıldığında, aşağıdaki pencereyi göreceksiniz. TıklaDisplay buton.

Adı ve Yaşı değiştirelim ve tıklayın. Display düğmesine tekrar basın.

Bunu tıklama düğmesinde görebilirsiniz ‘Display’, metin kutularının metni, verileri göstermek için kullanılmaz. TextBlock ancak sınıf değişkenleri kullanılır.

Daha iyi anlamak için yukarıdaki kodu her iki durumda da çalıştırmanızı tavsiye ederim.

Eleman Bağlama

Standart bir veri kaynağına değil, sayfadaki başka bir öğeye bağlanmak da mümkündür. Adlı bir uygulama oluşturalımElementBindingburada bir Kaydırıcı ve Dikdörtgenin oluşturulduğu ve kaydırıcıyla dikdörtgen genişliği ve yüksekliği sınırlıdır. Aşağıda, XAML'deki kod verilmiştir.

<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>

Yukarıdaki kod derlendiğinde ve çalıştırıldığında, aşağıdaki pencereyi göreceksiniz.

Bir kaydırıcıyla dikdörtgenin boyutunu aşağıda gösterildiği gibi değiştirebilirsiniz.

Uygulamanızın başlangıçta ne kadar hızlı göründüğü veya bir sonraki içeriği göstermek için gezinmesi gibi uygulamaların performansı çok önemlidir.

Bir uygulamanın performansı, XAML işleme motorunun uygulamanızda sahip olduğunuz tüm XAML kodunu ayrıştırma yeteneği de dahil olmak üzere birçok şeyden etkilenebilir. XAML, UI oluşturmak için çok güçlü bir araçtır, ancak artık Windows 10 uygulamalarında bulunan yeni teknikleri kullanarak daha sağlam olabilir.

Örneğin, uygulamalarınızda, sayfa yüklendiğinde göstermek istediğiniz ve daha sonra ihtiyaç duymayacağınız belirli şeyler vardır. Başlangıçta tüm UI öğelerinin yüklenmesine gerek duymamanız da mümkündür.

Windows 10 uygulamalarında, XAML performansını artıran bazı yeni özellikler XAML'e eklenmiştir.

Herhangi bir Evrensel Windows uygulamasının performansı aşağıdaki tekniklerle iyileştirilebilir;

  • Aşamalı Görüntü Oluşturma
  • Ertelenmiş Yükleme

Aşamalı Görüntü Oluşturma

Windows 10'da, XAML'de iki yeni ve çok güzel özellik tanıtıldı. Onlar -

x: Bağla

Bağlama için kullanılan XAML'de tanıtılan yeni bir sözdizimidir ve neredeyse aynı şekilde çalışır. Binding sözdizimi yapar. x:Bindiki temel fark vardır; derleme zamanı sözdizimi doğrulaması ve daha iyi performans sağlar.

X: Aşama

Bir veri şablonu içinde XAML denetimlerinin oluşturulmasına öncelik verme yeteneği sağlar. Her UI öğesinin yalnızca bir aşaması belirtilebilir. Öyleyse, bu, öğedeki tüm bağlamalar için geçerli olacaktır. Bir faz belirtilmezse, faz 0 varsayılır.

Evrensel Windows Platformu (UWP) uygulamalarında, bu iki yeni özellik performans iyileştirmeleri sağlar. Windows 10'a geçiş yapan mevcut Windows 8.x uygulamalarında da kullanılabilir.

Aşağıda, çalışan nesnelerinin bağlı olduğu bir örnek verilmiştir. GridView kullanarak x:Bind anahtar kelime.

<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>

Yukarıdaki XAML kodunda, x:Phase = "1"Başlık ile tanımlanır. Bu nedenle ilk aşamadaName işlenecek ve sonra Title işlenecek.

Aşağıda verilen Employee class C # ile uygulama.

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; 
      } 
		
   }
	
}

Yukarıda verilen kod çalıştırıldığında aşağıdaki pencereyi göreceksiniz.

X:Phase ile x:Bind render etmek için kullanılır ListView ve GridView öğeleri aşamalı olarak ve kaydırma deneyimini iyileştirir.

Ertelenmiş Yükleme

Ertelenmiş yükleme, bir uygulamanın başlangıcında XAML UI öğelerinin sayısını azaltarak başlangıç ​​yükleme süresini en aza indirmek için kullanılabilen bir tekniktir. Uygulamanız 30 UI öğesi içeriyorsa ve kullanıcı başlangıçta tüm bu öğelere ihtiyaç duymuyorsa, gerekli olmayan tüm bu öğeler erteleyerek yükleme süresinden tasarruf sağlayabilir.

x:DeferLoadStrategy = "Lazy" bir öğenin ve alt öğelerinin oluşturulmasını geciktirir, bu da başlangıç ​​süresini azaltır, ancak bellek kullanımını biraz artırır.

Ertelenen öğe, Calling ile gerçekleştirilebilir / yaratılabilir FindName eleman üzerinde tanımlanan isimle.

Ertelenmiş bir öğe oluşturulduktan sonra, birkaç şey olur -

  • Öğe üzerindeki Yüklendi olayı ortaya çıkacaktır.

  • Öğe üzerindeki tüm bağlamalar değerlendirilecektir.

  • Başvurunun, ertelenen unsur (lar) ı içeren mülkle ilgili mülk değişikliği bildirimlerini almak için kaydedilmesi durumunda bildirim yapılır.

Aşağıda verilen bir örnek verilmiştir. x:DeferLoadStrategy = "Lazy" dört metin bloğu içeren ve siz yükleyene kadar uygulamanızın başlangıcında yüklenmeyecek olan ızgara için kullanılır.

<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>

Aşağıdaki program, kılavuzun uygulama ana sayfasına yüklendiği tıklama olay uygulamasıdır.

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 
      } 
		
   } 
	
}

Yukarıdaki kod yerine getirilip yürütüldüğünde, yalnızca bir düğme göreceksiniz. Textblocks başlangıçta yüklenmez.

Şimdi tıkladığınızda Show Elements düğmesi, uygulamanızın başlangıç ​​performansını artıracak metin bloklarını yükleyecektir.

Windows 10'da, Evrensel Windows Platformu (UWP) uygulamaları artık aşağıdakiler gibi bir dizi cihaz ailesinde çalışacaktır:

  • Desktop device family - Tabletler, dizüstü bilgisayarlar, PC'ler

  • Mobile device family - Windows Telefonları, phablet'ler

  • IoT device family - Giyilebilir cihazlar veya ev aletleri gibi kompakt cihazlar

  • Team device family - Yüzey göbeği

Her cihaz ailesinin kendi ekranı ve pencere boyutu vardır. Peki, önemli ölçüde farklı ekran boyutları ve farklı giriş yöntemleriyle çeşitli cihazlarda harika bir kullanıcı deneyimi sağlayan bir uygulama nasıl tasarlanır?

Uygulamanızı birden çok cihaz ailesi için tasarlamak, bazı ek değerlendirme, planlama ve tasarım gerektirir. Windows 10 UWP, platform kontrolleri tarafından desteklenen, birden çok cihaz için tasarım yapmayı ve farklı ekran ve pencere boyutlarında otomatik olarak ölçeklendirmeyi çok daha kolaylaştıran bir dizi yerleşik özellik ve evrensel yapı taşı sağlar.

Yeni Yerleşik Özellikler

Aşağıda, geliştiricilerin bir UWP uygulaması oluştururken kullanabilecekleri yeni özellikler verilmiştir. Bu özellikler otomatik ve ücretsizdir.

Etkili Pikseller ve Platform Ölçeklendirme

UWP uygulamanız Windows 10 tarafından desteklenen herhangi bir cihazda çalıştığında, o zaman -

  • Sistem, üzerinde çalıştığı bir cihazın ekranında kontrollerin, yazı tiplerinin ve diğer UI öğelerinin görüntülenme şeklini normalleştirmek için bir algoritma kullanır.

  • Ölçekleme algoritması, varsayılan boyutu (fiziksel boyut yerine) optimize etmek için görüntüleme mesafesini ve ekran yoğunluğunu (inç başına piksel) kontrol eder.

  • Ölçekleme algoritması, 10 fit uzaklıktaki Surface Hub'daki 36 piksellik bir yazı tipinin, birkaç inç uzaklıktaki 5 '' telefondaki 36 piksel yazı tipi kadar kullanıcı tarafından okunabilir olmasını sağlar.

Evrensel Girdi ve Akıllı Etkileşimler

Evrensel Windows Platformu, tüm cihazlar için girdiyi anlayan yerleşik akıllı etkileşim giriş sistemlerine sahiptir. Örneğin, uygulamanızda bir tıklama etkileşimi tasarladığınızda, tıklamanın gerçek bir fare tıklamasından mı yoksa bir parmak dokunuşundan mı geldiğini bilmenize gerek yoktur. Sistem bunu sizin için otomatik olarak yapacaktır.

Evrensel Yapı Taşları

Evrensel Windows Platformunda (UWP) birden çok cihaz ailesi için uygulamaları tasarlamayı kolaylaştıran bazı değerli yapı taşları vardır.

Evrensel Kontroller

UWP, tüm Windows 10 cihazlarında iyi çalışması garanti edilen bir dizi Evrensel Kontrol sağlar.

  • Bu 'Evrensel kontroller' listesi, radyo düğmesi, birleşik giriş kutusu ve metin kutusu gibi yaygın kontrolleri içerir.

  • Ayrıca, aşağıdaki gibi bazı gelişmiş kontroller içerir: grid view ve list view bir veri akışından ve bir şablondan bir öğe listesi oluşturabilir.

Evrensel Stiller

UWP uygulaması, size şu özellikleri sağlayan varsayılan bir stil grubunu otomatik olarak alır -

  • Uygulamanıza otomatik olarak açık veya koyu bir tema veren bir dizi stil.

  • Etkileşimler için varsayılan animasyonlar.

  • Yüksek kontrastlı modlar için otomatik destek.

  • Diğer diller için otomatik destek. Varsayılan stillerimiz, Windows'un desteklediği her dil için doğru yazı tipini otomatik olarak seçer. Aynı uygulamada birden fazla dil bile kullanabilirsiniz ve bunlar düzgün bir şekilde görüntülenecektir.

Evrensel Windows Platformu (UWP) uygulaması birçok farklı cihazda çalışabilir ve her cihazın kendi giriş biçimi, ekran çözünürlükleri, DPI yoğunluğu ve diğer benzersiz özellikleri vardır.

Windows 10'da, yeni evrensel kontroller, düzen panelleri ve araçların yardımıyla, kullanıcı arayüzünüzü uygulamanızın üzerinde çalışabileceği cihazlara kolayca uyarlayabilirsiniz. Örneğin, UWP uygulamanız bir masaüstü bilgisayarda, bir mobil cihazda veya bir tablette çalışırken, kullanıcı arayüzünü farklı ekran çözünürlüğü, ekran boyutları ve DPI yoğunluğundan yararlanacak şekilde uyarlayabilirsiniz.

Windows 10'da, aşağıdaki özelliklerle kullanıcı arayüzünüzü birden çok cihaza kolayca hedefleyebilirsiniz:

  • Evrensel kontrolleri ve düzen panellerini kullanarak kullanıcı arayüzünüzü farklı ekran çözünürlükleri ve ekran boyutları için geliştirebilirsiniz.

  • Ortak giriş işleme, bir dokunmatik yüzey, kalem, fare, klavye veya Microsoft Xbox denetleyicisi gibi bir denetleyici aracılığıyla girdi almanıza olanak tanır.

  • Araçlar yardımıyla, farklı ekran çözünürlüklerine uyum sağlayabilen uygulama kullanıcı arayüzünüzü tasarlayabilirsiniz.

  • Uyarlanabilir ölçekleme, cihazlar arasındaki çözünürlük ve DPI farklılıklarına göre ayarlanır.

Windows 10'da, uygulamaları istediğiniz şekilde kolayca düzenleyebilir, yeniden boyutlandırabilir ve konumlandırabilirsiniz. Ayrıca, kullanıcıya uygulamanızı istedikleri şekilde kullanma konusunda bir tür esneklik sağlar. Windows 10'da, UWP uygulamanızda duyarlı teknikler uygulamanın çeşitli yolları vardır, bu nedenle ekran veya pencere boyutu ne olursa olsun harika görünür.

VisualStateManager

Windows 10'da VisualStateManagerclass, yardımıyla UWP uygulamalarınızda duyarlı bir tasarım uygulayabileceğiniz iki yeni mekanizmaya sahiptir. YeniVisualState.StateTriggers geliştiricinin pencere yüksekliği veya pencere genişliği gibi belirli koşulları ve ardından VisualState.Setters API'ler, bu belirli koşullara yanıt olarak görsel durumları tanımlar.

Yığın paneline bazı kontrollerin eklendiği aşağıda verilen örneğe göz atalım.

<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>

Şimdi VisualStateManager, yığın panelinin yönünü pencerenin genişliğine göre ayarlayacaktır. Genişlik> = 720 ise, yönlendirme Yatay olur, aksi takdirde dikey kalır. Yukarıdaki kod derlendiğinde ve çalıştırıldığında, dikey sırada üç metin bloğu içeren aşağıdaki pencereyi göreceksiniz.

Yukarıdaki pencerenin genişliğini yeniden boyutlandıralım ve aşağıdaki pencereyi göreceksiniz -

Artık metin bloklarının yatay sırada olduğunu görebilirsiniz.

GöreliPanel

RelativePanelöğeler arasındaki uzamsal ilişkileri ifade ederek UI öğelerini düzenlemek için kullanılabilir. Göreli panelde bazı dikdörtgenlerin oluşturulduğu bir örnek alalım.

<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>

Yukarıdaki kod derlendiğinde ve çalıştırıldığında, aşağıdaki pencereyi göreceksiniz.

Yukarıdaki pencereyi yeniden boyutlandırdığınızda, yeşil dikdörtgenin şimdi üst satırda mavi dikdörtgenin solunda gösterildiği gibi ayarlandığını göreceksiniz.

Bu bölümde, uygulamanızın Windows 10 tarafından desteklenen farklı cihazlara nasıl uyarlandığını göstereceğiz. Kullanıcı arayüzünüzü ve UWP uygulamalarında kullanılan tüm püf noktaları, teknikleri ve kontrolleri benimsemeyi zaten öğrendik.

Şimdi, kodunuzu nasıl benimsemeyi öğreneceğiz çünkü

  • Uygulama kodları tüm cihazlarda aynı değildir.

  • Özellikle Xbox için kullanılan API'ler mobil cihazlarda kullanılamayacaktır. Aynı şey HoloLens vb. İçin de geçerlidir.

Adaptive kod, uygulamanızı koşullu olarak aydınlatabilir ve kodu yalnızca belirli bir cihaz ailesinde ve / veya platform / uzantı API'lerinin belirli bir sürümünde çalışırken çalıştırabilir.

Kod Yazma

Windows 10'da, C ++, C #, Visual Basic veya JavaScript kullanarak UWP uygulamalarını Visual Studio'da uygulayabilirsiniz.

  • C # ve Visual Basic ile, UI tasarımı için XAML kullanabilirsiniz.

  • C ++ ile XAML kullanmak yerine DirectX'i kullanabilirsiniz.

  • JavaScript için, çapraz platform Web standartları olan sunum katmanınız için HTML kullanabilirsiniz.

Windows Core API'leri, kodunuz ve kullanıcı arayüzünüz için ihtiyaç duyduğunuz işlevlerin çoğunu içeren tüm cihazlar için aynı şekilde çalışır. Bununla birlikte, belirli cihaz aileleri için uyarlanmış kod ve kullanıcı arabirimi için, uyarlanabilir kodu ve uyarlanabilir kullanıcı arabirimini kullanmanız gerekir.

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

Kullanıcı arayüzü farklı ekranlara kolayca uyum sağlar, ancak farklı cihaz aileleri yalnızca farklı ekran boyutlarına sahip olmakla kalmaz, bundan çok daha fazlasına sahiptir.

  • Örneğin, cep telefonlarında Geri ve Kamera gibi bazı donanım düğmeleri bulunur ve bunlar PC gibi diğer cihazlarda bulunmayabilir.

  • Varsayılan olarak, temel API'ler, tüm cihazlar için çalışan işlevselliğin çoğunu içerir, ancak cihaza özgü işlevsellik, tıpkı harici montajlar gibi UWP uygulamalarınızdaki Uzantı SDK'larına referans verilerek kullanılabilir.

Uygulamanızda ihtiyaç duyulan belirli bir uzantı SDK'sını eklemek için, aşağıda verilen adımları izleyin -

  • Sağ tıklayın References.

  • Seçiniz “Add References..”. Aşağıdaki iletişim kutusu açılacaktır.

  • Bir uzantı eklemek, bir proje referansı eklemek kadar basittir.

  • Artık listeden Masaüstü Uzantısı, IoT Uzantısı ve Mobil Uzantı vb. İçeren herhangi bir uzantı SDK'sını ekleyebilirsiniz.

Masaüstü ve Mobil uzantılar, en yaygın iki platform Uzantı SDK'sıdır. Örneğin Mobil uzantı, donanım kamera düğmesini kullanmak için gerekli API'leri etkinleştirir.

Cihaz özelliklerini kontrol etmek için Windows.Foundation.Metadata.ApiInformationmevcut cihazda tür destekleniyorsa bir Boole çıkışı döndüren sınıf yöntemi. Örneğin, Windows uygulamanızın Kamera düğmesini bunun gibi bir kodla kullanmasını sağlayabilirsiniz -

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

Telefon kamera düğmesi kodu, yalnızca cihazda Mobil Uzantı SDK'sı etkinse yürütülür. Benzer şekilde, mevcut API sürümündeki belirli bir olay, yöntem veya özelliği kullanarak da kontrol edebilirsiniz.IsEventPresent, IsMethodPresent, IsPropertyPresent, onun yerine IsTypePresent Aşağıda gösterildiği gibi.

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

UWP'deki Win32 API'leri

C ++ / CX ile yazılmış bir Universal Widows Platform (UWP) uygulaması veya Windows Runtime Component, artık UWP'nin bir parçası olan Win32 API'lerine erişebilir. Windows 10 cihaz ailelerinin tümü, uygulamanızı birbirine bağlayarak Win32 API'lerini uygulayabilir.Windowsapp.lib.

Windowsapp.libUWP API'leri için dışa aktarım sağlayan bir "şemsiye" kitaplıktır. BağlanıyorWindowsapp.lib uygulamanıza bağımlılıklar eklenecek dlls tüm Windows 10 cihaz ailelerinde mevcut.

Uygulamanın hem masaüstünü hem de telefonu hedeflediği basit bir örneğe bakalım. Bu nedenle, uygulama masaüstünde çalıştığında durum çubuğunu göstermeyecek, ancak aynı uygulama telefonda çalıştığında durum çubuğunu gösterecektir.

Aşağıda, farklı kontrollerin eklendiği XAML kodu verilmiştir.

<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>

Aşağıda, farklı olaylar için C # uygulaması verilmiştir.

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); 
         } 
      } 
   } 
}

Yukarıdaki kod derlendiğinde ve bir Mobil cihazda çalıştırıldığında, aşağıdaki pencereyi göreceksiniz.

Durum çubuğunun arka plan rengini, görüntüde gösterildiği gibi onay kutusu ile değiştirebilirsiniz.

Durum çubuğunu da gizleyebilirsiniz.

Şimdi, aynı uygulamayı bir masaüstü cihazda çalıştırdığınızda, durum çubuğunun ve durum çubuğuna özgü onay kutularının görünmediği aşağıdaki pencereyi göreceksiniz.

Herhangi bir uygulamada, en önemli şeylerden biri verilerdir. Eğer sen.net geliştirici, yalıtılmış depolama hakkında bilgi sahibi olabilirsiniz ve aynı kavram Evrensel Windows Platformu (UWP) uygulamaları aracılığıyla gerçekleşir.

Dosya Konumları

Bunlar, uygulamanızın verilere erişebileceği alanlardır. Uygulama, belirli bir uygulamaya özel olan ve diğerlerine erişilemeyen bir alan içerir, ancak verilerinizi bir dosya içinde saklayabileceğiniz ve kaydedebileceğiniz birçok başka alan vardır.

Aşağıda, her klasörün kısa açıklamaları verilmiştir.

S.No. Klasör ve Açıklama
1

App package folder

Paket yöneticisi, uygulamanın tüm ilgili dosyalarını Uygulama paketi klasörüne yükler ve uygulama yalnızca bu klasördeki verileri okuyabilir.

2

Local folder

Uygulamalar yerel verileri yerel bir klasörde depolar. Depolama cihazında sınıra kadar veri depolayabilir.

3

Roaming folder

Uygulamayla ilgili ayarlar ve özellikler dolaşım klasöründe saklanır. Diğer cihazlar da bu klasördeki verilere erişebilir. Uygulama başına 100 KB'a kadar sınırlı boyuta sahiptir.

4

Temp Folder

Geçici depolamanın kullanımı ve uygulamanız yeniden çalıştığında hala kullanılabilir olacağına dair bir garanti yoktur.

5

Publisher Share

Aynı yayıncıdan tüm uygulamalar için paylaşılan depolama. Uygulama manifestinde beyan edildi.

6

Credential Locker

Parola kimlik bilgisi nesnelerinin güvenli depolanması için kullanılır.

7

OneDrive

OneDrive, Microsoft hesabınızla birlikte gelen ücretsiz çevrimiçi depolamadır.

8

Cloud

Verileri bulutta depolayın.

9

Known folders

Bu klasörler Resimlerim, Videolar ve Müzik gibi zaten bilinen klasörlerdir.

10

Removable storage

USB depolama cihazı veya harici sabit sürücü vb.

Dosya İşleme API'leri

Windows 8'de, dosya işleme için yeni API'ler tanıtıldı. Bu API'ler şurada bulunur:Windows.Storage ve Windows.Storage.Streamsad alanları. Bunun yerine bu API'leri kullanabilirsiniz.System.IO.IsolatedStoragead alanı. Bu API'leri kullanarak, Windows Phone uygulamanızı Windows Mağazası'na taşımak daha kolay olacaktır ve uygulamalarınızı Windows'un gelecekteki sürümlerine kolayca yükseltebilirsiniz.

Yerel, dolaşım veya geçici klasörlere erişmek için bu API'leri çağırmanız gerekir -

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

Yerel bir klasörde yeni bir dosya oluşturmak için aşağıdaki kodu kullanın -

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

İşte yeni oluşturulan dosyayı açmak ve bu dosyaya bir miktar içerik yazmak için kod.

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

Aynı dosyayı, aşağıda verilen kodda gösterildiği gibi yerel klasörden tekrar açabilirsiniz.

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); 
   } 
	
}

Verilerin okunmasının ve yazılmasının nasıl çalıştığını anlamak için basit bir örneğe bakalım. Aşağıda, farklı kontrollerin eklendiği XAML kodu verilmiştir.

<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>

Aşağıda, farklı olaylar için C # uygulaması ve ayrıca FileHelper metin dosyasına veri okumak ve yazmak için sınıf.

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; 
      } 
   } 
}

Yukarıdaki kod derlendiğinde ve çalıştırıldığında, aşağıdaki pencereyi göreceksiniz.

Şimdi, metin kutusuna bir şey yazıp “Write Data to File”buton. Program, verileri yerel bir klasördeki metin dosyasına yazacaktır. Eğer tıklarsan“Read Data from File” düğmesine tıklandığında, program verileri yerel klasörde bulunan aynı metin dosyasından okuyacak ve metin bloğu üzerinde gösterecektir.

Çoğu uygulamada, birbirleriyle bir tür ilişki içinde olan belirli veri türleri vardır. Bir dosyada saklanması zor olan bu tür veriler bir veritabanında saklanabilir.

Herhangi bir uygulamadaki SQL sunucusu veya Oracle veritabanları gibi veritabanı türlerine aşina iseniz, anlaşılması çok kolaydır SQLite database.

SQLite nedir?

SQLite, bağımsız, sunucusuz, sıfır konfigürasyonlu, işlemsel SQL veritabanı motorunu uygulayan bir yazılım kitaplığıdır.

Önemli özellikler -

  • SQLite, dünyadaki en yaygın kullanılan veritabanı motorudur.

  • SQLite için kaynak kodu Açık kaynak kodludur.

  • Taşınabilirliği ve az yer kaplaması nedeniyle oyun ve mobil uygulama geliştirme üzerinde büyük bir etkisi oldu.

SQLite'ın Avantajları

Aşağıdakiler SQLite'ın avantajlarıdır -

  • Çok hafif bir veritabanıdır.
  • Platformdan bağımsızdır ve tüm platformlarda çalışır.
  • Küçük bir bellek ayak izine sahiptir.
  • Güvenilirdir.
  • Herhangi bir kurulum ve kuruluma gerek yok.
  • Bağımlılığı yoktur.

Kullanmak SQLite Evrensel Windows Platformu (UWP) uygulamalarınızda aşağıda verilen adımları izlemeniz gerekir.

  • Adıyla yeni bir Evrensel Windows boş uygulaması oluşturun UWPSQLiteDemo.

  • Şuraya git Toolsmenüsüne gidin ve Uzantılar ve Güncellemeler'i seçin. Aşağıdaki iletişim kutusu açılacaktır.

  • Uzantıları ve Güncellemeleri seçtikten sonra, aşağıdaki pencere açılacaktır.
  • Şimdi seçin Online sol bölmeden SQLite seçeneğini arayın.

  • Evrensel Uygulama Platformu için SQLite'ı indirin ve yükleyin.

  • Şimdi, Araçlar menüsüne tekrar gidin ve NuGet Package Manager > Package Manager Console menü seçeneği aşağıda gösterildiği gibidir.

  • Paket Yöneticisi Konsoluna aşağıdaki komutu yazın ve bu komutu yürütmek için enter tuşuna basın -

Install-Package SQLite.Net-PCL

  • Şimdi sağ tıklayın References çözüm gezgininde ve seçin Add References.

  • Aşağıdaki iletişim kutusu açılacaktır.
  • Seçiniz Extensions sol bölmeden altında Universal Windows, orta bölmedeki Evrensel Uygulama Platformu için SQLite'ı işaretleyin ve Tamam'ı tıklayın.

  • Artık UWP uygulamalarınızda SQLite kullanmaya hazırsınız.

Aşağıdaki kodu kullanarak bir veritabanı oluşturabilirsiniz.

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);

Bir masa oluşturmak için aramanız gerekir CreateTable tablo adı nesnesine sahip yöntem.

conn.CreateTable<Customer>();

Aşağıdaki kodu kullanarak verileri tablonuza ekleyebilirsiniz.

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

Tablodan veri almak için kod aşağıda verilmiştir.

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; 
}

Basit bir örnek yardımıyla nasıl veritabanı, tablo oluşturulacağını ve veritabanından verilerin nasıl eklenip alınacağını anlayalım. İsim ve yaş ekleyeceğiz ve ardından aynı verileri tablodan alacağız. Aşağıda, farklı kontrollerin eklendiği XAML kodu verilmiştir.

<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>

Aşağıda, olaylar için C # uygulaması verilmiştir ve 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; } 
   } 
	
}

Yukarıdaki kod derlendiğinde ve çalıştırıldığında, aşağıdaki pencereyi göreceksiniz.

Giriş Name ve Age ve tıklayın Add buton.

Şimdi tıklayın Retrievebuton. Aşağıdaki verileri şurada göreceksiniz:Text Block.

Kimlik alanı, Müşteri sınıfında belirtilen bir Birincil Anahtar ve Otomatik Artış alanıdır.

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

Uygulamadan uygulamaya iletişim, uygulamanızın aynı cihazda yüklü başka bir uygulama ile konuşabileceği veya iletişim kurabileceği anlamına gelir. Bu, Evrensel Windows Platformu (UWP) uygulamasında yeni bir özellik değildir ve Windows 8.1'de de mevcuttur.

Windows 10'da, aynı cihazdaki uygulamalar arasında kolayca iletişim kurmanın bazı yeni ve geliştirilmiş yolları tanıtıldı. İki uygulama arasındaki iletişim aşağıdaki şekillerde olabilir -

  • Bazı verilerle başka bir uygulamayı başlatan bir uygulama.
  • Uygulamalar, hiçbir şey başlatmadan basitçe veri alışverişi yapıyor.

Uygulamadan uygulamaya iletişimin temel avantajı, uygulamaları daha küçük parçalara bölebilmenizdir; bu, kolayca korunabilir, güncellenebilir ve tüketilebilir.

Uygulamanızı Hazırlama

Aşağıda verilen adımları takip ederseniz, diğer uygulamalar uygulamanızı başlatabilir.

  • Uygulama paketi bildirimine bir protokol bildirimi ekleyin.

  • Çift tıklayın Package.appxmanifest Dosya, aşağıda gösterildiği gibi Çözüm Gezgini'nde mevcuttur.

  • Şuraya git Declaration sekmesine gidin ve aşağıda gösterildiği gibi protokolün adını yazın.

  • Sonraki adım, activation kod, böylece uygulama diğer uygulama tarafından başlatıldığında uygun şekilde yanıt verebilir.

  • Protokol etkinleştirmelerine yanıt vermek için, OnActivatedaktivasyon sınıfının yöntemi. Öyleyse, aşağıdaki kodu ekleyinApp.xaml.cs dosya.

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(); 
		
   } 
}
  • Uygulamayı başlatmak için basitçe Launcher.LaunchUriAsync Bu yöntemde belirtilen protokol ile uygulamayı başlatacak yöntem.

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

Bunu, iki UWP uygulamasına sahip olduğumuz basit bir örnekle anlayalım. ProtocolHandlerDemo ve FirstProtocolHandler.

Bu örnekte, ProtocolHandlerDemo uygulama bir düğme içerir ve düğmeye tıklandığında, FirstProtocolHandler uygulama.

ProtocolHandlerDemo uygulamasında bir düğme içeren XAML kodu aşağıda verilmiştir.

<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>

Aşağıda, düğme tıklama olayının uygulandığı C # kodu verilmiştir.

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")); 
      }
		
   }
}

Şimdi şuna bir göz atalım FirstProtocolHandleruygulama tablosu. Aşağıda, bazı özelliklerle bir metin bloğunun oluşturulduğu XAML kodu verilmiştir.

<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>

C # uygulaması App.xaml.cs hangi dosyada OnActicatedgeçersiz kılınan aşağıda gösterilmiştir. Aşağıdaki kodu App sınıfının içine ekleyin.App.xaml.cs dosya.

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(); 
   } 
}

Derleyip çalıştırdığınızda ProtocolHandlerDemo bir emülatörde uygulama, aşağıdaki pencereyi göreceksiniz.

Şimdi, düğmeye tıkladığınızda, FirstProtocolHandler aşağıda gösterildiği gibi.

Windows, dünya çapında çeşitli farklı pazarlarda ve kültür, bölge veya dil açısından farklılık gösteren hedef kitleler için kullanılmaktadır. Yerelleştirme, uygulamanın desteklediği belirli kültürler için uygulama kaynaklarının yerelleştirilmiş sürümlere dönüştürülmesidir.

Herhangi bir uygulamayı tek bir dilde geliştirdiğinizde, bu sadece işinizi ve müşterilerinizi sınırlandırdığınız anlamına gelir. İşinizi de artıracak müşteri tabanınızı genişletmek istiyorsanız, uygulamanızın dünya çapında erişilebilir ve ulaşılabilir olması gerekir. Ürününüzün uygun maliyetli yerelleştirilmesi, daha fazla müşteriye ulaşmanın en iyi ve en ekonomik yollarından biridir.

Windows 10'da, yerelleştirilebilir uygulamaların oluşturulması çok kolaydır resx dosyası, yerelleştirme için en basit çözümdür.

Bunu, aşağıda belirtilen tüm adımları izleyerek basit bir örnek yardımıyla anlayalım.

UI Kaynaklarını Çevirme

Kullanıcı arabiriminiz için dize kaynaklarını kaynağa (resw) doğrudan kod veya biçimlendirmeye koymak yerine dosyaları ve ardından bu dizelere kodunuzdan veya biçimlendirmenizden başvurabilirsiniz. Kaynak dosyalarına dizeler eklemek için aşağıda verilen adımları izleyin.

  • Yeni bir Evrensel Windows Platformu (UWP) uygulaması oluşturun.

  • İçinde Solution Explorer, projeye sağ tıklayın ve Add > New Folder.

  • Yeni klasörün adını şu şekilde değiştirin: "Strings".

  • Sağ tıklayın Strings klasör ve "adıyla yeni bir klasör ekleyin"en-US". Bunlar, bir dile ve ülke / bölge adına özgü adlandırma kurallarıdır ve Ulusal Dil Desteği (NLS) API Başvurusu msdn.microsoft.com sayfasında bulunabilir.

  • Sağ tıklayın en-US klasör ve seçin Add > New Item….

  • Aşağıdaki iletişim kutusu açılacaktır.
  • Seçiniz "Resources File (.resw)" ve tıklayın Add buton.

  • Şimdi XAML dosyasına gidelim ve aşağıda gösterildiği gibi bazı özelliklere sahip bir Hub kontrolü ekleyelim.

<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" yerelleştirme için kullanılan tanımlayıcılardır

  • Şimdi, yukarıdaki kod derlendiğinde ve çalıştırıldığında, aşağıdaki pencereyi göreceksiniz.

Başlık, Ön Plan ve arka plan rengi gibi Hub ile ilgili tüm bilgiler XAML'de ayarlanır.

  • Şimdi bazı bilgileri ekleyin Resource.resw dosyadaki Strings/en-US klasörü aşağıda gösterildiği gibi.

  • Yerelleştirilmiş metin gerektiren her denetimi.reswdosya. Bunu kullanarak yapabilirsinizx:Uid XAML öğelerinizde bunun gibi öznitelik -

    • x:Uid = "HubControl" kullanılır resw dosya, başlık, ön plan ve arka plan rengi için bir dize atamak için.

  • Şimdi, uygulamanızı bir emülatörde derleyip çalıştırdığınızda, aşağıdaki pencereyi göreceksiniz. Başlık, ön plan ve arka plan renk değerlerininResources.resw dosya.

  • Başka ekleyebilirsiniz Resource.resw İngilizce-ABD için yaptığımız gibi, Fransızca, Almanca ve Japonca vb. gibi diğer diller için dosyalar manuel olarak, ancak Microsoft ayrıca Multilingual App Toolkit yardımıyla, kolayca çevirebilirsiniz. Resource.resw diğer dillere.

  • Şuraya git Tools > Extensions ve Güncelle menüsüne gidin ve Multilingual app araç seti.

  • Bu araç setini indirin ve kurun. Yükleme tamamlandığında, Visual Studio'yu yeniden başlatın ve aynı projeyi açın.

  • Şimdi bu araç setini Tools > Multilingual App Araç Seti menü seçeneği.

  • Artık diğer diller için çeviri ekleyebilirsiniz.

  • Projeye sağ tıklayın Solution Explorer ve seçin Multilingual App Toolkit > Add Translation Menüden dil seçeneği.

  • Aşağıdaki Translation Languagesiletişim kutusu açılacaktır. Uygulamanızı bu kültürlere göre yerelleştirmek için istediğiniz herhangi bir dili seçebilirsiniz.

  • Seçelim German dil ve tıklayın OK buton.

  • Ayrıca şunu da görebilirsiniz: Resources.resw dosya klasörün içinde oluşturulur Strings\de.

  • Şimdi bir başkasını göreceksin MultiLingualResources içine eklenir *.xlfdosya. Bu dosyaya çift tıklayın,Multilingual Editör çevrilmiş dizeleri kontrol edip doğrulamak ve gerekirse bazı değişiklikler yapmak için.

  • Değişiklikleri yapın ve Arka Plan renginin kahverengiye dönüp dönmediğini ve Başlık metninin Almancaya doğru şekilde çevrilip çevrilmediğini doğrulayın.

  • Yukarıdaki örnekte olduğu gibi, Hub'ın arka plan rengi mavi renkten kahverengiye değişmiş ve ön plan rengi aynı kalmıştır.

  • Şimdi açın Resources.reswiçinde olan Strings\de Klasör.

  • Burada sadece iki dizeden bahsedildiğini görebilirsiniz, çünkü çok dilli düzenleyicide ön plan rengini değiştirmedik.

Uygulamanızın yerelleştirilmiş sürümünü kontrol etmek için makinenizin kültürünü değiştirin. Makinenizin kültürünü değiştirmek için verilen adımları izleyin.

  • PC ayarlarına gidip Zaman ve Dil'i seçelim.
  • Sol bölmeden şunu seçin: Regions & language ve tıklayın Add a language.

  • Seçiniz Deutsch German yukarıda gösterildiği gibi başka bir iletişim kutusu açacaktır.

  • Şimdi seçin German (Germany) ve bu iletişim kutusunu kapatın.

  • Deutsch'u varsayılan dil yapın.
  • Şimdi uygulamanızı çalıştırın, aşağıdaki pencere görüntülenecektir.
  • Şimdi başvurunuzun çıktısını Almanca olarak görebilirsiniz.

Geçmişte Windows, kullanıcıların aynı anda birden fazla uygulamayı çalıştırabildikleri bir ortama sahiptir. Kullanıcı farklı uygulamalar arasında kolaylıkla geçiş yapabilir. Bu model, kullanımın genellikle tek uygulama odaklı olduğu telefon veya tablet cihazlarda iyi çalışmaz.

Windows 8 Mağazası uygulama programcılarının karşılaştığı en önemli zorluklardan biri, uygulama yaşam döngüsünü yönetmek ve anlamak olacaktır. Windows telefon uygulamaları oluşturuyorsanız, bunun çoğu tanıdık gelecektir.

  • Windows 8 altında, işletim sistemi bir uygulamanın ömrünü yönetir ve kullanıcı bir uygulamayı sonlandırabilirken, tipik olarak kullanıcı çalışan uygulamaları bilinçli olarak sonlandırmadan yeni uygulamaları açar.

  • Windows 10 için Evrensel Windows Platformu (UWP) bu sorunları gidererek masaüstü kullanıcılarına bazı harika şeyler sunar, böylece birden çok uygulama birden çok pencereli bir deneyimle çalışabilir.

Windows uygulamaları, aşağıda gösterildiği gibi temel düzeyde üç durumda bulunabilir.

  • Running

  • Suspended

  • Terminate

  • Bir kullanıcı herhangi bir uygulamayı başlattığında / etkinleştirdiğinde, running durum.

  • Bir kullanıcı onu kullanmazsa ve artık ön planda değilse uygulamalar askıya alınabilir.

  • Askıya alındı ​​durumundan, uygulamalar sistem kaynaklarını geri kazanmak için o uygulamayı sürdürebilir veya işletim sistemini sonlandırabilir.

İşlem Durumu Geçişi

Çalışan bir uygulamadaki işlem durumu geçişlerini anlamak önemlidir. Kullanıcı uygulamayı ilk kez başlattığında, açılış ekranı gösterilir ve ardından uygulama çalışmaya başlar.

Süreç şu şekilde açıklanabilir -

  • Uygulama askıya alındığında, uygulamanızın askıya alınan olayı işlemesi beş saniye sürer.

  • Uygulama askıya alındığında, kesinlikle hiçbir kod çalışmaz ve kaynak tahsis edilmez.

  • Devam ettiğinde, uygulamaya devam ettiği bildirilir. Askıya alınmış bir durumdan geliyorsanız, herhangi bir işlem yapmanıza gerek yoktur.

  • Bellek baskısı altında uygulamanızın sonlandırılması mümkündür.

  • Bu noktada bilgilendirilmeyeceğinizi ve bu nedenle yaptığınız her tasarruf, askıya alınmış başvuru durumuna girdiğinizde yapmanız gerektiğini unutmayın.

Uygulama arasında geçiş yaptığında Running ve Suspended durumları, sırasıyla yangının askıya alınması ve devam ettirilmesi olayları.

Bazen verileri kaydetmeniz gerekir. Ardından, aşağıda gösterildiği gibi asenkron yöntemleri çağırmanız gerekir.

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"]; 
}

Aşağıda verilen XAML dosyasında gösterildiği gibi kontrollerin eklendiği bir örneği inceleyelim.

<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>

Aşağıda verilen, Askıya Alma ve Sürdürme olaylarının uygulandığı C # kodudur. Mevcut veriler şurada saklanacaktır:suspend event yerel ayarlarda ve ardından veriler resume event aşağıda gösterildiği gibi yerel ayarlardan.

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); 
         } 
      } 
   } 
}

Yukarıdaki kod derlendiğinde ve çalıştırıldığında, aşağıdaki pencereyi göreceksiniz. Şimdi istediğiniz bilgileri yazın.

Gidelim Lifecycle Etkinlikler açılır menüsü ve seçin suspended. Şimdi başvurunuz askıya alınacak ve istenen bilgiler yerel ayarlarda saklanacaktır. Aşağıda verilen ekran görüntüsüne bakın.

Şimdi, başvurunuzu devam ettirmek istediğinizde seçeneği seçin Resume -den Lifecycle Events Menü.

Artık depolanan bilgilerin yerel ayarlardan alındığını ve uygulamanın askıya alındığı aynı durumda kaldığı yerden devam ettirildiğini göreceksiniz.

Evrensel Windows Platformu (UWP), uygulama ön planda çalışmıyorken uygulamaların bazı işlevleri gerçekleştirmesine izin veren yeni mekanizmalar sunar. UWP ayrıca uygulamaların arka planda yürütme sürelerini uzatmak içinBackground Tasks and Triggers. Arka planda yürütme, uygulama yaşam döngüsünün gerçek tamamlayıcı kuyruğudur.

Arka Plan Görevlerinin önemli özellikleri şunlardır:

  • Bir arka plan görevi, bir sistem veya zaman olayı tarafından tetiklenir ve bir veya daha fazla koşulla sınırlandırılabilir.

  • Bir arka plan görevi tetiklendiğinde, ilişkili işleyicisi çalışır ve arka plan görevinin çalışmasını gerçekleştirir.

  • Arka plan görevi, arka plan görevini kaydeden uygulama askıya alındığında bile çalışabilir.

  • Standart uygulama platformunun parçasıdırlar ve esasen bir sistem olayına (tetikleyici) kaydolma becerisine sahip bir uygulama sağlarlar. Bu olay meydana geldiğinde, arka planda önceden tanımlanmış bir kod bloğu çalıştırırlar. Sistem tetikleyicileri, ağ bağlantısı veya sistem saat dilimindeki değişiklikler gibi olayları içerir.

  • Arka Plan Yürütme garanti edilmez, bu nedenle kritik işlevler ve özellikler için uygun değildir.

  • İşletim sisteminin aynı anda kaç tane arka plan görevinin çalıştırılabileceği konusunda bir sınırlaması vardır. Bu nedenle, tetikleyici çalıştırıldığında ve koşullar karşılandığında bile görev yine de çalışamaz.

Arka Plan Görevi Oluşturun ve Kaydedin

Bir arka plan görev sınıfı oluşturun ve uygulamanız ön planda değilken çalışması için kaydedin. Kodu uygulayan sınıflar yazarak arka planda çalıştırabilirsiniz.IBackgroundTaskarayüz. Aşağıdaki örnek kod, bir arka plan görev sınıfı için çok temel bir başlangıç ​​noktası gösterir.

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

Arka plan görevine aşağıdaki şekilde erişim talep edebilirsiniz.

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; 
}

Arka plan görevini oluşturmak ve kaydetmek için aşağıdaki kodu kullanın.

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

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

Aşağıda verilen tüm adımları izleyerek basit bir arka plan görevi örneğini anlayalım.

  • Yeni bir boş UWP projesi oluşturun ‘UWPBackgroundDemo’ ve XAML dosyasına bir düğme ekleyin.

<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>
  • Aşağıda verilen button click arka plan görevinin kayıtlı olduğu olay uygulaması.

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(); 
      } 
   } 
}
  • Şimdi başka bir proje oluşturun, ancak bu sefer menüden Windows Çalışma Zamanı Bileşeni'ni (Evrensel Windows) seçin ve adı verin Background stuff bu projeye.

  • Aşağıda verilen C # kodudur. içerenMyBackgroundTask sınıf implantasyonu ve arka plan görevini çalıştıracaktır.

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); 
      } 
   } 
}
  • Bu projeyi UWPBackgroundDemo proje, sağ tıklayın References > Add References Solution Explorer'da ve ekleyin BackgroundStuff proje.

  • Şimdi, gidelim Package.appxmanifest dosyası UWPBackgroundDemo Projelendirin ve aşağıdaki bilgileri Bildirimler sekmesine ekleyin.

  • Önce Arka Plan malzemeleri projesini oluşturun, ardından UWPBackgroundDemo proje.

  • Yukarıdaki kod derlendiğinde ve çalıştırıldığında, aşağıdaki pencereyi göreceksiniz.

  • Tıkladığınızda button, arka plan görevini çalıştıracak ve pencerenizin sağ ucunda bir bildirim gösterecektir.

Bu bölümde, UWP uygulamalarının başka bir Evrensel Windows Platformu (UWP) uygulamalarına nasıl yardımcı olabileceğini veya hizmet sağlayabileceğini öğreneceğiz. Aslında bu bölüm, bölümün bir uzantısıdırBackground execution ve bunun özel bir durumu.

  • Windows 10'da bir uygulama hizmeti, bir uygulamanın diğer uygulamalara hizmet sağlaması için bir yol veya mekanizmadır.

  • Bir uygulama hizmeti, bir arka plan görevi biçiminde çalışır.

  • Ön plan uygulamaları, arka planda görevleri gerçekleştirmek için başka bir uygulamadaki bir uygulama hizmetini çağırabilir.

Uygulama hizmetleri web hizmetleri gibidir ancak uygulama hizmetleri Windows 10 cihazında kullanılır.

Evrensel Windows Platformu (UWP) uygulamaları, başka bir UWP uygulamasıyla çeşitli şekillerde etkileşim kurabilir -

  • LaunchUriAsync kullanarak URI ilişkilendirmesi
  • LaunchFileAsync kullanarak dosya ilişkilendirme
  • LaunchUriForResultsAsync kullanarak sonuçlar için başlatın
  • Uygulama hizmetleri

İlk üç yol, her iki uygulama da ön plandayken kullanılır, ancak Uygulama hizmetleri background task ve bu durumda istemci uygulaması ön planda olmalı ve Uygulama hizmetini kullanmak için uygun olmalıdır.

Uygulama hizmetleri, görsel olmayan hizmetlerin sağlandığı uygulamalarda çok faydalıdır, örneğin ön plandaki bir uygulamanın görüntüyü alacağı ve bu baytları barkodu tanımlamak için uygulama hizmetlerine göndereceği bir barkod tarayıcı.

Tüm bu kavramları anlamak için, adıyla yeni bir UWP projesi oluşturalım. AppServiceProvider Microsoft Visual Studio 2015'te.

Şimdi Package.appmenifest dosya, aşağıdaki bilgileri ekleyin.

Ön plan uygulamaları tarafından çağrılabilen bir uygulama servisi oluşturmak için yeni bir Windows Runtime Bileşen projesi ile çözüme MyAppService name, çünkü uygulama hizmetleri arka plan görevi olarak uygulanıyor.

Bir referans ekleyin MyAppService projede AppServiceProvider proje.

Şimdi silin class1.cs dosyasından MyAppService projelendirin ve envanter adıyla yeni bir sınıf ekleyin; IBackgrounTask arayüz.

IBackgrounTask arayüzün sadece bir yöntemi vardır “Run” Arka plan Görevi için uygulanması gereken.

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

Arka plan görevi oluşturulduğunda, Run() methodçağrılır ve Run yöntemi tamamlandığında arka plan görevleri sonlandırılır. Bir arka plan görevine bağlı kalmak, isteklere hizmet etmek için kod ertelenir.

Uygulama hizmetleri kodu OnRequestedReceived(). Bu örnekte, bir stok kalemi için bir dizin, belirtilen envanter kaleminin adını ve fiyatını almak için hizmete geçer.

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

Aşağıda, C # 'da Envanter sınıfının tam uygulaması verilmiştir.

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(); 
            } 
      } 
   } 
}

Yeni bir boş UWP projesi ekleyerek bir müşteri uygulaması oluşturalım ClientApp ve aşağıda gösterildiği gibi XAML dosyasında bir düğme, bir metin kutusu ve iki metin bloğu ekleyin.

<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>

Aşağıda, Uygulama hizmetlerinin talep edildiği düğme tıklama etkinliği uygulaması verilmiştir.

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;  
      } 
   } 
}

Bu uygulamayı çalıştırmak için, ClientApp Çözüm Gezgini'nde başlangıç ​​projesi olmak için proje yapın ve ardından bu çözümü Build > Deploy Çözüm.

Yukarıdaki kod derlendiğinde ve çalıştırıldığında, aşağıdaki pencereyi göreceksiniz. Uygulama hizmetlerinde, iki öğenin bilgilerini ekledik. Dolayısıyla, bu öğelerin bilgilerini almak için 0 veya 1 girebilirsiniz.

0 girip düğmeye tıkladığınızda, arka plan görevi olarak Uygulama hizmetini çalıştıracak ve öğenin bilgilerini ekranda gösterecektir. textblock.

Windows 10'da, geliştiricilerin Evrensel Windows Platformu (UWP) uygulaması oluşturmaları ve web sitelerini bu uygulama üzerinde barındırmaları ve daha sonra indirilmek üzere Windows Mağazası'nda yayınlanmaları çok kolaydır.

Avantajlar

  • Windows 10'daki bu yeni özellik ile web geliştiricileri, web sitelerinin bileşenlerini Windows uygulamalarına kolayca dönüştürebilirler.

  • Bununla birlikte, tüm bu bileşenler yine de kendi web sunucularında uzaktan barındırılacaktır.

  • Ek olarak, geliştiricilerin bildirimler, kamera, takvim, Cortana ve daha fazlası gibi bazı harika şeylere erişmesine olanak tanıyan evrensel API'lere de erişebilirler.

Microsoft, bu özellik ve yeteneğin daha fazla geliştiricinin Windows 10 platformu için uygulamalar yazmasını sağlayacağını umuyor.

  • Desktops
  • Smartphones
  • Xbox
  • Tablets
  • HoloLens ve diğer cihazlar

Şu anda, bu özellikle ilgili tek bir sorun var ve bu da güvenlik. Açıkçası, Microsoft'un bunu mümkün olan en kısa sürede ele alması gerekiyor.

Bir web sitesini barındıracağımız ve bu web sitesini bir Windows uygulamasına dönüştürebileceğimiz bir örnek yardımıyla anlayalım.

Aşağıda verilen adımları izleyin.

  • Şuradan yeni bir Evrensel Windows Projesi oluşturun File > New > Project.

  • Seçiniz JavaScript > Windows > Universal Yeni proje ve iletişim kutusunun sol bölmesindeki seçeneği.

  • Orta bölmeden şunu seçin: Blank App (Universal Windows).

  • İsim alanına yazın, UWPWebApp ve tıklayın OK buton.

  • Bakarsan Solution Explorer penceresi, bazı dosya ve klasörler göreceksiniz.

  • Sil css, js, WinJS klasörler ve default.htmldosya, çünkü bu örnekte sadece bir web sitesi barındırıyoruz ve tüm içeriğin uzak sunucuda olduğunu varsayıyoruz. Bu nedenle, yerel dosyaların çoğuna ihtiyacımız yoktur.

  • Yukarıda belirtilen dosya ve klasörleri sildikten sonra, şimdi çift tıklayın. package.appxmanifest dosya ve aşağıdaki pencereyi göreceksiniz.

  • Şimdi web sitesi URL'sini default.htmlBaşlangıç ​​sayfası alanında URL'ye göre. Gösteri amacıyla URL'yi kullanacağızhttps://www.google.com.pk/ İnternet sitesi.

  • Şimdi gidin Content URIs sekmesine gidin ve web uygulamanız için kural ve erişim iznini tanımlayın.

  • URI alanında, web sitenizin bağlantısını belirtin ve ardından Include -den Rule dropdown ve All itibaren WinRT Access.

  • Bu uygulamayı çalıştırdığınızda, aşağıda gösterildiği gibi uygulamanızda google başlangıç ​​sayfasını göreceksiniz.

Bildiğimiz gibi, Windows 10'da birden fazla Windows 10 cihazında çalıştırılabilen ve çalıştırılabilen bir uygulama oluşturabiliriz. Diyelim ki bu farklı cihazlara sahibiz ve farklı cihazlarda çalışıyor olsa bile bunun tek bir uygulama olduğunu hissettirmek istiyoruz.

Evrensel Windows Platformunda (UWP), tüm Windows 10 cihazlarında tek bir uygulama çalıştırabilir ve kullanıcıya bunun tek bir uygulama olduğu hissini verebilirsiniz. Bu olarak bilinirconnecting experience.

Bağlantılı deneyimin önemli özellikleri -

  • Windows 10, uygulamalarınızın, hizmetlerinizin ve içeriğinizin sizinle cihazlar arasında sorunsuz ve kolay bir şekilde hareket edebileceği daha kişisel bilgi işlem çağının ilk adımıdır.

  • Bağlantılı deneyim ile, verilerinizi ve o uygulamayla ilgili kişisel ayarlarınızı kolayca paylaşabilirsiniz ve tüm cihazlarda kullanılabilir olacaktır.

Bu bölümde öğreneceğiz -

  • Bu paylaşılan verilerin veya ayarların, cihazlarınızda söz konusu tek uygulama için kullanılabilmesi için depolanacağı yer.

  • kullanıcının nasıl tanımlandığı; aynı uygulamayı farklı cihazlarda kullanan kişinin aynı kullanıcı olduğunu.

Windows 10, cesur bir adım atıyor. Microsoft hesabınızla (MSA) veya kurumsal veya (iş) hesabınızla Windows 10'da oturum açtığınızda, şu varsayılır -

  • OneDrive for MSA hesabına ücretsiz erişiminiz vardır ve kurumsal hesabınızla birlikte bir bulut sürümü olan Active Directory (AD) ve Azure Active Directory'ye (AAD) erişiminiz vardır.

  • Farklı uygulamalara ve kaynaklara erişiminiz var.

  • Cihazlar ve uygulamalar dolaşım durumunda ve ayarlardadır.

Windows 10'da Dolaşım

Bir PC'de oturum açtığınızda, kilit ekranı veya arka plan rengi gibi bazı tercihler ayarlayabilir veya farklı türdeki ayarlarınızı kişiselleştirebilirsiniz. Windows 10 üzerinde çalışan birden fazla bilgisayarınız veya cihazınız varsa, bir cihazdaki tercihleriniz ve ayarlarınız, aynı hesapla diğer cihazlara giriş yaptığınızda buluttan senkronize edilecektir.

Windows 10'da, uygulama ayarlarınızı belirlediğinizde veya kişiselleştirdiğinizde, bu ayarlar UWP'de bulunan Dolaşım API'leri ile dolaşacaktır. Aynı uygulamayı başka cihazda tekrar çalıştırdığınızda, önce ayarları alacak ve bu ayarları o cihazdaki uygulamaya uygulayacaktır.

Buluta dolaşım verilerini yüklemek için 100 KB'lık bir sınır vardır. Bu sınır aşılırsa, senkronizasyon duracak ve yerel bir klasör gibi davranacaktır.

RoamingSettings API'ler, bir uygulamanın verileri kaydedebileceği sözlük olarak sunulur.

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";

Veriler değiştiğinde RoamingSettings sonra ateşler DataChanged ayarlarınızı yenileyebileceğiniz olay.

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

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

Uygulamanın arka plan rengini belirleyeceğimiz ve bu ayarların UWP'de bulunan Roaming API'leri ile dolaşacağı bir örneğe bakalım.

Aşağıda, farklı kontrollerin eklendiği XAML kodu verilmiştir.

<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>

İçin C # uygulaması RoamingSettings ve farklı olaylar aşağıda verilmiştir.

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(); 
      } 
		
   } 
}

Yukarıdaki kod derlendiğinde ve çalıştırıldığında, aşağıdaki pencereyi göreceksiniz.

Arka plan rengi olarak gri rengi seçelim ve bu uygulamayı kapatalım.

Şimdi, bu uygulamayı bu cihazda veya başka bir cihazda çalıştırdığınızda, arka plan renginin griye dönüştüğünü göreceksiniz. Bu, uygulamanın arka plan rengi değişikliği bilgilerini başarıyla aldığını gösterir.RoamingSettings.

Evrensel Windows Platformu (UWP) uygulamalarında gezinme, gezinme yapılarının, gezinme öğelerinin ve sistem düzeyi özelliklerinin esnek bir modelidir. Uygulamalar, sayfalar ve içerik arasında geçiş yapmak için çeşitli sezgisel kullanıcı deneyimleri sağlar.

Tüm içeriğin ve işlevselliğin tek bir sayfaya kolayca sığabileceği ve geliştiricilerin birden fazla sayfa oluşturmasına gerek olmadığı bazı durumlar ve senaryolar vardır. Bununla birlikte, uygulamaların çoğunda, farklı içerik ve işlevler arasındaki etkileşim için birden çok sayfa kullanılır.

Bir uygulamanın birden fazla sayfası olduğunda, geliştiricilerin doğru gezinme deneyimini sağlaması çok önemlidir.

Sayfa Modelleri

Genelde, Evrensel Windows Platformu (UWP) uygulamalarında, tek sayfalı gezinme modeli kullanılır.

Önemli özellikler -

  • Tek sayfalık bir gezinme modeli, uygulamanızın tüm bağlamını ve ek içeriği ve verileri merkezi bir çerçevede tutar.

  • Uygulamanızın içeriğini birden çok sayfaya bölebilirsiniz. Ancak, bir sayfadan diğerine geçerken, uygulamanız sayfaları bir ana sayfa formuna yükler.

  • Ne uygulamanızın ana sayfası kaldırılır ne de kod ve veriler kaldırılır, durum yönetimini kolaylaştırır ve sayfalar arasında daha yumuşak geçiş animasyonları sağlar.

Çok sayfalı gezinme, uygulama bağlamı hakkında endişelenmeden farklı sayfalar veya ekranlar arasında gezinmek için de kullanılır. Çok sayfalı gezinmede, her sayfanın kendi işlevleri, kullanıcı arayüzü ve verileri vb. Bulunur.

Çok sayfalı gezinme, genellikle web sitesi içindeki web sayfalarında kullanılır.

Navigasyon Yapısı

Çok sayfalı gezinmede, her sayfanın kendi işlevleri, kullanıcı arayüzü ve verileri vb. Vardır. Örneğin, bir fotoğraf uygulamasının fotoğraf çekmek için bir sayfası olabilir, ardından kullanıcı fotoğrafı düzenlemek istediğinde başka bir sayfaya gider ve görüntü kitaplığını korumak için başka bir sayfası vardır.

Uygulamanızın gezinme yapısı, bu sayfaların nasıl düzenlendiği ile tanımlanır.

Aşağıda, uygulamanızda gezinmeyi yapılandırmanın yolları verilmiştir -

Hiyerarşi

Bu tür gezinme yapılandırmasında,

  • Sayfalar ağaç benzeri bir yapı halinde düzenlenmiştir.

  • Her alt sayfanın yalnızca bir ebeveyni vardır, ancak bir ebeveynin bir veya daha fazla alt sayfası olabilir.

  • Bir alt sayfaya ulaşmak için ebeveyn aracılığıyla seyahat etmelisiniz.

Akran

Bu tür navigasyonda -

  • Sayfalar yan yana bulunur.
  • Bir sayfadan diğerine herhangi bir sırayla gidebilirsiniz.

Çok sayfalı uygulamaların çoğunda, her iki yapı aynı anda kullanılır. Sayfalardan bazıları eşler olarak, bazıları ise hiyerarşiler halinde düzenlenmiştir.

Üç sayfa içeren bir örnek alalım.

  • Adıyla boş bir UWP uygulaması oluşturun UWPNavigation.

  • İçinde projeye sağ tıklayarak iki boş sayfa daha ekleyin Solution Explorer ve seçin Add > New Item Aşağıdaki iletişim penceresini açacak olan menüden seçenek.

  • Orta bölmeden Boş sayfayı seçin ve Add buton.

  • Şimdi yukarıda verilen adımları izleyerek bir sayfa daha ekleyin.

Çözüm Gezgini'nde üç sayfa göreceksiniz - MainPage, BlankPage1, ve BlankPage2.

Aşağıda verilen XAML kodu MainPage iki düğmenin eklendiği.

<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>

Aşağıda verilen iki düğme için C # kodu verilmiştir. MainPage, diğer iki sayfaya gidecektir.

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)); 
      } 
		
   } 
}

XAML kodu blank page 1 aşağıda gösterilmiştir.

<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>

Düğme için C # kodu - etkinliğe tıklayın blank page 1Ana sayfaya gidecek olan aşağıda gösterilmiştir.

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)); 
      }
		
   } 
}

Aşağıda verilen XAML kodu 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>

Aşağıda verilen düğme tıklama etkinliği için C # kodu verilmiştir. blank page 2, ana sayfaya gidecektir.

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)); 
      }
		
   } 
}

Yukarıdaki kod derlendiğinde ve çalıştırıldığında, aşağıdaki pencereyi göreceksiniz.

Herhangi bir düğmeye tıkladığınızda sizi ilgili sayfaya yönlendirecektir. TıklayalımGo to Page 1 ve sonraki sayfa görüntülenecektir.

Düğmeye tıkladığınızda 'Go to Main Page', ana sayfaya geri dönecektir.

Günümüzde, bir şekilde web servisleriyle veya bir ağdaki diğer cihazlarla entegre olmuş birçok uygulama göreceksiniz. Çevrimiçi hava durumu içeriği, en son haberler, sohbet veya eşler arası oyunlar, ağ hizmetlerini kullanan bazı örneklerdir. Bu uygulamalar, çok çeşitli ağ API'leri kullanılarak oluşturulmuştur. Windows 10'da, ağ API'leri hızları ve bellek performanslarının yanı sıra geliştiricilere sağladıkları yetenekler ve esneklik açısından geliştirildi.

Yetenekler

Ağ oluşturmak için, uygulama bildiriminize uygun yetenek öğeleri eklemeniz gerekir. Uygulamanızın bildiriminde herhangi bir ağ özelliği belirtilmezse, uygulamanızın ağ oluşturma yeteneği olmaz ve ağa bağlanma girişimleri başarısız olur.

Aşağıdakiler en çok kullanılan ağ yetenekleridir.

S.No. Yetenek ve Açıklama
1

internetClient

Havalimanları ve kahve dükkanı gibi halka açık yerlerdeki İnternet ve ağlara giden erişim sağlar. İnternet erişimi gerektiren çoğu uygulama bu özelliği kullanmalıdır.

2

internetClientServer

Uygulamaya internetten ve havalimanları ve kafeler gibi halka açık yerlerdeki ağlardan gelen ve giden ağ erişimi sağlar.

3

privateNetworkClientServer

Uygulamaya gelen ve giden ağ erişimini kullanıcıların ev ve iş gibi güvenilen yerlerinde verir.

Uygulama manifest dosyanızda bir veya daha fazla yetenek tanımlamak için aşağıda verilen resme bakın.

Evrensel Windows Platformu (UWP), aşağıdakileri hedefleyerek çok sayıda ağ API'si içerir:

  • Cihazın bağlantı durumunu sorgulama ve eş cihazlara bağlanma.
  • REST web servisleri ile iletişim ve
  • Arka planda büyük medya dosyalarını indirme

Ağ Teknolojileri

Evrensel Windows Platformunda (UWP), birçok farklı durumda kullanılabilen aşağıdaki ağ teknolojileri geliştiriciler için mevcuttur.

Soketler

Başka bir cihazla kendi protokolünüzle iletişim kurmak istediğinizde soketler kullanılır.

  • İkisini de kullanabilirsiniz, Windows.Networking.Sockets ve Winsock Evrensel Windows Platformu (UWP) uygulama geliştiricisi olarak diğer cihazlarla iletişim kurmak için.

  • Windows.Networking.Sockets UWP geliştiricileri tarafından kullanılmak üzere tasarlanmış modern bir API olma avantajına sahiptir.

  • Çapraz platform ağ kitaplıklarını veya diğer mevcut Winsock kodunu kullanıyorsanız, Winsock APIs.

Aşağıdaki kod, bir yuva dinleyicisinin nasıl oluşturulacağını gösterir.

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. 
}

Aşağıdaki kod, SocketListener_ConnectionReceived olay işleyicisi.

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

WebSocketsprotokol, bir istemci ile bir sunucu arasında web üzerinden hızlı ve güvenli bir çift yönlü iletişim sağlar. Evrensel Windows Platformu (UWP) geliştiricileri,MessageWebSocket ve StreamWebSocket Websocket protokolünü destekleyen sunuculara bağlanmak için sınıflar.

Önemli özellikler -

  • WebSocket Protokolü altında, veriler tam çift yönlü tek soketli bağlantı üzerinden anında aktarılır.

  • Mesajların her iki uç noktadan gerçek zamanlı olarak gönderilmesine ve alınmasına izin verir.

  • WebSockets Anlık sosyal ağ bildirimlerinin ve güncel bilgi görüntülemelerinin (oyun istatistikleri) güvenli olması ve hızlı veri aktarımı kullanması gereken gerçek zamanlı oyunlarda kullanım için idealdir.

Aşağıdaki kod, güvenli bir bağlantıda nasıl mesaj gönderilip alınacağını gösterir.

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 
}

Aşağıdaki kod, bağlı bir diziden bir dize alacak olay uygulamasını gösterir. 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 ve Windows.Web.Http ad alanı API'leri, geliştiriciye HTTP 2.0 ve HTTP 1.1 protokollerini kullanarak bilgi gönderme ve alma yeteneği sağlar.

Kullanılabilir -

  • bir web hizmeti veya web sunucusu ile iletişim kurun.
  • Birkaç küçük dosya yükleyin veya indirin.
  • İçeriği ağ üzerinden yayınlayın.

Aşağıdaki kod, kullanarak bir GET isteğinin nasıl gönderileceğini gösterir. Windows.Web.Http.HttpClient ve 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; 
}

Bir geliştirici olarak, masaüstünüzde bulunandan başka verilere ihtiyacınız olabilir. Bulut hizmetleri bu verilere erişmenize yardımcı olabilir. Bu bölüm, ihtiyaç duyabileceğiniz bulut hizmetlerinin daha iyi anlaşılmasını sağlar.

Microsoft, bir bulut bilişim platformu ve şu adla bilinen altyapıyı sağlamıştır: Microsoft Azure, tüm uygulamaları ve hizmetleri oluşturabileceğiniz, dağıtabileceğiniz ve yönetebileceğiniz yer.

Azure ilk olarak 1 Şubat 2010'da Windows Azure adıyla piyasaya sürüldü. Daha sonra 25 Mart 2014'te Microsoft Azure olarak yeniden adlandırıldı.

Her ikisini de sağlar, PaaS and IaaS hem Microsoft'a özgü hem de üçüncü taraf yazılım ve sistemleri dahil olmak üzere birçok farklı programlama dilini, aracını ve çerçevesini destekler.

Microsoft, bulut hizmetlerini Windows 10 ile yükseltti. Microsoft hesabı entegrasyonu, Windows 8'de tanıtıldı. OneDrive 2007'den beri var. Windows 10 için, her iki hizmet de artan entegrasyon ve daha fazla kullanıcının ilgisini çeken yeni işlevsellik ile güncellendi.

Microsoft hesabı

Microsoft hesabınızla Microsoft'un Azure bulut tekliflerini kullanabilirsiniz. Tabii ki ücretsiz değil ama 30 günlük ücretsiz deneme kullanabilirsiniz.

Windows 10 ile bir makineyi ilk kurduğunuzda ve Microsoft hesabıyla oturum açtığınızda, aynı hesabı Microsoft Azure aboneliği için kullanabilirsiniz. Microsoft Azure'a kaydolmak için buraya tıklayınhttps://azure.microsoft.com/.

Microsoft Azure'a abone olduktan sonra Azure Portal'a gidin https://portal.azure.com/. Aşağıdaki sayfayı göreceksiniz.

Veritabanlarında depolayabilir, Sanal makineleri vb. Kullanabilirsiniz. Ayrıca mobil uygulamanızın arka ucunu da oluşturabilir ve barındırabilirsiniz.

Aşağıdaki bahsedilen adımları izleyerek bunu bir örnekle deneyelim.

  • Tıkla New sol bölmedeki seçenek.

  • Seçiniz Web + Mobile > Mobile App ve Web uygulamanıza bir ad verin.

  • Uygulamanızı göndermek ve dağıtmak biraz zaman alacaktır. Bu işlem tamamlandıktan sonra aşağıdaki sayfayı göreceksiniz. Burada, Windows (C #), iOS Android, vb. Gibi farklı mobil uygulama türlerini seçebilirsiniz.

  • Windows 10 hakkında konuştuğumuz için, aşağıdaki sayfayı açacak olan Windows'u (C #) seçin.

  • Burada iki indirme seçeneğini görebilirsiniz. Bunlar örnek projelerdir, Visual Studio'yu indirip oluşturabilir ve ardından Microsoft Azure'da kolayca yayımlayabilirsiniz.

  • Bir sunucu projesi olan ilkini indirelim. Bu bir zip dosyasıdır.

  • İndirme tamamlandığında, bunu açın ve Visual Studio'da açın.

  • Şimdi bu uygulamayı oluşturun. Bazı hatalar listelenirse, tekrar oluşturun.

  • Uygulamayı çalıştırın. Şu anda localhost'ta olan aşağıdaki web sayfasını göreceksiniz.

  • Şimdi bu uygulamayı bulutta barındırmak için sağ tıklayın Project seçeneği Solution Explore Aşağıda gösterildiği gibi.

  • Seçiniz Publishmenüden seçenek. Aşağıdaki iletişim kutusunu göreceksiniz.

  • İlk seçeneği seçin - Microsoft Azure Web Apps. Aşağıdaki iletişim kutusu açılacaktır.

  • Şimdi tıklayın Add an account Microsoft Azure hesabı eklemek için menüden seçenek.

  • Kimlik bilgilerinizi belirtin ve tıklayın Sign in. Aşağıdaki iletişim penceresi açılacaktır.

  • Oturum açtıktan sonra menüden uygulamanızı seçin Existing Web Apps ve tıklayın Ok.

  • Aşağıda gösterilen iletişim kutusu, ad, sunucu adı, URL vb. Gibi uygulamanızla ilgili bazı bilgileri gösterir.

  • Şimdi tıklayın Validate Connectionbuton. Doğrulamadan sonra,Publish düğmesine tıklarsanız uygulamanızın şu anda üzerinde barındırıldığını göreceksiniz Microsoft Azure.

Bu bölümde, karolar aracılığıyla bir kullanıcıyla etkileşimden bahsedeceğiz. Windows 10'un ikonik parçasıdır. Kutucuklar,Start Screen yanı sıra Start Menu. Başka bir deyişle, Windows 10 işletim sistemi genelinde çeşitli biçimlerde görünen bir uygulama simgesi varlığıdır. Evrensel Windows Platformu (UWP) uygulamanız için arama kartlarıdır.

Çini Anatomisi

Üç karo durumu vardır.

  • Basic State - Başlangıç ​​kutucuğunun temel bileşenleri bir arka plaka, bir simge ve bir uygulama başlığından oluşur.

  • Semi-Live state - Bir sayı olan rozetin 0-99 arasındaki sayıları görüntüleyebilmesi tek farkı temel karo ile aynıdır.

  • Live State - Bu döşeme, yarı canlı durum döşemesinin tüm öğelerini içerir ve ayrıca fotoğraflar, metin vb. Gibi istediğiniz her şeyi koyabileceğiniz ek içerik plakasını gösterir.

Döşemeleri Güncelleme

Kutucukları güncellemenin dört yolu vardır.

  • Scheduled - Şablonu ve zamanı ile ayarlayabilirsiniz. ScheduledTileNotification.

  • Periodic- Bilgiler bir URI'den alındığında ve 30 dakika, 1 saat, 6 saat gibi bu süreden sonra bilgilerin alınacağı zamanı belirtebilirsiniz. vb.

  • Local- Yerel olan uygulamanızdan güncellenebilir; ön plandan veya arka plan uygulamasından.

  • Push - Sunucudan bilgi iterek sunucudan güncellenir.

Bir döşeme oluşturmak için verilen kodu izleyin.

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 oldukça basittir çünkü bu sadece bir sayıdır ve rozetin değerini aşağıda gösterildiği gibi ayarlayabilirsiniz.

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);

Visual Studio'da yeni bir UWP projesi oluşturalım.

  • Farklı png dosyalarını, Assets klasör Solution Explorer.

  • Paket bildiriminde varsayılan bir kutucuk ve onun görüntüsünü tanımlayalım.

  • Çift tıklayın. package.appxmanifest. Bu, manifest düzenleyici penceresini açar.

  • Seçiniz Visual Assets sekmesi.

  • Uygulama döşemeniz için belirtilen boyutlardan herhangi birine sahip resimleri ve simgeleri seçebilirsiniz. AltındaTile Images and Logosgibi tüm logolar için varsayılan resimler sağlanır

    • Kare 71x71 Logo
    • Kare 150x150 Logo
    • Kare 310x310 Logo
    • Mağaza Logosu
  • Uygulamanızı çalıştırıp ardından başlangıç ​​ekranınıza gittiğinizde, uygulamanızın kutucuğunu göreceksiniz.

Bu bölümde, uygulamalar arasında verilerin nasıl paylaşılacağını öğreneceğiz. Kullanıcılar genellikle biriyle paylaşmaktan veya başka bir uygulamada kullanmaktan heyecan duydukları bilgilerle karşılaşırlar. Günümüzde kullanıcılar, diğer insanlarla bağlantı kurmak ve paylaşmak için teknolojiyi kullanmak istiyor.

Bir kullanıcı paylaşmak isteyebilir -

  • Sosyal ağlarıyla bir bağlantı
  • Bir resmi bir rapora kopyala
  • Bulut depolamaya bir dosya yükleyin

Günümüzde uygulamalar, kullandıkları verilerin aynı zamanda kullanıcıların paylaşması ve değiş tokuşu için kullanılabilir olmasını sağlamalıdır. Paylaş, UWP uygulamanıza eklenmesi kolay olan hafif bir özelliktir. Uygulamaların diğer uygulamalarla veri alışverişi yapmasının birkaç yolu vardır.

UWP uygulamalarında paylaşım özelliği aşağıdaki şekillerde desteklenebilir;

  • İlk olarak, uygulama, kullanıcının paylaşmak istediği içeriği sağlayan bir kaynak uygulama olabilir.

  • İkincisi, uygulama, kullanıcının paylaşılan içerik için hedef olarak seçtiği bir hedef uygulama olabilir.

  • Bir uygulama aynı zamanda hem kaynak uygulama hem de hedef uygulama olabilir.

İçerik Paylaşımı

Kaynak uygulama olan bir uygulamadan içerik paylaşmak çok basittir. Herhangi bir paylaşım işlemini gerçekleştirmek için,DataPackagesınıf nesnesi. Bu nesne, kullanıcının paylaşmak istediği verileri içerir.

Aşağıdaki içerik türleri dahil edilebilir DataPackage nesne -

  • Düz metin
  • Tekdüzen Kaynak Tanımlayıcıları (URI'ler)
  • HTML
  • Biçimlendirilmiş metin
  • Bitmaps
  • Files
  • Geliştirici tanımlı veriler

Verileri paylaşırken, yukarıda belirtilen formatlardan bir veya daha fazlasını dahil edebilirsiniz. Uygulamanızda paylaşımı desteklemek için, öncelikleDataTransferManager sınıf.

Daha sonra her zaman çağrılan bir olay işleyicisi kaydedecektir. DataRequested olay meydana gelir.

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

Uygulamanız bir DataRequest nesne, ardından uygulamanız kullanıcının paylaşmak istediği içeriği eklemeye hazırdır.

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!"); 
}

Uygulamanızın paylaştığı herhangi bir içerik iki özellik içermelidir -

  • Zorunlu olan ve ayarlanması gereken bir Başlık özelliği.
  • İçeriğin kendisi.

Paylaşılan İçeriği Alma

Uygulamanızın paylaşılan içeriği alabilmesini istiyorsanız, yapmanız gereken ilk şey, uygulamanızın Share Contract. Bildirimden sonra, sistem uygulamanızın içerik almasına izin verecektir.

Hisse Sözleşmesine destek eklemek için -

  • Çift tıklayın package.appmanifest dosya.

  • Şuraya git Declarationssekmesi. SeçShare Target -den Available Declarations listeye tıklayın ve Add buton.

  • Uygulamanızın herhangi bir dosyayı paylaşılan içerik olarak almasını istiyorsanız, dosya türlerini ve veri formatlarını belirtebilirsiniz.

  • Desteklediğiniz Veri Biçimlerini belirtmek için şu adrese gidin: Data Formats bölümü Declarations sayfa ve tıklayın Add New.

  • Desteklediğiniz veri formatının adını yazın. Örneğin,"Text".

  • Desteklediğiniz dosya türünü belirtmek için, Supported File Types bölümü Declarations sayfa, tıklayın Add New.

  • Desteklemek istediğiniz dosya adı uzantısını yazın, örneğin, .pdf

  • Desteklemek istiyorsan All file türleri, kontrol edin SupportsAnyFileType Kutu.

  • Bir kullanıcı uygulamanızı veri paylaşımı için hedef uygulama olarak seçtiğinde OnShareTargetActivated olay tetiklendi.

  • Uygulamanızın, kullanıcının paylaşmak istediği verileri işlemek için bu olayı işlemesi gerekir.

protected override async void OnShareTargetActivated(ShareTargetActivatedEventArgs args) { 
   // Code to handle activation goes here.  
}
  • Kullanıcının herhangi bir uygulamayla paylaşmak istediği tüm veriler bir ShareOperationnesne. Ayrıca içerdiği verilerin formatını da kontrol edebilirsiniz.

Aşağıda verilen, işleyen kod parçacığıdır. shared content düz metin biçiminde.

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; 
}

Bir web bağlantısını paylaşacak yeni bir UWP projesi oluşturarak basit bir örneğe bakalım.

Aşağıda, bazı özelliklerle bir düğmenin oluşturulduğu XAML kodu verilmiştir.

<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>

Düğme tıklama olayının uygulandığı C # kodu ve bir URI paylaşım kodu aşağıda verilmiştir.

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(); 
      }
		
   } 
}

Yukarıdaki kod derlenip çalıştırıldığında, emülatörde aşağıdaki sayfayı göreceksiniz.

Butona tıklandığında hangi uygulamada paylaşma seçenekleri sunulur.

Mesajlaşmaya tıklayın ve bağlantıyı herhangi birine gönderebileceğiniz aşağıdaki pencere görüntülenecektir.

Bu bölümde, mevcut uygulama Windows 8.1 uygulamanızı Evrensel Windows Platformuna (UWP) nasıl taşıyacağınızı öğreneceğiz. Müşterilerinizin her tür cihaza yükleyebileceği tek bir Windows 10 uygulama paketi oluşturabilirsiniz.

Uygulamanızı Windows 10 UWP'ye taşıdıktan sonra, uygulamanız şunlardan yararlanacaktır:

  • Heyecan verici yeni donanım
  • Harika para kazanma fırsatları
  • Modern bir API seti,
  • Uyarlanabilir UI kontrolleri,
  • Uyarlanabilir Tasarım ve Kod
  • Fare, klavye, dokunma ve konuşma gibi bir dizi giriş yöntemi.

Windows 8.x Projesini UWP Projesine Taşıma

Mevcut Windows 8.x uygulamanızı Evrensel Windows Platformuna (UWP) taşımak için iki seçenek vardır.

Option 1 - Biri, Visual Studio'da yeni bir Windows 10 projesi oluşturmak ve dosyalarınızı buna kopyalamaktır.

Option 2 - Diğer seçenek, uygulama paketi bildirimi dahil mevcut proje dosyalarınızın bir kopyasını düzenlemektir.

Aşağıda, ilk seçeneği kullanırken ana adımlar verilmiştir.

  • Microsoft Visual Studio 2015'i başlatın ve adıyla yeni bir Boş Uygulama (Windows Universal) projesi oluşturun UWPBookStore.

  • Yeni projeniz, tüm cihaz ailelerinde çalışacak bir uygulama paketi (bir appx dosyası) oluşturur.

  • Universal 8.1 uygulama projenizde, yeniden kullanmak istediğiniz tüm kaynak kod dosyalarını ve görsel varlık dosyalarını tanımlayın. Aşağıda gösterilen, üç projesi olan örnek bir uygulamadır. Biri Windows için, ikincisi mobil için ve üçüncüsü Windows ve mobil için paylaşılan projedir.

  • Bu uygulamayı telefonda çalıştırdıktan sonra aşağıdaki pencereyi göreceksiniz.

  • Pencere uygulamasını çalıştırdıktan sonra aşağıdaki uygulamayı göreceksiniz.

  • Şimdi, yeni oluşturulan UWP proje uygulamasını açın
  • Paylaşılan Projeden klasörü kopyalayın Assets\CoverImageskitap kapak resmi (.png) dosyalarını içeren. Ayrıca kopyalayınViewModel klasör ve MainPage.xaml ve dosyayı hedefte değiştirin.

  • Windows projesinden kopyalayın BookstoreStyles.xaml. Bu dosyadaki tüm kaynak anahtarları bir Windows 10 uygulamasında çözülecektir. Eşdeğer olanlardan bazılarıWindowsPhone dosya olmayacak.

  • İçinde Solution Explorer, emin olmak Show All Files değiştirildi ON.

  • Kopyaladığınız dosyaları seçin, üzerlerine sağ tıklayın ve Include In Project Aşağıda gösterildiği gibi.

  • Bu, otomatik olarak içerdikleri klasörleri içerecektir. Daha sonra geçiş yapabilirsinizShow All Files ‘OFF’ Eğer hoşuna giderse.

  • Şimdi proje yapınız şu şekilde görünecek: Solution Explorer.

  • Yeni kopyaladığınız kaynak kodunu ve biçimlendirme dosyalarını düzenleyin ve referansları değiştirin. Bookstore1_81 ad alanı UWPBookStore ad alanı.

  • En kolay yol, isim boşluğunu değiştirmektir. Replace In Filesözelliği. Görünüm modelinde kod değişikliğine gerek yoktur.

  • Şimdi, yukarıdaki kod çalıştırıldığında, onu yerel bir makinede ve aşağıda gösterildiği gibi bir cep telefonunda çalıştırabilirsiniz.

Şimdi ikinci seçenek, uygulama paketi bildirimi dahil mevcut proje dosyalarınızın bir kopyasını düzenlemektir. Proje dosyası vepackage.appmanifest dosya Windows / phone 8.x'ten Windows 10'a taşınırken bazı değişikliklere ihtiyaç duyar.

Microsoft, mevcut uygulamanızı taşırken çok yararlı olan UWP proje yükseltme yardımcı programını sağlamıştır. Yardımcı program github.com adresinden indirilebilir .

Daha iyi anlamak için yukarıdaki örnekleri adım adım izlemenizi tavsiye ederiz.