C#nedir?com
 
YAZAR HAKKINDA
Turhal Temizer
Turhal Temizer
http://www.turhaltemizer.com
İletişme geçmek için tıklayın.
92 Makalesi yayınlanmakta.
Yazar hakkında detaylı bilgi için tıklayın.
Yayınlanan diğer makaleleri için tıklayın.
İlgili etiketler: animasyon border=0 cellpadding=5 cellspacing=0 farkli grafik islemi islemleri islemlerini isletim olacaktir. ortadan sayesinde sonucunda windows .NET 3.x Turhal Temizer
 
YAZI HAKKINDA
Türü : Makale
Serbest Köşede C#nedir?com üyelerinin hazırladıkları yazılar yayınlanır. Bu yazılar editör incelemesine girmeden yayınlanır.
Seviyesi : Başlangıç
Kategori : .NET 3.x
Yayınlanma Tarihi : 21.2.2008
Okunma Sayısı : 20885
Yorum Sayısı : 0     yorum yaz
Site İçi AramaSİTE İÇİ ARAMA
Üye Girişini AçÜye GİRİŞİ
Üye girişi için tıklayın.
Kullanıcı Adı
Şifre
 
Beni her zaman hatırla
Bir hafta boyunca kullanıcı bilgilerinizi kullanıcı çıkışı yapana kadar hatırlar. (Paylaşılan bilgisayarlarda önerilmez.)
 
Şifremi / Kullanıcı Adımı unuttum.
 
.net TV RSS Serbest KÖŞE (?)
Serbest Köşede C#nedir?com üyelerinin hazırladıkları yazılar yayınlanır. Bu yazılar editör incelemesine girmeden yayınlanır.
emre TAŞ
XML - Deniz Kılınç
emre TAŞ
yazının devamı >
emre TAŞ
Decompiling and Reverse Engineering .Net Radyo
emre TAŞ
yazının devamı >
emre TAŞ
Masaüstü mü ? İnternet Mi? .Net Radyo
emre TAŞ
yazının devamı >
emre TAŞ
.Net Kavramları - .Net Radyo
emre TAŞ
yazının devamı >
emre TAŞ
Yeni Başlayanlar için - .Net Radyo
emre TAŞ
yazının devamı >
Makale Gönder Bende Yazmak İstiyorum
.net TV RSSBlogroll
Turhal Temizer 'in Blogu
ChatBot UI Sample 15.7.2018
Turhal Temizer 'in Blogu
C# – IRR Function 15.7.2018
Burak Selim Şenyurt
Stream ve Pipe Mevzusu 15.7.2018
Burak Selim Şenyurt
Pug, Pug, Pug 15.7.2018
  Diğer Herşey
Sponsorlar
BT Akademi
Medya Portakal
Video Hosting Sponsoru
Csharpnedir.com bir Ineta üyesidir
Uzman Abi
Her Yönüyle C# - Sefer Algan
Neden Geliştiriciler WPF 'i Tercih Etmeli?
 
Kapat
Sayfayı Yazdır Sık Kullanılanlara Ekle Arkadaşıma Gönder MySpace Del.Ico.Us Digg Facebook Google Mixx Reddit StumbleUpon
Win – 32 ile karşımıza çıkan UI grafikleri ve bu yapı kullanılarak oluşturulmuş olan Windows XP yaklaşık 20 yıldır benzerdir. Bu benzerlikler sonucunda bizlere sürekli olarak grafik konusunda birbirlerinde farkı olmayan programlar ve işletim sistemleri sunulmaktaydı. Programların grafiklerinde herhangi bir gelişme gözlenmezken işlemci ve grafik kartı üreticileri sınırları zorlayan ürünler üretmeye başlamışlardı. Bunların başında çift çekirdekli işlemciler ve çift grafik işlemcisi (GPU) kullanan ekran kartları gelmektedir. Tabii bu gelişimler esnasında işletim sistemleri ve geliştiriciler tarafında oluşturulmuş yazılımların bunları kullanmaması çok mantıksız bir düşünce gibi olurdu.

Yukarıda bahsettiğimiz gelişmeler sonucunda Microsoft yeni çıkaracağı (Bir yılını doldurmuş olan işletim sistemi) Windows Vista ‘da grafik işlemlerinin daha önceki sürümlerden farklı olarak ilk olarak grafik kartına yükleneceği açıklanmıştı. Bu durum Windows işletim sistemleri için bir devrim niteliğindeydi. Bu sayede formlar, butonlar ve diğer bütün kontroller grafik işlemleri kullanıyorlarsa grafik kartına ve işletim sisteminde dahil olarak gelen PresentationFontCache.dll ‘ine yüklenecekti. Bu işlem grafik işlemlerinin gerçekleşmesi anında CPU ‘u çok büyük bir yükten kurtarmış olacaktır.

İşletim sistemi konusunda bu gelişimler yaşanırken geliştiriciler için nelerin yapılacağı merak konusuydu. Çünkü bizler grafik konusunda yapacağımız işlemler için CPU ‘u kullanmak zorundaydık. Bu da yapacağımız uygulamalarda performans düşüklüğüne sebep olmaktaydı. Bu durumdan kurtulmakta yeni Framework ‘ün içeriğinin açıklanması ile olmuştu. Artık Avalon kod adında yeni bir yapımız olacak ve bu yapı sayesinde bizlerde grafik işlemlerimizde grafik kartını kullanabilecektik. 2007 yılının başlarında .net Framework 3,0 çıkmış ve AVALON kod adlı yapımız Windows Presentation Foundation adını almıştı. Daha sonra ise 2007 yılının sonlarında Visual Studio 2008 ile .net Framework 3,5 yapısı da bitirilmişti. Artık WPF ‘i rahatlıkla kullanabilmemiz mümkündü.

WPF ‘in temel yapısı ve yapabilecekleri ile ilgili daha önceki makalelerimizde ayrıntılı bir biçimde bahsetmeye çalışmıştık. Bu sefer ise yukarıdaki bilgiler ışığında geliştiricilerin neden WPF ile uygulama geliştirmesi gerektiğini açıklayabilmeye çalışacağız. Bu açıklamayı yaparken ise en değerli 10 özelliğini incelerken Win32 ile neler yapabileceğine de öğrenmiş olacağız.

10. İleri Düzey Grafikler

Yıllarca alışık olduğumuz grafiklerden yukarıdaki paragraflarda bahsetmeye çalışmıştık. Bu grafik işlemleri oluşturulurken drawing isim alanı (namespace) kullanılmaktaydı. Bu kullanım için ise bütün metotlarının ayrıntılı bir biçimde bilinmesi gerekiyordu. Ayrıca bu isim alanını bilmemiz sadece 2D işlemlerimizi yapabilmemizi olanak tanıyacaktır. Farklı ve daha çok boyutta grafik kullanmak istediğimizde ise daha birçok API ve isim alanı öğrenmek zorunda kalıyorduk. Bu durumun ortadan kaldırılması amacıyla GDI+ içeriğinde birçok yenilik getirilmiştir. Bu yeniliklerin en önemlisi ise daha önceden bizlerin uzun işlemler ile oluşturmuş olduğumuz grafik fonksiyonlarının içeriğine eklenmiş olmasıydı.

GDI+ ‘ta ilk olarak 2D fonksiyonlar eklenmişti. Çünkü bu grafik fonksiyonları daha önceki sürümlerde oldukça fazla kullanılmıştı. Bazı geliştiriciler raporlamalar için hazırlanmış olan 3. Parti yazılımların yerine bile GDI+ ile hazırladıkları grafikleri kullanmaktaydılar. Ayrıca WPF içinde sadece grafik çizimleri değil form kontrollerinin özelleştirilmesi gibi özellikler kullanılacaktı. Açıkladığımız bu sebeplerden ötürüdür ki WPF için geliştirilen GDI+ ta ilk öncelik 2D işlemlerine verilmiştir.

GDI+ içerisinde Bezier eğrileri, karmaşık daireler, yazılar ve daha birçok çizim işlemi bulunmaktadır. Yazı işlemleri için ise vektörsel çizimlerde olduğu gibi anti – aliasing özelliği de eklenmiştir. Bu özellik sayesinde yakınlaştırılan olan yazılarda ve çizilen grafiklerin kenarlarında oluşmakta olan kırılmalar ortadan kalkacak ve pürüzsüz bir görünüme sahip grafikler oluşacaktır. Bu pürüzsüzleştirme işlemini daha önceleri yapmak oldukça zahmet bir işti ve yapılan işlemler bizlere uzun zamanlar kaybettirmekteydi. Artık grafik işlemlerini kolaylık ile yapabilecektik.

GDI+ ve XAML ile WPF ‘de eskiden yapmak istediğimizde oldukça karışık olan fakat yeni yapımız ile oldukça kolay yapabileceğimiz bir uygulamanın örneğine göz atalım.

XAML
<DrawingBrush Viewbox="0,0,1,1" ViewboxUnits="Absolute" Viewport="0,0,0.07,0.2" TileMode="Tile">
   <DrawingBrush.Drawing>
       <GeometryDrawing Brush="LightGreen"> <!--ikinci ekran görüntüsünde yararlanılacaktır.--!>
          <GeometryDrawing.Geometry>
             <RectangleGeometry Rect="0,0,1,0.6" />
          </GeometryDrawing.Geometry>
       </GeometryDrawing>
    </DrawingBrush.Drawing>
</DrawingBrush>

Yapmış olduğumuz bu uygulama sonucunda karşımıza çıkan örnek ise aşağıdaki gibidir.



Bu örneğimizde, şeffaflık eklenmiş yazı ile dolgu rengini değiştirdiğimizde ise aşağıdaki gibi bir ekran görüntüsü ile karşılaşırız.



Böyle güzel özelliklerinin olması dışında kısıtlanan ufak bir özelliği de var. Yukarıdaki örnek kodumuza dikkat ettiyseniz GDI+ kolaylık ile kullanılabilmektedir. Bu kolaylıktan ötürü .net 3,x isim alanları kullanıldığı durumlarda eskiden olduğu gibi Win32 API ’lerini direkt olarak kullanamıyoruz. Eğer ki kullanmak istersek Windows.System.Shapes isim alanını kaldırıp eskiden kullanmış olduğumuz Windows.System.Drawing isim alanını tanıtmamız 2D işlemler için yeterli olacaktır. Diğer durumlar içinde yeni nesil isim alanları kaldırılıp yerlerine eskileri eklenebilmektedir. Fakat yeni altyapı ile gelen isim alanları hem performans hem de kolaylık açısından bakıldığında geliştiricilere büyük katkıları bulunmaktadır.

GDI ve GDI+ ‘ı eskiden kullandığımız zamanlarda rectangle sınıfı ile çizimlerimizi yapardık. Bu çizim işlemleri sırasında piksellere çizgilerin nasıl yerleştirileceği konusunda büyük sorunlar yaşanırdı. Bu sorunları ortadan gidermek için ise çizginin geçtiği karelere bakılır ve bu karelerin içerisindeki dolgu yüzdesi fazla ise o kare seçilir ve devam edilirdi. Bu yöntem dışında bir de tek kare seçimi yerine birden fazla kareden yararlanılarak yapılan yöntemler kullanılırdı. Bu yöntemler mantıksal olarak uygun yöntemlermiş gibi gözükse de pratikte istenilen sonuçları vermemektedir. Çizilen grafiklerin yaklaştırılması durumunda çizgiler üzerindeki kırılmalar göze çarpıyor ve kusursuz bir çizimi yaşamamış oluyoruz. Bu sorunlar yeni altyapı ile ortadan kaldırılmış durumdadır.

Yukarıda açıkladığımız bu kadar bilginin ışığında kafamıza bir soru takılıyor. Soru ise,Bu grafik işlemlerini form kontrolleri üzerinde de kullanabilir miyiz? biçiminde oluyor. Sorunun cevabı ise kesinlikle evet olacaktır. Çünkü WPF ile birlikte bizlere XAML kod ortamı sunulmaktadır. Bu kod ortamında grafik işlemlerini kullanabilmemiz dışında form kontrollerini dilediğimiz biçimde özelleştirebilmemizde mümkündür. Bu olanaklar yardımıyla form kontrollerini istediğimiz şekilde değiştirebilmemiz ve özelleştirebilmemize olanak vardır.

Bu bilgiler ışında WPF form kontrolüne şeffaflık özelliği eklenerek değiştirilmiş yeni görünüme ait ekran görüntüsü aşağıdadır.



Oluşturabildiğimiz farklı form kontrollerinin dışında bu kontrollerin boyutları konusunda da iyileştirmeler yapılmıştır. Daha önceden hazırlamış olduğumuz uygulamalarda form kontrollerimizin çözünürlük kaliteleri 150dpi iken yeni nesil form kontrolleri ile oluşturabildiklerimizin kaliteleri 200dpi olmuştur. Bu durum ise son kullanıcıların daha düşük çözünürlüklü bir ekran görüntüsü kullandıkların karşılarındaki kontrollerin kenarlarında oluşan kırılmış yapıyı görmemeleri anlamına gelmektedir. Aynı şekilde uygulamanın üzerinde bir noktaya yakınlaştırma yapıldığı zamanda bu durum söz konusu olacaktır.

Grafik işlemlerinin dışında bizler formlarımızın üzerinde animasyon işlemleri yapmak istersek neler yapmalıyız sorusuna değinmeye çalışacağız. Eskiden hazırlamış olduğumuz animasyonlar için GDI, GDI+ veya yönetilebilir DirectX APIleri kullanmamız gerekiyordu. Yine bu işlemlerde grafik işlemleri gibi hazırlanması oldukça zor ve zahmetliydi. Ayrıca bir etken daha var. Eski altyapılar grafik işlemleri ve animasyon işlemlerinde ilk olarak grafik kartı yerine işlemciyi kullanmalarıydı. Bu durumda kullanış olduğumuz bilgisayarın performansında büyük düşüşler gözlenmekteydi. Yukarıdaki paragraflarda neden grafik kartını kullandığını uzunca anlatmıştık. Şimdi ise animasyon işlemlerini XAML yardımı ile ne kadar kolay yapabileceğimize bir örnek ile göz atalım. Örneğimizde yatay eksende bizim belirdiğimiz sürede genişleyen bir dikdörtgen yapılacaktır.

XAML
<Rectangle Fill="Red" Height="100">
   <Rectangle.Triggers>
      <EventTrigger
         RoutedEvent="Rectangle.Loaded">
            <BeginStoryboard>
               <Storyboard TargetProperty=
                 "(Rectangle.Width)">
                  <DoubleAnimation From="20" To="200"
                    Duration="0:0:5"
                    RepeatBehavior="Forever" />
               </Storyboard>
            </BeginStoryboard>
         </EventTrigger>
      </Rectangle.Triggers>
</Rectangle>

Animasyon işlemleri dışında medya dosyalarını da MediaElement yardımıyla çağırabilmemiz mümkündür. Şimdi de bu işlemi nasıl yaptığımızı XAML kod bloğunda görelim.

XAML
<MediaElement Name="myVideo"
   Source="C:\WINDOWS\system32\oobe\intro.wmv"
   Width="450" Height="400" >

Son örneğimiz ile ileri düzey grafikler başlığını bitirmiş oluyoruz. Sadece yukarıda belirtmiş olduğumuz özellikler değil dönüşüm işlemlerinden kontrollere atanan başka stil özelliklerine kadar yapabileceğimiz birçok işlem vardır. Fakat temel bilgi teşkil etmesi açısında yukarıda anlattıklarımızın yeterli olduğunu düşünüyoruz. Bu konular hakkında daha ayrıntı bilgi edinmek isterseniz WPF hakkındaki diğer yazılarımızı okuyabilirsiniz.

9. Çizim Nesnesi (Drawing Object)

Çizim nesnesinin nasıl kullanıldığını iki biçimde incelememiz daha doğru olacaktır. Birincisi WPF öncesi nasıl kullandığımız, ikincisi ile WPF ile nasıl kullandığımız olacaktır.

WPF öncesi durum için ilk olarak modellenmiş durum şemasına göz atalım;



WPF ‘in grafik sistemi tam olarak kullanılabilen bir yapı olduğundan uzunca bahsedilmişti. WPF öncesi durumda ise sistem tabanlı uygulamalar ile karşılaşmaktaydı. Bu uygulamalarda çizim işlemleri ilk olarak işletim sistemine gönderilir daha sonrasında GDI veya GDI+ gönderilmek üzere uygulamaya işlenmiş olarak geri gönderilirdi. Bu işlenmiş verileri GDI ailesi ile şekiller oluşturulduktan sonra grafik karta gönderilir ve çizim işlemi yapılırdı. Fakat bu durumda ilk olarak GDI kullanıldığı için bu işlemlerin gerçekleşmesi esnasında işleminin tamamını kullanma gereksinimi hissedilmektedir. Böyle bir olayın gerçekleşmesi ise hazırlanmış olan uygulamanın grafik işlemleri esnasında gerçek performansından uzak kalmasına sebep olacaktır. Peki, şu anda kullanılan uygulamalar bu durumları nasıl çözüyorlar. OpenGL ve DirectX APIleri kullanılarak bu yoğunluktan kurtarılabilmesi mümkün oluyordu. Ama kafamıza başka bir soru geliyor. Bu soru; “Uygulamamızda sadece tek bir yerde çizim işlemi uygulayacak bile olsak bu APIleri öğrenmek zorunda mı kalacağız” biçiminde oluyor. Maalesef bu sorunun cevabı evet oluyor.
Başka alternatif çözüm ise WPF kullanmaktadır. WPF ’in çizim nesnesini kullanırken nasıl bir yol izlediğine dair modellenmiş şemasına göz atalım;



WPF kullanılırken arka planda çalışan mantık bir öncekine göre daha kolay gibi gözüküyor. Şimdi bu kolaylığın sebeplerini araştıralım.

Çizim nesnesinin uygulamanın içerisinde oluşturulması GDI ailesine yapılacak olan yüklenmeyi ortadan kaldırmaktadır. Bunun sebebi ise WPF ve XAML içerisinde GDI+ ’in en üst seviyede kullanılıyor olması ve anlık olarak çizilen grafiklerin oluşturulabilmesidir. Bu durum çizim işlemi gerçekleştirilirken işlemciye olan yüklenmeyi ortadan kaldırmaktadır. Ayrıca işletim sistemi derlenme sonucunda nasıl bir çizim işlemi gerçekleşeceği yerine uygulama için hangi protokolleri çalıştırabilirim düşüncesi ile hareket etmektedir. Bu sayede direk WPF ile iletişim içerisinde olmaktadır. Aynı biçimde Uygulama da çizim işlemlerini kod veya XAML ile WPF bünyesinde oluşturduğu için direk grafik kartı ile işlemlerini yapabilmesi mümkün kılmaktadır. Bu sayede çizim işlemeleri grafik kartında oluşturularak sistemin CPU ve RAM gibi bellek elemanlarını zorlamadan yapmış olacaktır.

Tabii bu durumun gerçekleştirilebilmesi için işletim sisteminizin yukarıda açıklamış olduğumuz modele uyumlu olması gerekmektedir. Uyumlu işletim sistemleri ise;

Windows XP + SP3
Windows Vista ve sonrası
Windows Server 2008 (Longhorn) ve sonrası
biçiminde sıralanmaktadır.

C#
public partial class Window1 : Window
{
   private Rectangle[] rectangles = new Rectangle[10];

   public Window1()
   {
      InitializeComponent();

      Canvas can = new Canvas();
      this.Content = can;

      Random rand = new Random();
      byte[] colors = new byte[3];
      for (int i = 0; i < rectangles.Length; ++i)
      {
         rectangles[i] = new Rectangle();
         rand.NextBytes(colors);
         rectangles[i].Fill = new SolidColorBrush(Color.FromArgb(
            255, colors[0], colors[1], colors[2]));
         rectangles[i].Width = 200;
         rectangles[i].Height = 100;
         Canvas.SetLeft(rectangles[i], i*20);
         Canvas.SetTop(rectangles[i], i*10);

         can.Children.Add(rectangles[i]);
      }
   }

   protected override void OnMouseWheel(MouseWheelEventArgs e)
   {
      int diff = e.Delta / 10;
      for (int i = 0; i < rectangles.Length; ++i)
      {
         if (rectangles[i].Width + diff > 0)
         {
            rectangles[i].Width += diff;
         }
      }
   }
}

Yukarıdaki kod parçacığı sonucunda oluşan uygulamanın ilk açılış anı ve fare kaydırma aracı sonrası oluşan görüntüsü aşağıdadır.




Yukarıdaki örneğimiz yardımı ile grafik işlemleri kolayca nasıl yapabildiğimize değinmiş bulunuyoruz. Yeni nesil grafik uygulamalarında hiç zorlanmadan işlemlerin yapılabilmesi için yeni nesil grafik kartlarının kullanılması uygulamalarımızın gerçek performansları açısından çok yararlı olacaktır.

8. Zengin Metin Uygulamaları (Rich Text)

Web uygulamalarında uzun zamandır Windows içerisinde kullanılan yazı formatları kullanılabilmekteydi. Kullanmış olduğumuz yazı ve stil işlemlerini daha sonraları tekrardan çağırmamak için bir dil oluşturulmuştu ve buna cascading style sheets (CSS) denilmiştir. Fakat web üzerinde kullanılabilen bu formatlar masaüstü uygulamalarında yeterinde kullanılamamaktaydı. Kullanılanlar ise çok kısa metin dosyalarına uygulanmaktaydılar.

Masaüstü uygulamalarında zengin yazı formatları kullanılmak istendiğinde ise Microsoft Word veya Windows işletim sistemlerinin bünyesinde bulunan zengin yazı formatları kullanılmaktaydı. Fakat buton gibi kontrollerde farklı ve süslü yazı stillerini maalesef tam verim ile kullanamıyorduk. Bu durumun en azında web ortamında ortadan kaldırılması amacıyla Microsoft MSHTML dosya formatının sürmüştü. Fakat bu dosya formatı da beklenen ilgiyi geliştiriciler alamamıştır.

WPF ile zengin yazı uygulamaları konusunda oldukça verim alınmış gibi görünüyor. Bu işlemlerin oluşturulmasındaki en büyük etken ise XAML gözükmektedir. XAML sayesinde form üzerine istediğimiz özelleştirmeleri yapabildiğimiz için hiç zorlanmadan zengin metin dosyalarını oluşturabilmemiz mümkün kılınmıştır.

Yukarıda açıkladığımız özellikler ışığında ufak bir uygulama oluşturalım ve oluşturmuş olduğumuz bu uygulamada zengin formatlı metin işlemleri, yazı stilleri ve renklerini kullanalım. Bu işlemleri daha kolay yapılabilmesi için XAML ortamında yapacağız.

XAML
   <Grid>
      <TextBlock FontFamily="Calibri" FontSize="11pt">
         Merhaba,
         <Span FontFamily="Old English Text MT" FontSize="24pt">
            Turhal
         </Span>
         <Italic>
            KTU
         </Italic>
         &lt;<Span Foreground="DarkRed">
            TextBlock
         </Span>/&gt;
         <Hyperlink>
            Link
         </Hyperlink>
      </TextBlock>
   </Grid>

Yukarıdaki koda dikkat ederseniz normal form özeliklerinin dışında web uygulamalarından alışık olduğumuz span metoduna kullanılmaktadır. Bu işlem yapısı sayesinde web programcılar ile Windows programcılarının uyum içerisinde çalışmaları amaçlanmıştır. Şimdi yukarıdaki kod bloğu sonucunda karşımıza çıkan ekran görüntüsüne göz atalım;



Peki, zengin metin dosyalarının içerisinde web uygulamalarında olduğu gibi form kontrollerini kullanamıyor muyuz? “ biçiminde bir soru aklımıza takılabilir. Bu sorunun cevabı oldukça açık ve nettir. “Web üzerinde yapmış olduğumuz işlemlerin neredeyse hepsini WPF uygulamaların da kullanabilmemiz mümkündür.

Şimdi bu bahsettiğimiz web uyumunu uygulayan bir örnek verelim. Bu örnekte bir önceki yazı işlemlerimize buton, checkBox ve radioButon ekleyeceğiz. Kod tarafında yukarıdaki kodda </TextBlock> ‘ın alt kısmını vereceğimiz kodları ekliyoruz.

XAML
   <CheckBox Height="16" Margin="0,38,0,0" Name="checkBox1" VerticalAlignment="Top"
         HorizontalAlignment="Left" Width="120">
      CheckBox
   </CheckBox>
   <RadioButton Height="16" Margin="0,59,0,0" VerticalAlignment="Top"
         HorizontalAlignment="Left" Width="120">
      RadioButton
   </RadioButton>
   <Ellipse Margin="97,38,181,124" Name="ellipse1" Stroke="AliceBlue" Fill="Brown" OpacityMask="Beige">
      <Ellipse.BitmapEffect>
         <EmbossBitmapEffect />
      </Ellipse.BitmapEffect>
   </Ellipse>
   <Button HorizontalAlignment="Left" Margin="0,83,0,0" Name="button1"
         Width="75" Height="23" VerticalAlignment="Top" FontFamily="Old English Text MT">
      Button
   </Button>

Eklediğimiz bu kod parçası sonucunda karşımıza çıkan ekran görüntüsü ise aşağıdaki gibidir.



Zengin metin uygulamalarını WPF ile ne kadar kolay ve performanslı bir biçimde yapacağımıza göz attık. Metin işlemleri ile ilgili diğer işlemleri deneme yanılma yöntemleri veya MSDN yardımı ile öğrenilebilmesi mümkündür.

7. Kolayca Uyum Sağlanabilen UI Yapısı

WPF öncesi hazırlamış olduğumuz form uygulamalarını derlediğimiz zaman nasıl bir sonuç ile karşılaşacağımızı tam olarak bilemiyorduk. Her ne kadar sürükle bırak form kontrollerinin yerleri biliyor olsak da kod tarafında oluşturduğumuz ekran görüntüleri tamamen piyango gibiydi. Bu durum Visual Studio 2008 ile WPF uygulamaları geliştirilmesi esnasında kod ile tasarım ekranını tam uyum değişmesi ile giderilmeye başlanmıştı. WPF uygulamalarında XAML ile tasarım ekranında yaptığımız bütün işlemlerin tam uyumu bizlere derleme sonrasında nasıl bir ekran ile karşılaşacağımız konusundaki şüphelerimizden kurtulmamızı sağlamıştır.

Win Form geliştiricileri karşılarına gelen ekranları diledikleri oranda kullanabilmekteler. Bu kullanım kolaylığı sayesinde XAML yapısına uyumun çabuk olmasını imkân tanımaktadır.

Kullanım kolaylığı ise Web uygulamaları geliştirirken kullandığımız tablolara benzemektedir. Formu satır ve sütunlara bölerek istediğimiz bölgesine istediğimiz bileşeni ekleyebilmemiz mümkündür.

Win form üzerinde basit bir uygulama geliştirelim. Bu geliştirdiğimiz uygulama HTML tablolarına benzer biçimde olsun ve başlığı, sol sütunu ve sağ sütunu olsun. Sağ sütunda bir çizim nesnesi olsun, sol sütunda ise listBox yer alsın. Şimdi bahsettiğimiz bu örneği XAML kod ile nasıl oluşturabildiğimize göz atalım.

XAML
<Grid>
   <Grid.ColumnDefinitions>
      <ColumnDefinition Width="*"/>
      <ColumnDefinition Width="235"/>
   </Grid.ColumnDefinitions>

   <Grid.RowDefinitions>
      <RowDefinition Height="Auto" MinHeight="32" />
      <RowDefinition Height="*" />
   </Grid.RowDefinitions>

   <TextBlock Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="2"
      Background="Cyan" FontSize="18pt" TextAlignment="Center">
     Uyumu Kolay UI Yapısı
   </TextBlock>

   <ListBox Grid.Row="1">
      <ListBoxItem>List</ListBoxItem>
      <ListBoxItem>On</ListBoxItem>
      <ListBoxItem>Left</ListBoxItem>
      <ListBoxItem>Hand</ListBoxItem>
      <ListBoxItem>Side</ListBoxItem>
   </ListBox>

   <Rectangle Grid.Row="1" Grid.Column="1" Fill="LimeGreen" />
   <Ellipse Grid.Row="1" Grid.Column="1" Fill="White" Margin="10" />
</Grid>

Satır ve sütunları kullanarak uygulamamızı geliştirdiğimiz zaman karşımıza nasıl bir ekran görüntüsü geldiğine göz atalım.



Yukarıda bahsettiğimiz yöntemlerin dışında daha kompleks yapılarda oluşturulabilmesi mümkündür. Oluşturulacak olan uygulamalar tamamıyla sizin hayal gücünüz ile doğru orantılıdır.

Formlar üzerinde oluşturabileceğimiz uygulamalar .net 2,0 ‘a göre daha kolay gibi gözükmekle birlikte aslında daha zordur. Bu karmaşık söze neden kullandığımıza gelirsek, eski form kontrollerinde her şeyi sürükle bırak işlemleri ile yaparken yeni nesil formlarda ise sürükle bırak yerine genellikle kod ile yapılmaktadır. Bu işlemler gerçekleştirilirken geliştirici çok daha dikkatli olmalıdır. Çünkü oluşturulacak olan binding işlemlerinde yapılacak bir hata veritabanına erişim dahil olmak üzere bir çok noktada bizleri sıkıntıya sokabilmektedir. Ayrıca oluşturulacak olan tasarımlarda da bir tasarımcıdan yardım almakta yarar vardır.

6. Esnek İçerik Modelleri

Birçok kontrollerde sabit özellikleri yerine başka özellikler eklenerek kullanarak kullanılmaktadır. Bu tür kullanıma örnek olarak, form üzerinde olan butonun içerisine bir label ekleyerek eklemiş olduğumuz o labelin yan kısmına yeni bir buton daha ekleyerek buton kontrolünün içeriğini zenginleştirmiş oluyoruz. Bir başka örnek daha vermek gerekirse Tab kontrollerinin içeriklerine yeni kontroller eklenerek işlevi arttırılabilmektedir.

WPF uygulamalarında da bu tür içerikleri esnekleştirebilme olanağımız vardır. Bu işlemi bir örnek ile açıklamamız daha mantıklı olacaktır. Örneğimizde butonun içeriğine yazı ekleyeceğiz, daha sonra bu yazının üzerine sürükle bırak ile yeni bir buton eklemek istediğimizde butonun üstüne eklenebilmekle birlikte yazı bölümünün içerisine daha da uyum içerisinde eklenmesine olanak tanıyacaktır.

XAML
<Grid>
   <Button Height="80" VerticalAlignment="Top" Margin="0,0,46,0">
      <StackPanel Orientation="Horizontal">
         <Ellipse Fill="Navy" Stroke="Yellow"
            Width="30" Height="20" />
            <TextBlock VerticalAlignment="Center">
               Baska bir buton daha ekleyin...
            </TextBlock>
      </StackPanel>
   </Button>
</Grid>

Örneğin ekran görüntüsü ise aşağıdadır.



Eklemek istediğimiz butonu “Baska bir buton daha ekleyin…” yazan kısma sürükleyip bırakıyoruz ve yeni ekran görüntümüz aşağıdaki gibi oluyor.



Esnek içerik modellemelerini yalnızca buton değil daha birçok özellik ile de kullanılması mümkündür. Bu kontrolleri içeriksel olarak arttırabilmekle birlikte tasarımcılar yardımıyla hem grafik yardımı ile hem de içerik yönüyle daha kuvvetli uygulamalar yapılabilmesi mümkündür.

5. Benzetilebilen Kontroller

İçeriklerin modellenebilmesi ile birlikte WPF ‘de benzetilebilen kontrollere de izin verilmektedir. Bu kontroller için uyumlu özellikler ile birlikte kod tarafında form kontrollerine başlamalar yapılmaktadır. Bu bağlamalar için ise ister LinQ ile ister başka bir sınıf ile kullanılabilmesine olanak vardır.

Biraz daha örneklemek gerekirse, şu ana kadar oluşturulmuş en iyi tasarım kontrollü olan Aero WPF yardımları ile oluşturulmuştur. Aynı şekilde Aero dan farklı bir ara yüz kullanmak isteyen kullanıcılar ve Windows System 2008 kullanıcıları için de Windows 2000 tasarımı oluşturulabilmektedir. Uygulamalarımızda bu biçimde birden fazla tasarım kontrolü oluşturmak sistem gereksinimleri konusunda eksiklikleri olan kullanıcılar açısından yararlı olacaktır.

XAML
<Button>
   <Button.Template>
   <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>
   </Button.Template>
    Tikla!
</Button>

Yukarıdaki örneğimizde butona WPF ile değişebilen özelliklerini dinamik olarak binding yapıyoruz standart halinden farklı olmasını sağlıyoruz.

Windows geliştirme araçlarıyla birlikte gelen kontroller en doğal halleri ile geliştiricilere sunulmaktadır. Bu doğal haller ise işletim sisteminde kullanılan temalardan alınmaktadır. Fakat bu temalar başka bir kullanıcıda farklı bir görünüm alabilir. Bu durumu ortadan kaldırabilmek için yapmamız gereken Ellipse ve Rectangle ‘ı Shapes sınıfının içerisinde kullanarak kontrolleri özelleştirebiliriz. Böyle durumlarda XAML kod tarafında kaynaklar diye bir kod bloğu oluşturarak bu kod bloğunun içerisine ne tür tasarı işlemleri yapmak istiyorsak bunları ekleriz. Ekledikten sonra ise forma ekleyecek olduğumuz kontrol ile bağlama işlemleri sonucunda kullanılabilir bir hal alacaktır.

4. 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);
benimButon.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. İ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. 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. 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
turhal.temizer@csharpnedir.com

Kaynaklar
MSDN Magazine
Makale:
Neden Geliştiriciler WPF 'i Tercih Etmeli? .NET 3.0 ve .NET 3.5 Özel Bölümü Turhal Temizer
  • Yazılan Yorumlar
  • Yorum Yaz
Bu konu hakkında yayınlanan yorum bulunmamaktadır.
"Yorum Yaz" tabını kullanarak sizde yorumlarınızı yazabilirsiniz.
Yorum yazabilmek için üye girişi yapmalısınız. Üye girişi için tıklayın.
Üye değilseniz Üyel Ol linkine tıklayarak üyeliğinizi hemen başlatabilirisniz.
 
  • Bu Konuda Son 10
  • Eklenen Son 10
  • Bu Konuda Geçmiş 10
Bu Konuda Yazılmış Yazılmış 10 Makale Yükleniyor
Son Eklenen 10 Makale Yükleniyor
Bu Konuda Yazılmış Geçmiş Makaleler Yükleniyor