Makale Özeti

Bu makalemizde geliştiricilerin WPF 'i tercih etme nedenlerinden 4 - 3 - 2 ve 1 puan alan özelliklerini incelemeye başlayacağız. Bu yazılarımızı incelerken en yüksek puandan en alt puan alan özelliğe doğru incelenmiştir.

Makale

4 Puan - Data-Driven UI (Veri Güdümlü UI)

Biz diğer başlıklarımızda WPF ile içerik modellerini değiştirebilme olanağımızın olduğunu görmüştük. Fakat bu içerikler kod içerisinde olmakta ve herhangi bir dış faktörden etkilenmemekteydi. Günümüz uygulamaların da ise kullanıcıdan alınan verilerin çok değerli olduğunu ve bu verilere göre işlemlerimizi yaptığımızı unutmamız gerekmektedir. Örneğin bir textBox ‘a girilen verinin web uygulamalarında kullanılan Session gibi verileri en son kullanılacak yere kadar bellekte tutarak kullandırabilmesini sağlamamız gerekebilir. Bu tür durumlar TextBox ‘ın içeriğini dinamik olarak okuyabilmemiz gerekmektedir. Böyle bir uygulama geliştirmek istediğimiz durumlarda ise binding işlemi yapmamız yeterli olacaktır.

Dinamik kontrolleri yalnızca textBox için değil buton gibi diğer form kontrolleri içinde kullanılabilmemiz gerekmektedir. Eğer ki herhangi bir verimiz olmadan form kontrollerine bağlama işlemi yaptığımızda aşağıdaki gibi bir ekran görüntüsü oluşacaktır.



Kullanici sınıfının içerisinde ki veriyi okuyamadığı için butonun üzerinde böyle bir mesaj vermiştir. Biz elimizdeki verilerden isim değerini almak istersek ise aşağıdaki gibi kod yazmamız gerekirdi.

Linq
public class Kullanici
{
   private string m_name;
   private DateTime m_dateOfBirth;

   public string Name
   {
      get { return m_name; }
      set { m_name = value; }
   }

   public DateTime DateOfBirth
   {
      get { return m_dateOfBirth; }
      set { m_dateOfBirth = value; }
   }
}

...

Kullanici turhal = new Kullanici();
turhal.Name = "Turhal";
turhal.DateOfBirth = new DateTime(1987, 07, 19);
myButton.Content = Turhal;

XAML
<Button x:Name="benimButon">
   <Button.ContentTemplate>
      <DataTemplate>
         <TextBlock Text="{Binding Name}" />
      </DataTemplate>
   </Button.ContentTemplate>
</Button>

Yukarıdaki kod bloğu sayesinde istediğimiz veriyi kullanıcıya sunabilmemiz mümkündür. İşlemlerimizi biraz daha farklı yapalım ve butonun üzerinde bu sefer kullanıcının adı ve doğum tarihini gösteren kod bloğuna göz atalım.

XAML
<Window.Resources>
   <DataTemplate DataType="{x:Type local:Kullanici}">
      <StackPanel Orientation="Horizontal">
         <TextBlock FontWeight="Bold">Isim:</TextBlock>
         <TextBlock Text="{Binding Name}" Margin="2,0,10,0" />
         <TextBlock FontWeight="Bold">Dogum Tarihi:</TextBlock>
         <TextBlock Text="{Binding DateOfBirth}" Margin="2,0,10,0" />
      </StackPanel>
   </DataTemplate>
</Window.Resources>

Kod parçacığımızın derlenmesi sonucunda karşımıza çıkan ekran görüntüsü ise aşağıdaki gibidir.



Yukarıda bahsettiğimiz örnekler dâhil olmak üzere Win32 uygulamalarında kullanmış olduğumuz bütün kontrollere bu bağlama işlemlerini yapabilmemiz mümkündür.

3 Puan - İstikrarlı Stiller

Eminim bu yazıyı okuyan herkes en az bir kerede olsa Microsoft Word programının kelime sayacını kullanmıştır. Bu sayaç kelimeleri kontroller ederken herhangi bir yazı formatı diğerlerinden farklı olsa da temelinde netin olduğu için o yazıda kelime olarak sayıyor ve devam ediyordu. Bu düşünceden yola çıkarak stiller ile özelleştirdiğimiz form kontrollerinin aslında birbirlerinden hiç farkları yokturlar. En nihayetinde yapabilecekleri alt yapının sınırlandırdığı ölçüdedir. Eğer ki geliştirici kendine özel sınıfını oluşturup kullanıyorsa durum farklı olabilir. Biz geneli düşünerek konumuzu incelemeye devam edelim.

WPF uygulamalarında da aynı durum söz konusudur. Bir kaydırma çubuğunun (slider) maksimum değeri WPF uygulamasında 200 ise Win32 uygulamasında da 200 olacaktır. Ayrıca biz aksini belirtmediğimiz sürece de aynı işlemleri yapacaklardır. Aralarında ki en önemli fark stil dosyalarının kullanım biçimi olmaktadır. Win32 uygulamalarında da stil dosyaları resimler ya da çizim işlemleri ile yapılabilmesi mümkündür. Fakat işlemlerimizi bu biçimde de yapmamız gerektiğini Çizim modelleri konusunda uzunca incelemiştik. WPF, stil dosyalarını kullanırken XAML kod bloğunda CSS gibi bir kaynak dosyası oluşturuyor ve bu stil dosyası kullanılmak istendiğinde kaynak dosyasına Binding yapılarak sınırsız kez kullanımına olanak tanıyordur. Şimdi bu işlemleri nasıl gerçekleştirdiği ile ilgili kod bloklarımıza göz atalım.

XAML
<Window.Resources>
   <Style x:Key="butonaStil">
   <Setter Property="Control.FontFamily"
    Value="Old English Text MT" />
      <Setter Property="Control.FontSize" Value="18" />
   </Style>
</Window.Resources>

Şimdi ise oluşturmuş olduğumuz stil dosyasını form kontrolüne nasıl ekleyebileceğimize göz atalım.

XAML
<Button Style="{StaticResource butonaStil}">Tikla!</Button>

Bu seferki örneğimizde ise stil özelliği tanımlayarak hazırlamış olduğumuz stillerin form üzerindeki bütün butonlar için gerçeklenmesi ile ilgili olacaktır. Kod bloğunda bu işlemi yapan yer karartılmıştır.

XAML
<Window.Resources>
   <!-- Bütün butonlara stilleri veriliyor -->
   <Style TargetType="{x:Type Button}">
   <Setter Property="Control.FontFamily"
      Value="Old English Text MT" />
   <Setter Property="Control.FontSize" Value="18" />
   <Setter Property="Background"
      Value="VerticalGradient Red Black" />
   <Setter Property="Foreground"
      Value="VerticalGradient Yellow Orange" />
   </Style>
</Window.Resources>
...
<!-- Manüel olarak hiç bir stil eklenmemiştir.-->
<Button>Tikla!</Button>

Belirtmiş olduğumuz bu yöntem sayesinde istediğimiz form kontrolüne hazırladığımız özellikleri ve değerleri atayabilmemiz mümkündür. Yukarıdaki örneklerden yararlanılarak stil dosyalarının manüel ve özellik olarak nasıl kullanılacağı öğrenmiş oluyoruz. Şimdi vereceğimiz örnekte ise butonun en çok kullanılan özelliklerine dâhil stil dosyasının nasıl kullanılacağına dair olacaktır.

XAML
<Window.Resources>
   <Style TargetType="{x:Type Button}">
   <Setter Property="Button.Template">
      <Setter.Value>
      <ControlTemplate>
         <Grid>
         <Rectangle Fill="VerticalGradient White Red"
           Stroke="DarkRed"
           RadiusX="10" RadiusY="10" />
         <ContentPresenter
           Content="{TemplateBinding Button.Content}"
           Margin="{TemplateBinding Padding}"
           HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
           VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
         </Grid>
      </ControlTemplate>
      </Setter.Value>
   </Setter>
   </Style>
</Window.Resources>

Yukarıdaki kod bloğunu WPF uygulaması ile oluşturulduğunda gelen APP.XAML dosyasının içerisinde kullanırsanız kolaylıkla bu stilleri form kontrollerinin içerisinde kullanabilmeniz mümkün olacaktır.

Genel olarak stil dosyalarını nasıl kullanacağımıza değinmeye çalıştık. Animasyonlarla birlikte form kontrollerini kullanmak isteyen geliştiriciler için bu özellik oldukça yararlı olacaktır.

2 Puan - Tetikleyiciler (Triggers)

Tetikleyiciler uygulamamıza bir olay gerçekleşeceği zaman neler yapılabileceğini makine dili ile anlatabilen yapıdır. Tetikleyiciler WPF bünyesinde animasyon işlemlerinde ve stil dosyalarında kullanılmaktadır. Stil dosyalarında kullanım şekli genellikle fare hareketleri üzerine olmaktadır. Şimdi bu hareketler ile ilgili bir örneğe göz atalım.

XAML
<Style TargetType="{x:Type Button}">
   <Style.Triggers>
   <Trigger Property="IsMouseOver" Value="True">
      <Setter Property="Background" Value="Green" />
   </Trigger>
   </Style.Triggers>
</Style>

Tetikleyicilerin animasyon işlemlerinde de kullanıldığında bahsetmiştik. Animasyon işlemlerinde kullanımı ile ilgili bir örnek vermek gerekirse form üzerinde bulunan bir butonun fare üzerine getirilip çekildikten sonra ortadan kaybolması olabilir. Bu tür örnekleri arttırabilmemiz mümkündür. Şimdi ise animasyon işlemlerinde tetikleyicileri nasıl kullanacağımıza ilişkin oluşturduğumuz kod bloğuna göz atalım.

XAML
<Rectangle Fill="Blue" Height="100" Width="200" Opacity="0.5">
   <Rectangle.Triggers>
   <EventTrigger RoutedEvent="Mouse.MouseEnter">
      <BeginStoryboard>
         <Storyboard TargetProperty="(Rectangle.Opacity)">
            <DoubleAnimation To="1" Duration="0:0:1" />
         </Storyboard>
      </BeginStoryboard>
   </EventTrigger>
   <EventTrigger RoutedEvent="Mouse.MouseLeave">
      <BeginStoryboard>
         <Storyboard TargetProperty="(Rectangle.Opacity)">
            <DoubleAnimation To="0.5" Duration="0:0:1" />
         </Storyboard>
      </BeginStoryboard>
   </EventTrigger>
   </Rectangle.Triggers>
</Rectangle>

Yukarıdaki kod bloğu sonucunda uygulamamızda form üzerinde yer alan butonun üzerinden fare çekildiği zaman belirli bir süre içerisinde yarı şeffaflık kazandığını gözlemleyebileceğiz.

Tetikleyicileri WPF bünyesinde neden kullanmalıyız sorusuna gelirsek. Özellikle tasarımcıların Microsoft tarafından çıkartılmış olan Expression Blend veya başka 3. Parti uygulamalar aracılığı ile oluşturacakları animasyon işlemlerini geliştiricilere verdikleri zaman geliştiricilerde XAML yardımı ile bu yapıları anlayabilip kullanabilmesine olanak tanımaktadır. Ayrıca geliştiriciler kendilerine verilen animasyon dosyalarında hoşlarına gitmeyen ufak hatalar olması durumunda ise tekrardan tasarımcıya göndermek yerine XAML kod üzerinde gerekli değişiklikleri yaparak kullanabilmesine olanak tanır. Kısaca Tetikleyiciler, tasarımcı ile geliştirici arasında animasyon işlemlerinde anlaşılabilirlik kolaylığı sağlamaktadır.

1 Puan - Bildirime Dayalı Programlama (Declarative Programming)

Bildirime dayalı programlama yapısı WPF mimarisinde yer almaktadır. Bu yapı sayesinde geliştirmiş olduğumuz uygulamalarda “neden” ve “nasıl” gibi sorunların cevaplarını ararız. Bu tür araştırmalar ise bize en çok SQL ‘i hatırlatmaktadır. SQL sorgularını neden yaptığımızı örnekler ile hatırlarsanız ya bir ürünü kimin veya neden satın aldığı gibi soruları cevaplardık ya da bir olgunun nasıl gerçekleşebileceği sorunun cevaplarını arardık. Kısacası SQL sorgularımız sonucunda bize geri dönen bilgiler ışığında yapacaklarımıza devam edebilmemiz mümkündür. Bu yapı bildirime dayalı programlamaya verilebilecek en iyi örneklerden biridir.

Uygulama geliştiren geliştiriciler zaten bildirime dayalı programlama yapısına güvenmekteydiler. Verileri göstereceğimiz bir ekran oluşturmak istediğimiz de ilk olarak listeleyeceğimiz bileşen içeriği boş bir biçimde ekrana çizilir. Sonrasında içeriği veri ile doldurulacağı için veriyi alacağı bölüme bağlanarak verileri çeker ve bu çektiği verileri listeleme yapacağı bileşene sırası ile eklemeye başlar. Bu ekleme işlemi istenen veriler sonuçlanana kadar devam eder.

Yukarıda bahsettiğimiz listeleme işlemini daha önceden GridView ile yapabilmemiz mümkündü, WPF de ise GridView ‘e ek olarak bizim harici olarak oluşturabildiğimiz grid yapıları eklenmiştir. Bu Gridi oluştururken yapmamız gereken satır ve sütunlarını belirlemek ve verileri içlerine bağlamak olacaktır. Şimdi satır ve sütunu WPF ’de XAML yardımıyla nasıl oluşturabileceğimize göz atalım.

XAML
<Grid.ColumnDefintions>
   <ColumnDefinition Width="*" />
   <ColumnDefinition Width="5*" />
</Grid.ColumnDefintions>

<Grid.RowDefintions>
   <RowDefinition Height="Auto" />
   <RowDefinition Height="*" />
</Grid.RowDefintions>

Oluşturduğumuz grid içerisinde satır ve sütunlar harici olarak bizim XAML kod bölümünde oluşturduğumuz biçimde çizilmiştir. Bu grid, genişliğini ve enini formun boyutu ile doğru orantılı olarak arttırıp azaltmaktadır.

Bildirime dayalı programlama yapısı .net Framework oluşturulduğundan bu yana yapının içerisinde bulunduğu için bunun dahil edilmemesini düşünmek çok mantıksız olacaktır. Çünkü sağladığı kolaylıkların ve performans artışının ne kadar yüksek olduğunu unutmamız gerekmektedir. Bizlerde kodlarımızı yazarken bu özelliği unutmadan hareket etmemiz gerekmektedir.

Son olarak ise XAML sayesinde veri okuma bileşenlerini animasyonlu ve süslü bir biçimde yapabilmesine olanak tanıyor.

Sonuç olarak bir geliştiricinin neden WPF ‘i tercih etmesi sorusuna karşılım gelen 10 cevabı en yüksek önemden en alt öneme doğru sıralamaya çalıştık.

Umarım Yararlı olmuştur.
Turhal TEMİZER