WPF 4.5 - Farklı Bir Thread'den UI Thread'deki Koleksiyonlara Erişme
9 Kasım,2011

Uygulamalarımızda kullanabileceğimiz pek çok veri kaynağı tipi  bulunmaktadır. Bunlardan birisi de koleksiyonlardır. Koleksiyonların kullanışlılığı, özellikle WPF’in güçlü data binding yapısı ile birlikte kullanılınca maksimum düzeye çıkmaktadır. Fakat bazı durumlarda koleksiyonlarla ilgili sıkıntılar yaşamıyor değiliz. Örnek vermek gerekirse uzun süren veri çekme işlemleri ya da bir web servisi aracılığıyla büyük verilerin çekilmesi uygulamamızı oldukça yorar ve bu yüzden veri çekme işlemleri bitene kadar kilitlenmeler yaşarız. Bunun nedeni tüm işlemlerin UI Thread içerisinde gerçekleşmesinden kaynaklanmaktadır. Çözüm yolu olarak farklı bir Thread oluşturup veri çekme işlemlerini orada gerçekleştirip dönen değerleri parametrik olarak diğer Thread’den alabiliriz.

Thread kavramını da açıklamak, çalıştırılabilir iş parçacığı anlamına gelmektedir. Çok çekirdekli sistemlerde eş zamanlı olarak farklı görevler üstlenebilmektedirler. Her ne kadar WPF’de Threading yapısı biraz değişse de amaç yine aynıdır. Farklı işlemleri birbirinden bağımsız olarak paralel bir şekilde çalıştırmaktır.

Farklı bir Thread’den aldığımız verileri UI Thread’deki koleksiyonumuza atamak istediğimizde ise, farklı Thread’lerden UI Thread’deki koleksiyonumuza erişemeyeceğimizi belirten bir hata almamız kaçınılmazdır. WPF takımının da dikkatini çekmiş olacak ki bu sorun, tam da aradığımız çözümü WPF 4.5 ile beraber bizlere sunmuşlar. Farklı thread’lerden UI Thread’deki bir koleksiyona erişebilmek için BindingOperations sınıfının EnableCollectionSynchronization isimli statik metodunu kullanmak yeterli.

public static object _lock=new  object();
ObservableCollection<string> nameList=new ObservableCollection<string>();
BindingOperations.EnableCollectionSynchronization(nameList, _lock);

Burada dikkat edilmesi gereken en önemli noktalardan birisi de koleksiyonumuza farklı bir Thread’den erişilmeden önce bu metodun çağrılmış olmasını garantiye almalıyız. Bu yüzden de metod çağrımını ilgili sınıfın yapıcı metodunda ya da Thread’leri başlatmadan önce yapmakta fayda var. Koleksiyonumuz için yukarıdaki gibi bir tanımlama yaptıktan sonra artık herhangi bir Thread içerisinden erişebiliriz.

Kolay gelsin.

SourceCode.zip (40,02 kb)

Kategoriler: WPF

WPF 4.5 - Data Binding Bilgilerini Alma
25 Ekim,2011

Artık .NET Framework 4.5 Preview ile gelen yeni API ler sayesinde WPF uygulamalarındaki bir data binding ifadesindeki hedef nesne,kaynak nesne ve ilgili özellikleri gibi bilgileri alabiliyoruz. Bunları aşağıdaki BindingExpression sınıfına gelen yeni özellikleri kullanarak gerçekleştirebiliriz.

Data binding bilgilerin alabilmek için öncelikle BindingOperations sınıfının GetBindingExpression isimli statik metodunu çağırarak binding ifademizi alıyoruz. Daha sonra yukarıdaki özellikleri kullanarak gerekli bilgileri alabiliriz.

Data Binding Information

Dilerseniz hemen bu yeni APIlerimizi kullanarak basit bir örnek üzerinde görelim. Aşağıdaki gibi bir XAML'ımızın olduğunu düşünelim ve kod tarafında, XAML 'da oluşturduğumuz binding ifadesinin bilgilerini alalım.

[XAML]

<StackPanel>
   <TextBox x:Name="myTextBox" Width="200" />
   <TextBlock x:Name="myTextBlock" Text="{Binding ElementName=myTextBox,Path=Text}"  Margin="5"/>           
</StackPanel>

[C#]

//Binding ifadesini alıyoruz
BindingExpression bindingExpression = BindingOperations.GetBindingExpression(myTextBlock, TextBlock.TextProperty);
//Binding yapılan nesnemiz (TextBlock)
DependencyObject target = bindingExpression.Target;
//Binding yapılan nesnemizin ilgili özelliği (TextBlock.Text)
DependencyProperty targetProperty = bindingExpression.TargetProperty;
//Binding yaptığımız kaynak nesne (TextBox)
object source = bindingExpression.ResolvedSource;
//Binding yaptığımız kaynak nesnenin ilgili özelliği (TextBox.Text)
string sourceName = bindingExpression.ResolvedSourcePropertyName;

Kısaca bir data binding ifadesindeki binding bilgilerini aldık. Eğer ifadeniz BindingGroup içeriyorsa BindingGroup özelliğini kullanarak bilgilerine ulaşabilirsiniz.

Kolay gelsin.

Kategoriler: WPF

WPF 4.5 - Static Property Binding
16 Ekim,2011

Framework 4.5 Preview ile gelen yeni özellikler sayesinde artık WPF uygulamalarımızda statik özellikler ile veri bağlama işlemleri gerçekleştirebilmekteyiz. Hatta bu statik özelliklerimizin değeri her değiştiğinde haberdar olabilmemiz için statik bir olay  tanımlamamız da mümkün. Özelliğimizin değişiminden haberdar olmamız için tanımlayacağımız statik olay MSDN de de belirtildiği gibi iki şekilde olabilir.

  • public static event EventHandler MyPropertyChanged;
  • public static event EventHandler<PropertyChangedEventArgs> StaticPropertyChanged;

İkisinin arasındaki tek fark eğer sadece bir tane statik özelliğinizi veri bağlama işleminde kullanacaksanız ilk tanımlamayı kullanabilirsiniz fakat birden fazla statik özellik kullanacaksanız ikinci tanımlamayı kullanmalısınız. Çünkü ilk tanımlama için birden fazla özellik kullanacaksanız her bir özellik için ayrı ayrı PropertyChanged olayı tanımlaması yapmanız gerekecektir. Jenerik tanımlamada ise tek bir olaya parametre olarak özellik adını vererek çok daha sade ve basit bir şekilde gerçekleştirmiş oluruz. Bu kadar açıklamadan sonra gelin bu özelliğimizi nasıl kullanacağımıza bakalım ve aşağıdaki gibi bir sınıfımız olduğunu düşünelim.

public class MyClass
    {
        private static string myProperty="This is static property text";       
        public static string MyProperty 
        {
            get
            {
                return myProperty;
            }
            set 
            {
                myProperty = value;
                NotifyPropertyChange("MyProperty");
            }
        }

        public static event EventHandler<PropertyChangedEventArgs> StaticPropertyChanged;
        public static void NotifyPropertyChange(string propertyName)
        {
            EventHandler<PropertyChangedEventArgs> handler = StaticPropertyChanged;
            if (handler != null)            
                handler(null, new PropertyChangedEventArgs(propertyName));
        }        
    }

Daha sonra statik olan MyProperty adındaki özelliğimizi XAML tarafında bağlarken önce aşağıdaki gibi MyClass sınıfımızdan bir nesne üretmeliyiz.

<Window x:Class="WPF_StaticProperties.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:WPF_StaticProperties"
        Title="MainWindow" Height="350" Width="525">
    <Window.Resources>
        <local:MyClass x:Key="MyClassInstance" />
    </Window.Resources><Grid>
</Grid>
</Window>

Artık MyClass tipinde bir nesne örneğini ürettikten sonra veri bağlama işleminde şu şekilde kullanabiliriz.

<StackPanel>
    <TextBox x:Name="txtBox" HorizontalAlignment="Center"
                     Width="200"  Margin="5"/>
     <TextBlock Width="200" Text="{Binding MyProperty, Source={StaticResource MyClassInstance}}" Margin="5" HorizontalAlignment="Center"/>
      <Button Content="Change Static Property"
                    Width="150"
                    Height="50"
                    HorizontalAlignment="Center"
                    Click="Button_Click" />
 </StackPanel>

XAML tarafındaki butonumuzun click olayında da TextBox kontrolümüze girdiğimiz metni statik özelliğimize atayalım. Bu sayede özelliğimizin değerinin değiştiğini haber veren olayın da çalışıp çalışmadığını gözlemleyebiliriz.

private void Button_Click(object sender, RoutedEventArgs e)
 {
     MyClass.MyProperty = txtBox.Text;
 }

WPF 4.5 Preview ile gelen bu özelliğimizden de kısaca bahsettik. Bir sonraki özelliğimizde görüşmek üzere.

Kolay gelsin.

WPF45-StaticPropertyBindingDemo.zip (58,72 kb)

Kategoriler: WPF

WPF 4.5-Veri Kaynağını Otomatik Güncelleme
5 Ekim,2011

WPF’te bir data binding işlemi gerçekleştirilirken çift yönlü, tek yönlü gibi pek çok farklı veri transferi kullanılabilir. Veri akışının hedeften kaynağa mı yoksa kaynaktan hedefe mi olacağını binding modlar ile belirtebiliriz. Binding modun değeri kullanıcının set edebildiği kontroller için varsayılan olarak TwoWay olarak gelmektedir.

WPF 4.5 ile beraber Delay adında yeni bir binding özelliği  geldi. Bu özellik bize artık data binding işlemlerini belirli bir süre geciktirebilme imkanını vermektedir. Bir diğer önemli nokta bu özellik hedeften kaynağa olacak şekilde tek yönlü çalışmaktadır.Parametre olarak da integer tipinde milisaniye değeri almaktadır ve varsayılan değeri 0’dır.

Kullanım senaryosu olarak açıkcası gerçel hayattan aklıma şu an bir örnek gelmiyor fakat MSDN’de bu özellikle ilgili güzel bir kullanım alanından bahsedilmiş. Örneğin bir slider kontrolümüzün olduğunu düşünelim ve bu kontrolümüzün değerine göre işlem yaptırmamız gerektiğini varsayalım. Slider’ın değerini 0’dan 100’e getirip bir işlem yaptığımızda 0 ile 100 arasındaki her bir değer için kaynağı güncellemiş olduk fakat bize lazım olan değer sadece 100 değeri. İşte tam bu noktada Delay özelliğini kullanıp makul bir milisaniye değeri verdikten sonra kaynağı güncellemek doğru bir hareket olacaktır.

Nasıl kullanırız?

<StackPanel>            
  <TextBox x:Name="txtTarget" Width="200" Margin="10" Text="{Binding ElementName=txtSource,Path=Text,Delay=1000,UpdateSourceTrigger=PropertyChanged}"/>
  <TextBox x:Name="txtSource" Width="200" />
</StackPanel>

Örnek kodda Delay özelliğini 1000 olarak set ederek hedef TextBox’da yaptığımız değişikliklerin her bir karakter girildiğinde yansıtılması yerine 1 saniye sonra yansıtılmasını sağlamış olduk.

Hepinize kolay gelsin.

Not: Yukarıdaki örnek kod .NET 4.5 Preview ortamında Visual Studio 11 Developer Preview kullanılarak test edilmiştir.  

Kategoriler: WPF

WPF 4.5-Olaylara Weak Reference Oluşturma Desteği
4 Ekim,2011

Build konferansında Windows 8 Developer Preview’ın duyurulması ile beraber .NET Framework 4.5 önizleme sürümü de duyuruldu. Bu sürümle beraber WPF’e pek çok yeni özellikler geldi. Bir önceki yazımda bu yeniliklerden  başlıklar halinde kısaca bahsetmiştim.

WPF 4.5 ile artık olaylara kolaylıkla zayıf referans (Weak Reference) oluşturabilme desteği geldi. Bilindiği üzere olayları dinlemek, sistemde bellek sızıntılarına sebep olmaktadır. Aşağıdaki kod buna bir örnektir.

button.Click+=new RoutedEventHandler(button_Click);

Normalde bir dinleyiciye olay ataçlayarak dinleyicinin nesne ömrünü, kaynağın nesne ömrüyle etkilemiş oluyoruz. WPF 4.5 ten önce bu olay sızıntılarını önlemek için IWeakEventListener isimli bir arayüz kullanarak gerçekleştiriyorduk. Hatta her bir olay için ayrı ayrı zayıf olay yöneticisi oluşturmak zorundaydık.  Artık Framework 4.5 ile jenerik WeakEventManager sınıfı geldi ve işimiz çok daha kolaylaştı.  O kadar kolaylaştı ki WeakEventManager sınıfının hali hazırda kullanabileceğimiz AddHandler ve RemoveHandler  olmak üzere iki static metodunu kullanarak bunu yapabilir hale geldik. Dilerseniz lafı daha fazla uzatmadan bellek sızıntılarını WPF 4.5’de ne kadar kolay bir şekilde engelleyebileceğimizi görelim.

public MainWindow()
  {
       InitializeComponent();
       btnClick.Click+=new RoutedEventHandler(Button_Click);
       WeakEventManager<Button, RoutedEventArgs>.AddHandler(button, "Click", Button_Click);
  }     
void Button_Click(object sender, RoutedEventArgs e)
   {
       //TODO
   }

Yukarıda, XAML tarafındaki “btnClick” isimli butonumuzun click olayı için weak reference oluşturmuş olduk.  Tek yapmamız gereken AddHandler static metoduna kaynak,olay adı ve olay yöneticisini parametre olarak vermek. Sizce de kolay değil mi? Bir sonraki yeni özellikte görüşmek üzere.

Kolay gelsin.

Kategoriler: WPF

WPF 4.5 Developer Preview ile Gelen Yenilikler
26 Eylül,2011

Yaklaşık iki hafta önce herkesin merakla beklediği Build Windows konferansı gerçekleşti. Bu konferansta Windows 8  ve yeni uygulama geliştirme platformları ile ilgili oturumlar gerçekleşti. Build Visual Studio 11 Developer Preview, Expression Blend 5 Preview, .NET 4.5 Developer Preview gibi pek çok ürünün yeni sürümlerini  de beraberinde getirdi.

WPF 4.5 Developer Preview versiyonunda neler var?

  1. Non-UI thread’lerden koleksiyonlara erişmek
  2. Geçerli bir DataContext nesnesinin varlığının kontrolü
  3. Event’lere geliştirilmiş WeakReference desteği
  4. Dispatcher sınıfı için yeni metodlar
  5. Event’ler için Markup Extension desteği
  6. Statik property binding desteği
  7.  Asenkron ve senkron data validasyon
  8. Data binding kaynağını otomatik güncelleme
  9. VirtualizingPanel için yeni özellikler
  10. Ribbon kontrol
  11. WPF ve Win32 kullanıcı arayüzü komponentleri arasında geliştirilmiş integrasyon
  12. Gruplanmış veri gösteriminde performans iyileştirmesi
  13. Binding ifadelerden data binding bilgilerini alma
  14. ICustomTypeProvider arayüzünü implemente eden tiplere data binding desteği
  15. Koleksiyondaki bir verinin değeri değiştiğinde, koleksiyonu yeniden düzenleme

.NET 4.5 Developer Preview sürümü ile WPF ‘e gelen yeniliklerin kabaca başlıkları bunlar.  Yeni özellikler ile ilgili daha detaylı bilgiye buradan ulaşabilirsiniz. Unutulmaması gereken en önemli noktalardan birisi de .NET 4.5 sürümünün final sürümünde pek çok değişiklik olabilir.

Kategoriler: WPF

2011-2012 Dönemi MSP Programı Başvuru Sonuçları Açıklandı!
24 Eylül,2011

Sonunda merakla beklenen 2011-2012 dönemi Microsoft Student Partner programının başvuru sonuçları açıklandı. Aşağıda sonuç listesine ulaşabilirsiniz. Seçilen arkadaşları tebrik ediyorum. 

Ahmet Tabanlıoğlu HARRAN ÜNİVERSİTESİ
Ahmet Anıl Müngen FIRAT ÜNİVERSİTESİ
Alp Arslan Eren İZMİR EKONOMİ ÜNİVERSİTESİ
Arda Develioğlu BİLKENT ÜNİVERSİTESİ
Aybala Sert ERCİYES ÜNİVERSİTESİ
Beraat Aldemir ANKARA ÜNİVERSİTESİ
Burak Gönüldaş SELÇUK ÜNİVERSİTESİ
Can Eyüpoğlu İSTANBUL KÜLTÜR ÜNİVERSİTESİ
Cem Yamanyılmaz MARMARA ÜNİVERSİTESİ
Deniz Marlalı SABANCI ÜNİVERSİTESİ
Doğukan Demir DOĞU AKDENİZ ÜNİVERSİTESİ 
Faruk Can Özdemir ÇANKAYA ÜNİVERSİTESİ
Gazi Uslu EGE ÜNİVERSİTESİ
Göknur Aslan ÇUKUROVA ÜNİVERSİTESİ
İlkay Taşkıran TRAKYA ÜNİVERSİTESİ
İlyas Yurtsever DOKUZ EYLÜL ÜNİVERSİTESİ
Kemal Kocabıyık KOÇ ÜNİVERSİTESİ
Kıvanç Tolga Çalışan BEYKENT ÜNİVERSİTESİ
Melike  Özdemir İSTANBUL TEKNİK ÜNİVERSİTESİ
Merve Arıtürk BAŞKENT ÜNİVERSİTESİ
Merve Özel KADİR HAS ÜNİVERSİTESİ
Muhammed Sefa Yılmaz HACETTEPE ÜNİVERSİTESİ
Mustafa Çelik FATİH ÜNİVERSİTESİ
Mustafa Arslan YEDİTEPE ÜNİVERSİTESİ
Nagihan Sema Kudu KARADENİZ TEKNİK ÜNİVERSİTESİ
Neslişah Çelik İSTANBUL ÜNİVERSİTESİ
Orhan Can Ceylan KOÇ ÜNİVERSİTESİ
Serap Şen ESKİŞEHİR OSMANGAZİ ÜNİVERSİTESİ
Tahsin Kasap PAMUKKALE ÜNİVERSİTESİ
Ülkü Buket Nazlıcan BOĞAZİÇİ ÜNİVERSİTESİ

 

Seçilen arkadaşları tekrar kutluyorum. Çok müthiş bir deneyim sizleri bekliyor benden söylemesi;)

Kategoriler: Genel

Linq to XML ile Bir Niteliğin Varlığının Kontrol Edilmesi
2 Eylül,2011

Pek çok uygulamanızda xml verilerle çalışma fırsatınız olmuştur ve bu verilerden ihtiyacınız olanları çekmek için parse işlemleri de yapmışsınızdır. Her ne kadar xml verileri ayrıştırmak işkence gibi gelse de Linq to Xml ile işimiz biraz daha kolaylaşmış durumda. Fakat bazı xml dosyaları standart olmayabiliyor. Özellikle niteliklerin değerlerini alırken bazı elementler almak istediğimiz niteliği içermeyebiliyor ve  bu yüzden uygulama hata veriyor. Peki elementlerin almak istediğimiz niteliği içerip içermediğini nasıl kontrol ederiz?

Nasıl yaparız?

<Book Edition="3"> 
<Name>..</Name> 
<Author>..</Author>
 <ISBN>..</ISBN> 
</Book>

Yukarıdaki gibi bir elementimizin olduğunu varsayıp Edition niteliğinin değerini okuyalım. Eğer elementimizin Edition isimli bir niteliği yoksa varsayılan olarak 1 değerini verelim.

string edition = p.Attributes("Edition").Any() ? p.Attribute("Edition").Value : "1";

Linq to Xml de Any() metodunu kullanarak elementimizin Edition isimli herhangi bir nitelik içerip içermediğine bakar. Eğer bir veya birden fazla nitelik varsa true döndürür yoksa false döndürür. Aynı şekilde herhangi bir elementin varlığını da bu metodla kontrol edebilirsiniz.

Kolay gelsin.

Etiketler: ,
Kategoriler: C#

XAML'da Arkaplan Kodu Çalıştırma
21 Ağustos,2011

Visual Studio’da bir WPF projesi oluşturduğumuzda otomatik olarak karşımıza iki farklı dosya tipi oluşturmaktadır. Bunlardan birisi görsel elementleri yerleştirdiğimiz XAML dosyası diğeri ise mantıksal işlemler gerçekleştirdiğimiz, görsel kısımlara veri sağladığımız ya da görsel elementlerin durumlarını değiştirebildiğimiz code behind dosyası vardır. Mimari açıdan da öngörülen bu şekildedir çünkü tasarımcı ile geliştiricinin rollerinin belirginleşmesi açısından bu önemlidir. Tabi eğer bir çılgınlık yapıp görsel elementleri de kod tarafında dinamik olarak oluşturmuyorsanızJ

Bildiğiniz gibi XAML tarafındaki her bir element .NET nesnesi olduğu için kod tarafında da oluşturulup kullanılabilmektedir. Peki ya XAML tarafında arka plan kodu çalıştırmak istersek?

Neden gerek var?

Mimari açının öngördüğünün aksine neden böyle bir şeye gerek var diye düşünebilirsiniz. Çoğunlukla gerek olmamasının yanı sıra bazı durumlarda kullanılabilir. MVVM (Model-View-ViewModel ) desenin kurallarından birisi sıfır arka plan kodu olmasıdır. WPF’in güçlü data binding yapısı sayesinde bu kolaylıkla sağlanabilmektedir. Peki projemizde bir event handler çalıştırmak istersek? İşte bu noktada XAML tarafında arka plan kodu çalıştırmanın mantıklı bir sebebi ortaya çıkıyor.

Peki nasıl?

XAML tarafında  kod çalıştırabilmemiz için x:Code taglarını kullanmalıyız. Öncelikle bir WPF projesi oluşturup arkaplan kodu dosyasını projemizden siliyoruz. Daha sonra aşağıdaki gibi kodları XAML tarafına ekleyebiliyoruz. Unutulmaması gereken en önemli şeylerden birisi kodlarımızı <![CDATA[ ]]> arasında yazmamız gerektiğidir. Bu sayede XAML işleyicisi kodumuzu XML içerik olarak yorumlamayacak. Gelelim kodumuzu yazmaya:

<Window x:Class="Win7JumpList.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <StackPanel>            
	   <TextBox x:Name="txtBox" Width="100" />
            <Button Width="133"
                    Height="24"
                    Name="btnGreeting"
                    Click="btnGreeting_Clicked"
                    Content="Greet!" />            
            <x:Code>
                <![CDATA[            
            private void btnGreeting_Clicked(object sender, RoutedEventArgs e)
            {
                txtBox.Text="Welcome guest!";
            }
        ]]>
            </x:Code>
         </StackPanel>
    </Grid>
</Window>

Gördüğünüz gibi arka plan kodlarını XAML tarafında çalıştırmak <x:Code><![CDATA[ ...]]></x:Code> tagları arasında eklemek kadar basit.

Sonuç

Her ne kadar XAML tarafında arka plan kodu çalıştırabilsek belirli kısıtlamalar mevcut. Yaşayacağınız en büyük eksiklik Intellisense özelliğinin olmaması. Tüm kodu teker teker yazmak zorundasınız J Bir diğer kısıtlaması using ifadesi kullanılamadığı için tüm CLR namespace’lerini kullanmak mümkün değil malesef. Kısıtlamalarla ilgili daha detaylı bilgi için MSDN dökümanına gözatabilirsiniz.

Kolay gelsin.

Etiketler: , ,
Kategoriler: WPF

XAML Parser Convert İşlemi
5 Ağustos,2011

XAML kullanmanın en güzel taraflarından birisi belki de property’lere gerekli değerleri hangi tip olursa olsun, string tipinde veriyor olmamızdır. Peki XAML bunu nasıl çözümlüyor hiç merak ettiniz mi?

XAML çözümlemeyi nasıl yapıyor?

XAML parser tüm xaml’ı kontrol ederken property üzerinde TypeConverterAttribute niteliğinin varlığını kontrol eder. Bu nitelik sayesinde belirtilen değer uygun tipe dönüştürülürken hangi dönüştürücü sınıfının kullanılacağını anlar. Eğer kontrol sırasında bir nitelik bulursa, converter sınıfını örnekler ve uygun convert işlemi için kullanır.

Kod tarafında aynı senaryoyu uygulayabilir miyiz?

Kod tarafında da aşağıdaki gibi TypeConverter sınıfını kullanarak aynı şekilde property lere string tipinde değerler verip uygun tiplere dönüştürülmesini sağlayabiliriz.

[XAML]

<Window x:Class="XmlParse.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <StackPanel>
            <TextBlock x:Name="txtMessage" Text="Hello world!" />
        </StackPanel>
    </Grid>
</Window>

  [C#]

void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            txtMessage.Foreground = MyConverter<SolidColorBrush>("Green");
        }       

        public T MyConverter<T>(string stringValue)
        {
            TypeConverter typeConverter = TypeDescriptor.GetConverter(typeof(T));

            if (typeConverter != null)
                return (T)typeConverter.ConvertFromString(stringValue);
            else
              throw new Exception("Dönüştürme işlemi için uygun converter bulunamadı.");
        }
Hepinize kolay gelsin.
Etiketler: , ,
Kategoriler: WPF