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

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

WPF-Single Instance Uygulama Geliştirme
18 Temmuz,2011

Bu yazımızda WPF uygulamalarımızı single instance hale nasıl getirebileceğimizden bahsediyor olacağım. Single instance uygulama demek, uygulamamızın sadece bir örneğinin çalıştırılabilmesi anlamına gelir. Örneğin windows işletim sisteminde hesap makinesini ya da paint uygulamasını birden fazla açabilir ve her birinde farklı işlemler yapabilirsiniz. Çünkü her bir uygulama farklı bir prosestir ve farklı thread lerde çalışırlar. Bu da bize her birinde bağımsız olarak farklı işler yapmamıza olanak sağlar.

image

Uygulamamamızın tek bir örneğinin çalışmasını sağlamak için pek çok yöntem bulabilirsiniz. Bunlardan biri uygulama ilk çalıştığında sistemdeki tüm proseslerin listesini alıp kendisiyle aynı isimli process olup olmadığını kontrol etmektir. Eğer aynı isimli proses yoksa uygulamayı çalıştırmak varsa o anki uygulamadan çıkmaktır. Aslında mantıklı bir çözüm gibi gelse de şöyle bir senaryonun oluşma durumu da var. Ya uygulamamızla aynı ismi taşıyan farklı bir uygulama varsa? İşte bu yüzden bu seçenek pek sağlıklı durmuyor. Diğer bir seçenek de Mutex kullanmaktır.

İki ya da daha fazla thread aynı anda, paylaşılmış bir kaynağa erişmeye çalıştığında, sistemin kaynağı aynı anda sadece bir thread in kullanmasını garanti etmesi gereken bir senkronizasyon mekanizmasına ihtiyacı vardır. Bu noktada Mutex ler devreye girmektedir. İlk thread in mutex’i devradlığını düşünelim, diğer threadler ilk thread mutex’i serberst bırakana kadar askıya alınırlar. Bu kadar teknik bilgiden sonra artık uygulamaya geçmenin zamanıJ

WPF uygulamaların böyle bir yapıyı kullanmak için öncelikle uygulama başlarken bu kontrolün yapılması gerekmektedir. Bu yüzden gerekli kontrolü kend Main metodumuzda yapmalıyız. WPF de main metodumuz otomatik olarak oluşturulur. Oluşturulan metodu görmek için Visual Studio Solution penceresinden Show All Files dediğimizde obj klasörünün içinde bulunan App.g.cs dosyasında bulabilirsiniz. Uygulamayı kendi main metodumuzdan çağırmak için şu yolu izlemeliyiz:

1-İlk olarak App.xaml dosyasının özelliklerinden Application Definition olan build action ını Page olarak değiştirmeliyiz.

2.Kendi tanımladığımız Main metodunu “single-threaded apartment” olarak işaretlemeliyiz. Artık kontrollerimizi yapabiliriz. Aşağıdaki kod parçası amacımıza ulaşmak için yeterli olacaktır.

 

public static bool isFirstInstance=false;
 
        [STAThread]
        public static void Main()
        {            
            using (var mutex=new Mutex(true,"WPFSingleInstanceDemo",out isFirstInstance))
            {
                if (isFirstInstance)
                {
                    MainWindow window = new MainWindow();
                    window.ShowDialog();
                }
                else
                {
                    MessageBox.Show("Uygulama zaten çalışıyor!");
                    App.Current.Shutdown();
                }
            }
        }

 

Yukarıda görüldüğü gibi bir mutex nesnesi oluşturuyoruz. Yapıcı metoduna gönderdiğimiz ilk parametre ile bu mutex i uygulamamızın çalışacağı thread ile ilişkilendiriyoruz, ikinci parametremizde ise mutex in adını belirtiyoruz . Son olarak da eğer daha önce bu isimde mutex yoksa oluşturulduğunu belirtmek için true varsa false değeri döndürdüğünü belirten sonucu almamız için bir değişken veriyoruz. Değişkenin durumuna göre de uygulamanın çalışmasını yönlendirebilirsiniz.

Son olarak hatırlatmakta yarar var. Aynı yapıyı wpf uygulamalarının yanısıra winform uygulamalarında da kullanabilmek mümkün.

SingleInstanceDemo.zip (24,42 kb)

Etiketler: ,
Kategoriler: C# | WPF

Microsoft Surface 2 ve Merak Edilenler
28 Mayıs,2011

Mix 11'de duyurulan Microsoft Surface 2 hakkında merak edilen soruların cevaplarını Luis Cabrera ile yapılan röportajda bulabilirsiniz.Röportaj içeriğinde Surface 2 ile gelen yenilikler, donanım değişiklikleri, development tarafında gelen yenilikler ve geliştirme araçları hakkında bilgiler yer almaktadır.

Etiketler: , ,
Kategoriler: Genel | WPF