Windows Mobile 5.0 ile birlikte artık Managed Uygulama geliştiriciler işletim sistemi üzerinde hali hazırda kullanımda olan birçok dialog penceresine çok daha rahat ulaşabilmektedirler. Birçok karmaşık fonksiyon tanımlaması bir yana Windows Mobile 5.0 API’ leri üzerinden managed uygulama geliştiriciler işletim sistemi üzerindeki dialog pencerelerinden kendi uygulamalarında yararlanabilmektedirler. Bu makalemizde ise işletim sistemi üzerinde tanımlı olan bir klasör içerisinde bulunan resimleri görüntülemeye ; bu resimlerin seçilmesi & sıralanması ile ilgili hazır tanımlı olan bir dialog penceresini ; SelectPictureDialog dialog penceresini Managed Uygulamalar içerisinde kullanımına değineceğiz.

SelectPictureDialog adından da anlaşılabileceği üzere uygulama içerisinde kullanıcılara resim seçtirebilmek adına geliştirilmiş bir dialog penceresi kontrolüdür. Bu kontrol işletim sistemi üzerinde standart olarak gelen birçok resim tabanlı uygulamada kullanılmış ; resim seçtirtme eylemi konusunda esneklik sağlamaktadır.

Konunun bu noktada daha rahat anlaşılabilmesi açısından örnek bir Mobil Cihaz uygulaması geliştirmek daha uygun olacaktır.

Hiç vakit kaybetmeden işe standart bir C# Smart Device Windows Application projesi açıyoruz.

Bir sonraki adımda makalemizin temel konusunu oluşturan sınıfı içerisinde barındıran System.WindowsMobile.Forms referansını mobil cihaz uygulamamıza refere ediyoruz.

Bir sonraki adımda şekildeki uygulama ekranını tasarlıyoruz.

Geliştiriyor olduğumuz örnek uygulamamızdaki temel amacımız mobil cihaz kullanıcısının SelectPictureDialog penceresi yardımı ile uygulama içerisinde işletim sistemi üzerinde bulunan resimlerini görüntüleyebilmektir. Uygulama ekranı üzerinde en üste bir Image kontrolü, altına bir TextBox ve dialog penceresini açtırabilmek adına bir button kontrolü yerleştiriyoruz.

Hiç vakit keybetmeden uygulamamızın kod bloklarını geliştirmeye geçelim.

Şekilden de anlaşılabileceği üzere Global erişim seviyesinde bir SelectPictureDialog referansı oluşturuyoruz. Bir sonraki adımda ise uygulama ekranı yüklendiğinde bu referansa objesini eşitliyoruz ve ilgili özelliklere ilgili değerleri belirliyoruz. Sıra geldi button’ a tıklandığında çalıltırılacak olan kod bloklarına.

İşte bu kadar ! Kod blokları ile ilgili açıklamaları yorum satırı olarak bir üst noktalarına ekledik. Hiç vakit kaybetmeden uygulamamımızı çalıştırıyoruz.

Uygulama ekranı içerisinde hiç vakit kaybetmeden ilgili button’ a basıyoruz ve SelectPictureDialog kontrolünü ekrana getirtiyoruz. StorageCard içerisinde çıkan ilk resmi seçiyoruz.

Resmin üzerine tıklıyoruz :

Ve sonuç ! Mükemmel !

Bu makalemizde Windows Mobile 5.0 API’ leri ile birlikte gelen SelectPictureDialog kontrolünü mercek altına aldık. Bir başka makalede daha görüşmek üzere.

Visual Studio 2005 ile birlikte sistemimize Mobil Uygulama Geliştiricilerin hayatını kolaylaştırabilecek bazı “küçük” uygulamalar yüklenmektedir. Bu uygulamalar tamamen izole ve birbirlerinden farklı amaçlar üzerine geliştirilmiş ; Emülatörler ve Fiziksel cihazlar üzerinde çalışabilmektedirler.

Genel hatlarıyla ;

Remote File Viewer

Remote Heap Walker

Remote Process Viewer

Remote Registry Editor

Remote Spy

Remote Zoom In

Şeklinde sıralanabilecek bu küçük uygulamalar normal şartlarda 3rd party uygulamalar kullanılarak yada mobil cihazımızın sınırlı ekranı üzerinden zahmetli bir şekilde gerçekleştirilebilerek yapılan işlemlerde kullanıcılara masaüstü rahatlığı sağlamaktadır. Bu makale serimizde ise liste üzerinde sıraladığımız uygulamalar ile ilgili kısa açıklamalarda bulunacağız.

Şimdiki durağımız Remote Zoom In. RZI genel hatlarıyla uzaktaki bir cihazın ekran görüntüsü almaya – bu görüntüyü yazdırmaya ve kaydetmeye yarayan yardımcı bir uygulama olarak özetlenebilir. Uygulamanın hangi noktalarda kullanılabileceğine gelinirse ; makalelerde, proje sunumlarında, kitap yazarken v.b. gibi süreçlerde mobil cihazımızın anlık ekran görüntüsüne ihtiyaç duyduğumuzda kullanılabilir. Küçük bir örnekle uygulamayı tanımaya başlayalım.

Uygulamamızı Başlat – Programlar – Microsoft Visual Studio 2005 – Visual Studio Remote Tools – Remote Zoom In seçenekleri üzerinden başlatıyoruz. Karşımıza diğer Remote Tools uygulamalarında olduğu gibi hangi mobil cihaz üzerinden bağlantı kurulacağını soran bir seçenek penceresi çıkmaktadır. Bu pencereden daha öncekilerde olduğu gibi aktif bağlı olan Cihaz / Emülatörü seçerek devam ediyoruz.

OK’ e tıkladığımızda uygulama o an aktif bağlantısı olan Cihaz / Emülatörün ekran görüntüsünü almak üzere bir Progress Bar çıkarmaktadır.

İşlem tamamlandığında :

Şekildeki gibi ekran görüntüsünü uygulamamız sistemimize yüklemektedir.Bundan sonra yapılabilecekler menü üzerinden New Bitmap seçeği üzerinden görüntüyü tazelemek olacaktır.

Emülatör üzerinde değişiklik yapıldıktan sonra New Bitmap seçildiğinde Yeni ekran görüntüsü sistemimize kopyalanmaktadır. Kullanıcılar bu görüntüyü File – Print seçenekleri üzerinden Yazdırabilmektedirler.

Ayrıca Save As seçeneği üzerinden görüntüyü sistemleri üzerine kaydedebilmektedirler.

Bir makalemizin daha sonuna geldik. Bir başka makalede daha görüşmek üzere.

.NET Compact Framework 2.0 daha önceki makalelerimizde belirttiğimiz üzere bir önceki sürümünde “keşke olsa” diyebileceğimiz birçok yenilikle birlikte mobil uygulama geliştiricilerin beğenisine sunuldu. Windows Mobile 5.0’ ında kullanımına geçilmesiyle birlikte mobil cihaz üzerinde yapabileceklerimizin sınırı genişlerken bu yapılabileceklerden uygulama geliştiricilerinde faydalanabilmesi için düzenli süreçler halinde yeni API’ ler yazılmaktadır. Ama hepimizinde bildiği üzere Unmanaged API’ leri kullanarak uygulama geliştirmenin kolay olmayacağı gibi konu ile ilgili SDK’ larda yoğun bir dil üzerinden yazılmaktadır. Bu noktada Managed uygulama geliştiricilerin bu güzelliklerden faydalanabilmeleri için .NET Compact Framework 2.0 üzerinde birçok “Managed” yenilik gelmektedir. Bu makalemizde Windows Mobile 5.0 işletim sistemi üzerinde cihaz ekranı üzerinde kullanıcıyı küçük “popup” niteliği taşıyabilen, ama bir o kadarda yetenekli bir kontrolü ; Notification kontrolünü mercek altına alacağız. Amacımızın her zaman kullanıcıyla maksimum seviyede iletişimin olduğunu göz önünde bulundurduğumuzda Notification kontrolünün bu konuda ne kadar yetenekli olduğunu geliştirecek olduğumuz örnek uygulamada farkedebileceksiniz.

Örnek uygulamamızı geliştirmeye başlamadan önce Notification kontrolünün Özellik ve Olaylarını tanımak bu noktada daha doğru olacaktır.

Şekil üzerindende anlaşılabileceği üzere Notification Kontrolü Windows Mobile 5.0 işletim sistemini kullanan Pocket PC Cihazlarının ekranlarının alt kısmı içerisinde gözüken ; kimi gerekli durumlarda kullanıcıyı bilgilendirmek üzere kullanabileceğimiz faydalı bir Mobil Windows Form kontrolü olarak ifade edilebilir. Şekildeki görünümde dikkatinizi çekmiş olmalıdır ki üzerinde örneğini geliştirecek olduğumuz Notification kontrolü standart düz metinlerin yanısıra görsel açıdan daha kapsamlı mesajlarıda ekran üzerinde kullanıcıya gösterebilmektedir. Bu kavramlar ile ilgili yukarıda örneği makalenin sonunda birlikte geliştireceğiz.

Hızlı bir şekilde makalemize devam edelim. Bu noktada konunun daha rahat anlaşılabilmesi açısından şekilde örneği geliştirmek daha doğru olacaktır.

Örneğin geliştirilebilmesi için ilk olarak yeni bir C# - Smart Device – Windows Mobile 5.0 Pocket PC – Device Application projesi açarak işe başlayalım.

Geliştirecek olduğumuz uygulamanın senaryosu şu şekilde olduğunu kabul edelim. Microsoft Türkiye için bir mobil uygulama geliştirdiğimizi ve bu uygulamanın kullanıcıya belirli periyotlarda Microsoft’ un kendi sitesi üzerinde gerçekleştirdiği bir Anket’e katılıp katılmayacağını sorması gerektiği bir durumu ele alalım. Bu noktada gerçekleştirilmesi gereken senaryoda bu tip bir sorunun gösterildiği konfirmasyon kutusunun uygulamayı kullanan kullanıcıyı rahatsız etmemesinin gerektiği gibi ana ekran üzerindende kullanıcıyı kesinlikle uzaklaştırmamalıdır. Bu noktada Notification kontrolünün ne kadar başarılı olduğu açıkça ve rahatlıkla söylenebilir.

Bir sonraki adımda konu ile ilgili form tasarımı şekildeki gibi gerçekleştiriyoruz ; toolbox içerisinde bulunan Notification kontrolündende form üzerinde bir adet sürükleyip bırakıyoruz.

Kontrolün ToolBox üzerindeki yeri :

Form üzerine bir adet sürükleyip bırakıyoruz.

Şekil üzerinden de anlaşılabileceği üzere Notification kontrolü form üzerinde görsel açıdan herhangi bir anlam ifade etmemektedir. Sadece Form üzerinde eklendiğine dair bir görsel çubuk Visual Studio 2005 Mobil Form Dizayn ekranı altında uygulama geliştiriciyi bilgilendirmektedir. Örneğimize devam etmeden önce kontrolü biraz daha yakından tanımak bu noktada daha doğru olacaktır.

Daha öncede belirtildiği üzere Notification kontrlü adındanda anlaşılabileceği üzere kullanıcıları notifike etmek üzere tasarlanmış bir kontroldür. Bu noktada mantık çerçevesinde düşünüldüğünde kontrolün en temel özellikleri notifikasyon esnasında görüntüleyecek olduğu mesaj, bu mesajın başlığı ve mesajın ne derece önemli olduğu parametresi. Kontrolü uygulamamız içerisinde ntfMICROSOFT olarak adlandırdıktan sonra Özellikler (Properties) penceresi üzerinden kontrolün özelliklerini mercek altına alıyoruz.

Listenin kalabalık olmadığı eminizki dikaktinizi çekmiştir. Bir sonraki adımda bu özellikleri kısaca açıklayalım.

·         Name – Kontrolün benzersiz ismi.

·         Caption – Notifikasyon esnasında bilgilendirme kutusunun üzerinde görünecek olan başlık değeri.

·         Critical – Notifikasyon’ un kritik bir eylem oluğ olmadığı ifade eden bir özelliktir. True değeri bilgilendirme kutusunun etrafının “kırmızı” renk alacağı anlamına gelmektedir.

·         Icon – Opsiyonel ikon değeri. Notifikasyon esnasında ikon olup olmayacağını ifade eder.

·         InitialDuration – İstisnai bir durum oluşmadığı sürece (Kullanıcı Kutuyu Kapatır v.b.) Notifikasyon Bilgilendirme kutusunun ekran üzerinde ne kadar süre görüneceğini belirtir.

·         Text – Notifikasyon metnini ifade eder. Bu özellik ayrıntılı olarak incelenecektir.

·         Visible – En önemli özelliklerinden biridir. True değeri ekran üzerinde görüneceğini ifade eder.

Özelliklerinin yanısıra Notification kontrolünün Olaylarıda bu noktada önemli bir yer teşkil etmektedir. Örneğimize devam etmeden önce kontrolümüzün olaylarını yakından incelemek daha doğru olacaktır.

Evet, bu noktada kalabalık bir liste ile karşı karşıya kalmamaktayız. Olaylar ile ilgilide kısaca açıklama yapmak gerekirse ;

·         BalloonChanged – Adındanda anlaşılabileceği üzere Ekran üzerinde notifikasyon esnasında görünen Balon’ un görünürlüğü değiştiğinde fırlatılır.

·         ResponseSubmitted – Bu olay kontrolün Text özelliğine HTML gömüldüğü ve bu HTML üzerinden bir sonuç geldiğinde tetiklenir. Ayrıntılı olarak incelenecektir.

Genel hatlarıyla kontrol incelendiğinde çokta karmaşık bir yapısı olmadığı kolaylıkla gözlenebilir. Sıra geldi örneğimizi geliştirmeye. Örnek basit seviyeden karmaşık seviyeye doğru geliştirilecektir. İlk olarak form üzerindeki Button kontrolüne tıkladığımızda ekrana basit bir notifikasyon balon’ u getirelim.

Bu değerler üzerinde uygulamamızı Emülatörümüz yada Fiziksel cihazımız üzerinde çalıştırdığımızda şekildeki görünümü görüyor olmamız gerekmektedir :

Ve sonuç. Ekran üzerinde belirttiğimiz özellik değerleri üzerinden bir notifikasyon balon’ u görünmektedir. Peki bu noktada daha kapsamlı neler yapılabilir ? Bu konuya az sonra değineceğiz. Fakat şunu belirterek devam etmeliyizki kullanıcı ekran üzerinde balon dışında herhangi bir lokasyona kalem kullanarak tıkladığında notifikasyon balon’ u kaybolacak ; mavi çubuk üzerinde “Notification” metninin çıkmasını sağlayacaktır. Kullanıcı Notification metnine tıklayarak balon’ un ekran üzerine tekrar gelmesini sağlayabilecektir ; ta ki Visible özelliği false olana kadar.

Sıra geldi özellikler listelenirken ayrıntılı olarak inceleyeceğimizi ifade ettiğimiz Text özelliğinin mercek altına alınmasına.

Text özelliği daha öncede ifade edildiği üzere balon içerisinde gösterilecek olan metni temsil etmektedir. Bu noktada entereasn bir kavram üzerinde konumuza devam edelim.

Uygulama geliştiriciler bu özelliğe çok ilginç ve başarılıdır ki basit HTML sintaksını kullanarak HTML içeriğini gömebilmektedirler. Hemen kafamızdaki soru işaretlerini çözümleyelim.

HTML (HyperText Markup Language) Internet üzerinde kullanılan basit işaretleme dili olarak ifade edilebilir.

Bu dili kullanarak kullanıcılar görsel ortamda her türlü standartize işlemi gerçekleştirebilirler. Peki Notification kontrolü içerisinde bu yapıdan Uygulama geliştiriciler nasıl faydalanacaklardır ?

Konuyu örnek üzerinden anlatmak bu noktada daha faydalı olacaktır :

HTML üzerinde bir metnin kalın olması için metni <b></b> tagleri arasına almak yeterli olacaktır. Ayrıca bir alt satıra geçmek için <br> tag’ inden faydalanabilmektedir.

Text özelliğini şekildeki gibi düzenliyoruz :

Uygulamımızı çalıştırıyoruz :

Ve sonuç. Merhaba ! yazısı ekran üzerinde kalın harflerle yazılmış ve metnin diğer kısmı alt satıra taşınmıştır. Peki HTML kullanarak yapabileceklerimiz sadece metnin görsel anlamda değiştirilmesimi ? Tabiki hayır. Bu noktada HTML kullanarak Balon’ umuzun içerisine Input Tag’ i kullanarak eklenebilecek her türlü objeyi Notification Balon’ umuzun içerisine ekleyebiliriz. Ayrıca bir diğer önemli nokta ise <a href=””></a> tag’ lerini kullanarak metin içerisine linkler gömebiliriz. Şimdi balon’ umuzu senaryomuza uygun olarak düzenliyoruz.

Uygulamımızı çalıştırdığımızda :

Sonuç süper. Kullanıcıya belirli periyotlarda (bu noktada timer kontrolü kullanılabilir) Anket’ e katılıp katılmak istemediğini uygulama ekranından uzaklaştırmadan rahatlıkla sorabiliyoruz. Üzerinde çalışmamız gerekecek tek birşey kaldı. Balon içerisindeki Link yada Button’ lara tıkladığımız zaman gerekli aksiyonları nasıl gerçekleştireceğiz ? HTML ile uygulamamız arasındaki haberleşme nasıl gerçekleştirilecektir ? Hemen cevaplayalım.

Olaylardan bahsederken ResponseSubmitted olayı için “Bu olay kontrolün Text özelliğine HTML gömüldüğü ve bu HTML üzerinden bir sonuç geldiğinde tetiklenir.” Şeklinde bir açıklama kullanmıştık.

Evet, gömülü HTML içerisinden “Response” kavramını ifade edecek bir eylem gerçekleştirildiğinde (buton’ a tıklamaki link’ e tıklamak) sistem gerekli parametreler üzerinde bu olay’ ı tetiklemektedir.

Olay tetiklendiğinde inceleyebilmek açısından gerekli delegeyi Çalışma Zamanında Form yüklendiğinde atıyoruz.

Ve olay tetiklendiğinde yakalanan kod bloğunu incelediğimizde “e” parametresi üzerinden tek bir özelliğin ; Response özelliğinin geldiğini görmekteyiz.

Response özelliği Buton’ a tıklandığında button’ un name özelliğine atanan değeri, link’ e tıklandığında ise Link’ in adres değerin kullanıcıya geri döndürmektedir. Senaryoyu şu şekilde tamamlayalım. Kullanıcı “Evet” butonuna bastığında Mobil Cihazımız üzerinde Internet Explorer uygulamasını açarak anket sayfasına yönlendirelim ; Hayır’ a tıkladığımızda ise sadece balon’ u ekran üzerinden kaldıralım. Ayrıca Link’ e tıkladığında ise Microsoft.com adresine surf yapmasına izin verelim. Kod bloğunu şu şekilde düzenliyoruz :

Uygulamayı hiç vakit kaybetmeden çalıştırıyoruz ve çıkan soruya “Evet “ diyoruz.

Mesaj kutusu kapandığında ise :

Internet Explorer’ ın açıldığını görebiliriz. Ayrıca Microsoft.com linkine tıklandığında ise aynı sonuca ulaşabiliriz.

Evet, bu makalemizde .NET Compact Framework 2.0 ile birlikte gelen Notification Kontrolünü mercek altına aldık. Bir başka makalede daha görüşmek üzere. İyi Çalışmalar.

Genel hatlarıyla bakıldığı zaman Mobil Cihazlar üzerinde uygulama geliştiren uygulama geliştiricilerin, geliştirdikleri bu uygulamaları her zaman fiziksel cihaz üzerinde test edebilme imkanları bulunmayabilir. Bu tip istisnai durumlarda fiziksel cihazların “bire-bir” yerini tutabilecek emülatör adını verdiğimiz “sanal cihazlar üzerinden” yardım almak birçok uygulama geliştirici tarafından iç rahatlatıcı bir yöntem olarak karşımıza çıkmaktadır.

Şu ana kadar üzerinde bahsettiğimiz neredeyse tüm makalelerimizde geliştirmiş olduğumuz Mobil Cihaz uygulamalarımızı ilgili emülatör üzerinde test etmiş ; sonuçlarını emülatörler üzerinden izlemiş bulunmaktayız.

Peki ya geliştirmiş olduğumuz Mobil Cihaz uygulamamızın çalıştırılması için işletim sistemimiz üzerinde bulunan herhangi x bir dosyaya ihtiyaç duyuluyor ise ? Bu tip bir durumda ihtiyaç duyulan fiziksel dosyayı Mobil Cihaz Emülatörüne nasıl kopyalabiliriz ?

Standart fiziksel mobil cihazlar üzerinde bu tip dosyalama işlemleri ilgili araçlar üzerinde işletim sistemimiz vasıtası ile gerçekleştirilebilirken ; Mobil Cihaz emülatörleri üzerinde farklı bir yaklaşımlada gerçekleştirilebilmektedir : Paylaşımlı Klasör (Shared Folder).

Üzerinde çalışıyor olduğumuz mobil cihaz emülatörümüzün içerisinde bulunan işletim sisteminin dosya sistemine herhangi bir dosyayı transfer etmek istediğimizde karşımıza çıkacak olan bu seçenek yardımıyla uygulama geliştiriciler istedikleri herhangi bir dosyayı herhangi bir zaman sürecinde mobil cihaz emülatörü üzerine kopyalayabilmektedirler.

Bu noktada konunun anlaşılabilmesi açısından görsel bir örnek geliştirmek daha doğru olacaktır. Amacımız Windows Mobile 5.0 işletim sistemi üzerinde çalıştırılan bir Mobil Cihaz emülatörüne Paylaşımlı Klasör tekniği yardımıyla bir dosyayı transfer edebilmektir.

Bu amaç uğruna ilk noktada Mobil Cihaz emülatörümüze ilgili bağlantıyı kuruyoruz. Bunun için en etkili ve basit yöntem Visual Studio 2005 üzerinden Connect To Device seçeneğine tıklamak olacaktır.

Açılan pencereden Emülatörümüzü seçip Connect’ e tıklıyoruz.

Connect button’ una tıkladığımız noktada karşımıza bu pencere açılacak ; akabinde emülatörümüz çalıştırılacaktır. Bağlantı ile ilgili durumu üstteki pencere yardımı ile izleyebilmektesiniz. Bağlantının başarılı olduğu bilgisini gördüğünüzde emülatörümüzün ayarları ile ilgili penceresine girmemiz gerekmektedir. File -> Configure ‘ a tıklıyoruz.

Önümüze çıkan ayarlar penceresinde General sekmesi altında bulunan Shared Folder kısmına tıklıyoruz ve bu noktada duraklıyoruz.

Emülatörümüz, kendi üzerinden erişilebilmek adına işletim sistemimiz üzerinde oluşturulmuş olan bir klasörü bizden istemektedir. Makalemizde örnek olarak C:\ kök dizini altında MobilCihazPaylasim adında bir klasör oluşturuyoruz.

Bir sonraki adımda ayarlar penceresinden bu klasörün emülatör tarafından paylaşımlı kullanılacağı bilgisini sisteme kayıt ediyoruz.

OK’ e tıklıyoruz. İşte bu kadar !

Geldik en önemli sürece, klasör üzerinden işletim sistemimiz ve emülatörümüz arasında dosya transferi gerçekleştirmeye. Klasör içerisine örnek bir metin dosyası oluşturuyoruz.

Peki, Mobil Cihaz emülatörümüz üzerinden bu klasöre nasıl erişeceğiz ?

İlgili paylaşımlı dosyaya mobil cihaz emülatörümüzün içerisindeki işletim sistemi üzerinden “Storage Card” olarak ulaşabilmekteyiz. Başka bir söylem ile Mobil Cihaz emülatörümüz ilgili klasörü “Sanal Bir Hafıza Kartı” olarak algılamakta ve işletim sistemi üzerinden bu şekilde kullanıcıların kullanımına sunmaktadır. Mobil cihazımızın dosya sistemi üzerinde Storage Card içerisine giriyoruz.

Ve sonuç ! Mükemmel ! Dosyaya mobil cihazımız üzerinden erişebilmekteyiz. Aynı senaryonun terside bu noktada geçerlidir, yani mobil cihaz üzerinden kopyalanan dosyaya da İşletim sistemimiz üzerinde bulunan klasör içerisinde erişebilmekteyiz.

Başka bir makalede daha görüşmek dileğiyle.

Genel hatlarıyla makalemizin konusunun başlığına bundan yaklaşık 3-4 sene önce bakılsaydı birçok uygulama geliştirici için böyle bir sistemi gerçekleştirmek ütopik ; belkide, imkansız olarak düşünülebilirdi. Mobil Cihazlar’ dan öte standart Windows işletim sistemimiz üzerinde Socket’ ler üzerinden haberleşip birbirleri arasında veri transferi gerçekleştiren uygulamalar geliştirebilemek için bile bundan kısa bir süre öncesine kadar yüksek bir programlama bilgisi gerektirmekte ; herşeyden öte işletim sistemimiz üzerindeki API (Application Programming Interface) Fonksiyonlarını bilmemizi gerektirmekdeydi.

Olaya bu açıdan bakıldığında Socket programlama her zaman uygulama geliştiriciler için bir problem ; en azından bir önceki paragrafta belirtildiği üzere yüksek programlama bilgisi gerektiren bir kavram olmuştur.

2000 yılında .Net Framework “dünyası” ile tanıştığımızda ise neredeyse tüm sıkıntılarımız sona ermiş, yepyeni bir platform ile karşı karşıya kalmıştık. Az önce üzerinde konuştuğumuz yüksek porgramlama bilgisi gerektiren birçok kavramı .Net Framework üzerinde çok daha kolay bir şekilde gerçekleştirmenin verdiği rahatlık ve esneklik ile çok daha büyük ölçekli ve hatasız projeler günümüzde birçok platform üzerinde geliştirilmektedir.

Konuyu bu noktada toparlamak gerekirse birçok noktasında olduğu gibi .Net Framework üzerinde Socket uygulamaları geliştirmekte eskiye nazaran çok daha az efor sarfedilerek gerçekleştirilebilmektedir. System.Net.Sockets NameSpace’ i içerisindeki sınıfları doğru yer ve doğru kombinasyonlar üzerinden kullanarak uygulama geliştiriciler .Net Framework üzerinde çok optimize ve sağlam Socket uygulamaları geliştirebilmektedirler.

Peki .Net Framework üzerindeki bu esnek yapıya .Net Compact Framework üzerinde hangi oranda sahip olabilmekteyiz ? Mobil Cihazlar üzerinde Socket uygulamaları geliştirmek günümüzde hala bir ütopyamıdır ?

İşin biraz derinine inildiğinde özellikle 2.0 sürümü ile birlikte .Net Compact Framework kendisine hayranlık bırakabilecek seviyede başarılı ; konumuz ile ilişkilendirdiğimizde ise hayli sağlam bir grafik çizmektedir.

Socket uygulamaların geliştirilmesi bakımından neredeyse .Net Framework ile başabaş giden .Net Compact Framework , .Net Framework üzerinde olduğu gibi işletim sistemi üzerinde tanımlı olan API Fonksiyonlarını kullanan managed metotları uygulama geliştiricilerin kullanımına sunmaktadır.

Bu makalemizde ise sayfalar dolusu teori ile konuyu anlatmak yerine, Masaüstü Bilgisayarımız üzerinde çalışacak olan bir sunucu uygulaması  ile Mobil Cihaz üzerinde çalışacak olan bir istemci uygulamasını baz alan ; Socket’ ler üzerinden birbirleriyle haberleşen bir mobil chat uygulaması geliştireceğiz.

Bu noktada üzerinde çalışacak olduğumuz kavramlardan bahsetmeden herşeyin “neredeyse .Net Framework ile birebir aynı” olduğunu belirtmek daha doğru olacaktır.

Ayrıca uygulamanın geliştirilme aşamasında standart seviyede Socket kavramlarını biliyor olduğunuzu kabul edeceğiz.

Fakat her ne olursa olsun uygulamamızın parçalarını geliştirmeye başlamadan önce her iki platform üzerinde de ; .Net Framework ve .Net Compact Framework üzerinde de neredeyse birebir aynı çalışma mekanizmasına sahip Socket sınıfını ve metotlarını yüzeysel olarak incelemek bu noktada daha doğru olacaktır.

Sizlerinde bildiği üzere Socket ; bir uygulamanın dış dünya ile iletişim kurabileceği bir kapı olarak kafamızda rahatlıkla canlandırılabilir. Bu noktada kapının bir adresinin ; tipinin ve o kapıdan nelerin geçebileceğinin bilgisinin belirlenmiş olması kapının dış dünya üzerinde çalıştırılabilmesi açısından yeterli parametreler olabilmektedir.

Uygulama geliştiriciler Socket’ ler yardımıyla onlarca protokolün onlarca tipi üzerinden farklı uygulamalar ile haberleşebilir ; veri transferleri gerçekleştirebilirler. Bugün işletim sistemimiz üzerinde kullanıyor olduğumuz birçok “internet” bazlı uygulama işletim sistemimiz üzerinde tanımlı olan WinSock Fonksiyonları üzerinden socket kullanımını gerçekleştirmekte ; bizleri dış dünyaya bağlamaktadırlar.

Olaya bu açıdan bakıldığında Socket programlamanın hiçbir zaman kolay olmadığından ;ileri bir programcılık bilgisi ve araştırma gerektiğinden yazımızın başında bahsetmiştik.

Fakat .Net Framework’ e bakıldığında ise bu işin Managed sınıflar üzerinden ne kadar kolay gerçekleştirilebildiğinden yazımızın başında bahsetmiştik.

.Net Framework içerisinde bulunan System.Net.Sockets NameSpace’ i içerisinde bulunan Socket sınıfı bu noktada gerekli tüm altyapıyı biz Managed uygulama geliştiricilere sunmaktadır. Yapılması gereken tek şey gerekli parametreleri belirledikten sonra bu sınıfın üretilen instance’ ı üzerinden ilgili metotları çağırmak ve veri transferlerini gerçekleştirmek olacaktır.

Şu an ki amacımız bu sınıfı .Net Framework üzerinde kısaca tanıttıktan sonra senaryomuzun ilk parçasını ; masaüstü sunucu uygulamamızı geliştirmek ve hemen akabinde herşeyin ama herşeyin %95 oranında .Net Compact Framework üzerinde de aynı olduğunu ifade ederek makalemizin ilk bölümünü tamamlayacağız.

Socket sınıfı ile ilgili Teorik amaçlı anlatıma geçmeden önce bu noktada örnek uygulamamızın ilk adımını gerçekleştirmeye başlamak daha doğru olacaktır.

Amacımız Mobil Cihaz üzerinden bağlanabileceğimiz ; TCP Protokolü kullanılarak oluşturulmuş bir Windows Masaüstü Sunucu uygulaması geliştirmek olacaktır.

Bu amaca uygun olarak Standart bir C# Windows Application projesi açarak işe başlıyoruz.

Bir sonraki adımda şekildeki Windows Formunu tasarlıyoruz.

Amacımız basit bir arayüz üzerinden “Start Server” button’ u üzerinden dinleme durumuna geçen sunucu uygulaması ile Mobil Cihaz uygulamamızı haberleştirebilmek. Bunun için basit bir kaç kontrolü form üzerine ekliyoruz. Orda noktadaki kontrol bir ListBox kontrolüdür.

Sıra geldi kodlar üzerinde çalışacağımız noktaya. 

İlk olarak belirtmemiz gereken nokta şu olmalıdır ki  uygulamamız asenkron mimari üzerinden geliştirilmelidir. Aksi takdirde bağlantı gerçekleştirilmesi safhasından itibaren her mesaj beklendiği süreçte uygulama ekranı kitli kalacak ; uygulama herhangi bir işe yaramayacaktır.

Bu noktada Socket sınıfı üzerinden hazır gelen bazı asenkron metotları kullanarak bu mimariyi oturtacağız.

Hızlı bir şekilde kaldığımız yerden devam edelim. Kod tarafına geçtiğimizde temel olarak basit birkaç “Callback” metodu ve birkaç delege yardımı ile Socket nesnemizi oluşturup ; sunucu üzerinden “Listen” moduna geçireceğiz. Bundan sonraki adımlarda yapılacak olan tek şey mobil cihaz üzerinden bağlantıyı kurup mesajlaşmaya başlamak olacaktır.

İlk olarak bazı nesne referanslarını global scope alanı içerisinde tanımlıyoruz.

Dikkat edilecek olursa listenin en tepesine System.Net.Sockets NameSpace’ i içerisinde bulunan Socket sınıfının bir referansı tanımlanmış ; bir altına bağlantı kurulduğu noktada karşı istemciyi temsil edecek olan Socket’ in referansı ; onun altına ise Socket sınıfının asenkron metotları çalışmayı tamamladıklarında gidip haber verecekleri metotların adresini barındırabilecek bir signature’ a sahip ; AsyncCallBack delegesinin bir referansı tanımlanmıştır.

En alta ise karşı istemciden mesaj geldiğinde mesajın içerisine yükleneceği 1MB’ lık bir alan teşkil eden bir Byte[] tanımladık.

Kaldığımız yerden devam edelim.

Uygulama tasarımımız asenkron mimari üzerine geliştirileceğinden belirli eylemler “asenkron” olarak gerçekleştirildiğinde işlemlerin sonucu işleyebilmek ve uygulamanın yaşam sürecine devam edebilmesi adına bazı görevleri yerine getirebilmek için iki adet CallBack metodu tanımlıyoruz.

Hiç vakit kaybetmeden şekildeki kod bloğu ile ilgili gerekli açıklamaları ifade edelim.

Kolayca anlaşılabileceği üzere CallBack metotlarının kod sayfası içerisinde yerleştirilebilmesi için tanımlanmış Callback Methods isimli Region içerisine iki adet metot tanımlanmıştır. Bu metotlardan kırmızı kutu ile ifade edilen AcceptedCallBack metodu sunucuya Mobil Cihazımız üzerinden herhangi bir bağlantı başarılı bir şekilde gerçekleştirildiğinde çalıştırılmakta ; Socket objesinin EndAccept isimli Asenkron “sonlandırma” metodu üzerinden karşı socket’ i refere eden socket objesi alınmaktadır. Bir sonraki adımda ise RemoteSocket ismiyle alınan bu socket objesinin Asenkron mimari üzerinden BeginAccept metodu çağırılmakta ; kısaca karşı Mobil Cihaz üzerinden mesajlar “uygulamayı kitlemeden” beklenmeye başlamaktadır.

Bir alttaki, turuncu kutu ile ifade edilen metotta ise BeginReceive ile başlatılan bekleme süreci sonlandığında ; yani Mobil Cihazımız üzerinden bir mesaj geldiğinde çalıştırılacak olan kod blokları geliştirilmiştir.

İlk olarak dikkat edilecek olan satır gelen mesajın nasıl liste kutusu içerisine eklendiğidir.

Bir önceki metotta belirtildiği üzere gelen byte dizisi MessageBuffer isimli byte dizisi içerisinde tutulacaktır. Bu noktada System.Text.Encoding.GetEncoding(1254).Getstring metodu üzerinden faydalanarak gelen byte dizisini “türkçe karakter setine uygun olarak” metne dönüştürüp liste kutusu içerisine ekliyoruz.

Bu satırdan sonra yazdığımız satırda ise MessageBuffer dizisini “yeni gelecek olan” mesajlar için temizliyoruz ; ve uygulamamızı “mesajların gelebilmesi” adına tekrar “mesaj bekleme” moduna geçiriyoruz.

İşte en önemli kısımları halletmiş olduk. Sıra geldi uygulamamızı çalıştıracak olan Socket tanımlama ve mesaj gönderme işlemlerinin gerçekleştirildiği kod bloklarını geliştirmeye.

Amacımız sistemimiz üzerinde 15423 numaralı TCP portu üzerinden dinlemeye ve mesaj göndermeye yarayan bir socket tanımlamak olacaktır. Hiç vakit kaybetmeden şekilde kod bloklarını geliştiriyoruz.

Kod bloğunu ayrıntılı olarak incelediğimizde uygulamamız açıldığında sistem üzerinde TCP protokolü 15423 numaralı porttan dinleyecek ve Stream ; yani akış işlemlerinin gerçekleştirilebileceği bir Socket objesi tanımlanmaktadır. Bir sonraki satırda ise bu socket objesi sistemimiz üzerindeki fiziksel bir port ile ilişkilendirilmektetir. Ayrıca uygulama ekranı yüklendiğinde delegemizin objesi tanımlanmakta ; son olarak ise Asenkron işlemlerde daha önceki makalelerimizde bahsettiğimiz “bir objeye o’ nun oluşturulduğu thread dışında farklı bir thread üzerinden erişmeye çalıştığımızda yaşanan CrossThreadOperationException hatasına karşı” Control.CheckForIllegalCrossThreadCalls static değişkenine “sorun çıkarmaması adına” false değerini veriyoruz.

Button1 isimli Start Server button’ una bastığımızda ise tanımlanan socket objemizi Listen metodumuz üzerinden dinleme moduna geçiriyoruz. Ve BeginAccept metodu üzerinden asenkron mimariyi kullanarak uzaktan gelecek olan bağlantıları kabul edebilecek şekilde yapılandırıyoruz.

Son olarak btnSEND isimli button’ umuza tıkladığımızda ise yazılan metin System.Text.Encoding.GetEncoding(1254).GetBytes metodu üzerinden byte dizisine çevirmekte ve “eğer bağlı bir socket var ise” yani RemoteSocket referansı “null” değil ise karşı noktaya yani mobil cihazımıza göndermektedir.

İşte bu kadar !

Makalemizin ilk bölümünün sonuna geldik. Bir sonraki makalemizde bu makalede geliştirdiğimiz sunucu ile haberleşecek bir mobil cihaz uygulaması geliştireceğiz.

Dağıtık uygulama senaryolarına baktığımızda muhtemelen karşılaşabileceğimiz en büyük problem ortam içerisindeki cihazların birbirleriyle haberleşme esnasında kullanacakları platformdur. Kullanılacak olan altyapının maliyeti yükseltmesi ; ticari bir ortamda pekte hoş karşılanmayacaktır. Bu noktada esnek, geliştirilebilir, güvenli ve “maliyeti düşük” bir platforma ihtiyaç duyulmaktadır.

Olaya bu perspektif üzerinden baktığımızda XML Web Servislerinin bu ihtiyacı fazlasıyla karşıladığını ; dağıtık uygulama senaryolarında “lokasyon’ dan bağımsız” sistemleri birbirlerine maliyeti yükseltmeden bağlayabildiğini rahatlıkla söyleyebiliriz. Belirli güvenlik seçenekleri çerçevesinde XML Web Servisleri yeni jenerasyon uygulama geliştiricilerin dağıtık uygulama senaryolarında tercih olarak seçebilecekleri başarılı seçeneklerin başında gelmektedir.

Bu makalemizde ise dağıtık uygulama senaryolarında en sık karşılaşılabilecek bir senaryoyu ; Mobil Cihazlar üzerinde XML Web Servislerinin kullanımına değineceğiz.

Bu noktada konunun daha rahat anlaşılabilmesi açısından makalenin devamında örnek bir uygulama geliştirilecektir.

Hiç vakit kaybetmeden makalemizin ilk bölümünde Mobil Cihazlar üzerinden çağırılabilecek bir Xml Web Servisi geliştirelim. İkinci aşamada ise bu Web Servisi ile Mobil Cihaz uygulamamız arasındaki bağlantıları gerçekleştirip makalemizi bitireceğiz.

Web Servisimiz girişi yapılan ürün numarası üzerinden kullanıcının Mobil Cihaz üzerindeki uygulamasına gerekli ürün bilgilerini gönderecektir. Bu noktada uygulama güvenliği kullanıcıdan alınan Müşteri kodu olacaktır.

Uygulamamıza başlamadan önce örneğimizde kullanacak olduğumuz veritabanının Northwind veritabanı olduğunu bu noktada belirtmek doğru olacaktır.

Hiç vakit kaybetmeden XML Web Servisimizi geliştirmeye başlayalım. XML Web servisimiz içerisinde iki adet metot olacaktır. Metotlardan ilki kullanıcıdan Müşteri Kod bilgisini isteyecek ve eğer bu bilgiyi Customers tablosu üzerinden doğrulayabilirse uygulamanın ikinci ; Ana ekranını ekrana getirecektir. Bir diğer metot ise Kullanıcı bilgilerinin doğrulanmasından sonra Kullanıcıdan ürün numarasını isteyecek ; sorgulama sonucunda ise eğer bilgi doğrulanabilirse ilgili ürün bilgisini ekrana getirecektir.

İlk olarak Yeni bir Asp.NET Web Servis projesi oluşturarak işe başlayalım.

Proje başarıyla oluşturulduğunda ilk adımda Müşteri Kod bilgisini kontrol eden metodu yazarak örneğimize devam edelim.

Metodu ayrıntılı bir şekilde incelediğimizde yapının çokta karmaşık olmadığını rahatlıkla anlayabiliriz. Metot kullanıcıdan string tipinde Müşteri Kod bilgisini istemekte ve bu bilgiyi doğrulaması sonucunda kullanıcıya sonuç ile ilgili bool tipinde bir değer döndürmektedir. Metodumuzu Internet Tarayıcımız üzerinden denediğimizde ;

Müşteri adı olarak “ALFKI” değerini giriyoruz ve metodumuzu tarayıcımız üzerinden Invoke ediyoruz.

Ve sonuç ! Metodumuz başarılı bir şekilde müşteri kod bilgisini veritabanı üzerinden sorgulayabilmektedir. Sıra geldi ikinci metodumuza. Bu noktada kullanıcımız başarılı bir şekilde giriş yapabilmiş ise ürün numarasını ikinci metodumuza parametre değeri olarak gönderecek ; ürün numarası tablo içerisinde bulunabilmiş ise ilgili ürünün bilgileri kullanıcıya ArrayList içerisinde döndürülecektir.

Metodu ayrıntılı bir şekilde incelediğimizde DataReader üzerinden dönen tek bir satır olduğunu ; bu satırı satırın içerisindeki kolon sayısı kadar dönen bir döngü içerisinde okuduğumuzu rahatlıkla anlayabiliriz. Satır içerisindeki her bir kolon “Kolon Adı : Kolon Değeri” şeklinde ArrayList içerisine eleman olarak eklenmektedir.

Uygulamanın ikinci metodunu tarayıcımız üzerinde test ettiğimizde :

Metodu çalıştırmak istediğimizde :

1 değerini metin kutusu içerisine giriyoruz ve Invoke button’ una tıklıyoruz.

Ve sonuc ! Mükemmel ! Sıra geldi mobil uygulamamıza. Mobil uygulamamız içerisinde iki adet form bulunacaktır. Formlardan ilki kullanıcıyı karşılayacak ; Müşteri kod bilgisini kullanıcıdan isteyecektir. Kullanıcının bu bilgisi Web Servisi üzerinden doğrulandığında uygulamamızın ikinci formu ekrana gelecek ve gerekli bilgiler kullanıcıdan istecenecektir. Bu noktada Mobil Cihaz uygulamamızı geliştirmeye geçmeden önce Web Servisimizi Lokal Web sunuzumuz üzerinden Publish etmemiz gerekmektedir. Bu şekilde Web Servisimiz Lokal Makinemiz üzerinden dış dünyaya sunulmuş olacaktır.Projemizin üzerine sağ tıklıyoruz ve Publish Web Site seçeneğini seçiyoruz.

Gerekli değerleri belirleyip OK’ e tıklıyoruz.

Tek yapmamız gereken uygulamamızın bulunduğu klasörü Internet Information Services üzerinde bir Application Folder (Uygulama Klasörü) olarak tanımlamış olmak.

Seçeğe tıkladığımızda ise :

OK’ e tıklayarak uygulamamızı IIS üzerinde tanımlamış oluyoruz.

Artık web servisimize http://MakinemizinAdi/UygulamaAdi/Service.asmx adresi üzerinden erişilebilmektedir.

Vakit kaybetmeden makalemizin ikinci bölümüne devam edelim. İlk olarak işe yeni bir C# - Smart Device – Device Application uygulaması açarak başlıyoruz.

Bir sonraki adımda ise proje içerisinde standart olarak gelen Windows Form’una ek olarak yeni bir Windows Form ekliyoruz. Form’ un isim değerine frmMAIN değerini atıyoruz.

Ve uygulamamızı geliştirmeye başlıyoruz. İlk form yani frmLOGIN içerisinde şekildeki tasarımı gerçekleştiriyoruz.

Web Servisi entegrasyonu kısmına geçmeden önce ikinci yani Ana Formumuzu’ da geliştirelim.

Ve sonuç ! Form üzerine bir metin kutusu, bir button ve bir Liste kutusu ekledikten sonra sıra geldi Web Servis entegrasyonuna. Bu noktada olayın ne kadar kolay olduğunu ifade edebilmek amacıyla sadece şunu söylemek yeterli olacaktır ; .NET Framework üzerinde bu iş nasıl gerçekleştiriliyorsa .NET Compact Framework üzerinde de o şekilde ! Projenin References sekmesi üzerine sağ tıklanıp Add Web Reference seçeneği üzerinden uygulama geliştiriciler Mobil Cihaz projeleri üzerinde Web Servislerini kullanabilirler.

Add Web Reference seçeneği üzerinden Web Servisimizi Mobil Cihaz uygulamamız ile ilişkilendiriyoruz.

Ve Web Servisimizin lokasyonumuzu yazıyoruz. Bu noktada dikkat etmemiz gereken yapı Web Servisimizin Lokaldeki makinamız üzerinde bulunmasından ötürü adresi “localhost” şeklinde belirtmiş olabiliriz. Bu adres modeli Mobil Cihaz üzerinde bulunamayacak ; haliyle Web Servisimiz ile Mobil Cihazımız haberleşemeyecektir. Doğru adres değeri ise Web Servisinin bulunduğu makinenin ismini ; yani makinemizin ismini yada IP adresimizi değer olarak belirleyerek soruna çözüm bulmuş olabiliriz.

Ne kadar basit değilmi ? Standart .NET Framework masaüstü uygulamalarında olduğu gibi tek yapmamız gereken Web Servisimize erişebilecek “Proxy” sınıfının otomatik olarak oluşturulabilmesi için “Add Reference” button’ una tıklamak olacaktır.

Web Reference Name değerine NorthwindWS değerini belirleyip “Add Reference” seçeneğine tıklıyoruz.

Ve sonuç ! Sıra geldi uygulamamızın giriş ekranı üzerindeki kod bloğunu hazırlamaya. Tek yapmamız gereken uygulama açıldığında Servis Proxy sınıfımızın bir kopyasını almak ve Kullanıcı bilgilerini kontrol eden metodu bu kopya üzerinden çalıştırmak olacaktır.

Kodları şekildeki gibi belirledikten sonra uygulamamızı Fiziksel Cihaz / Emülatör üzerinde çalıştırıyoruz.

Değer olarak ilk adımda yanlış bir Müşteri Kod bilgisi giriyoruz. İkinci adımda ise doğru bir değer girdikten sonra ana ekran görünümünün ekrana geldiğini görmemiz gerekmektedir.

Doğru bir Müşteri Kod bilgisi girdiğimizde ise :

Uygulamanın ana ekranı ekrana gelmektedir. Tek yapmamız gereken ana ekran üzerinde çalışacak olan kodları yazmaktır. Gerçekleştirilecek tek eylem girilen ürün numarası bilgisini Web Servisimiz üzerindeki ilgili metoda göndermek ve gelen object[] içerisindeki metinleri liste kutusu içerisine eklemektir.

Uygulamayı Fiziksel Cihaz / Emülatör üzerinde çalıştırdığımız ve Müşteri Kod bilgisi ekranını başarılı bir şekilde geçtikten sonra :

Ve sonuç !

Ürün numarası Web Servisi üzerinden veritabanımızda sorgulanıp gerekli ürün bilgisi ekrana getirilmiştir !

Bu makalemizde örnek bir Web Servisi uygulamasının Mobil Cihazlar üzerinde kullanımına değindik, başka bir makalede daha görüşmek üzere.

Masaüstü ya da Mobil Cihaz Form uygulamalarında yaşanan en büyük problemlerden birisi döngülerin çalıştırıldığı süreç esnasında uygulama ekranı üzerinde yaşanan kilitlenmelerdir. Bu konuyla ilgili daha önce http://www.yazgelistir.com/Makaleler/1000001208.ygpx adresinde Asenkron Mimarinin uygulanması ; başka bir deyişle işlemlerin farklı bir thread içerisinden yürütülerek halledilebileceğinden bahsetmiştik. Bu makalemizde ise işlemlerin çalıştırılma süreci içerisinde yaşanan bu beklemelerin temel sebebinden bahsedip ; buna farklı bir perspektiften ; Application.DoEvents() metodu üzerinden çözüm arayacağız.

Asıl konumuza geçmeden önce işletim sistemimiz üzerinde bir uygulama başladığı andan itibaren yaşanan süreçten bahsedelim. Bilindiği üzere Windows CE ya da herhangi bir Windows tabanlı işletim sistemi üzerinde herhangi bir kaynak üzerinde gerçekleşen bir olay ile ilgili işletim sisteminin gösterdiği tepkilere bildiğimiz “Olay (Event)” ismi yerine “Mesaj (Message)” ismi verilmektedir. Bu noktada işletim sistemi üzerinde gerçekleştirilen herhangi bir eylem uygulama geliştiriciye Mesaj olarak gönderilmektedir. Zaten Buton üzerinde tıkladığımızda ilgili buton’ un tıklatıldığını işletim sistemimiz donanımsal seviyeden yakalayıp .Net Framework’ e iletmekte ; Olay (Event) olarak tanımladığımız tetikleyiciler uygulamalarımızda fırlatılmaktadır.

Üzerinde konuştuğumuz bu süreç ana uygulama herhangi bir sebepten kapatılmadığı ya da sonlandırılmadığı süre boyunca istisnasız devam etmekte ; gerçekleştirdiğimiz her eylemin karşılığında işletim sistemimiz üzerinden mesajlar fırlatılmakta ve bu mesajlar .Net Framework tarafından yakalanıp işletilmektedir.

Konuyu biraz daha ayrıntılı incelediğimizde istisnasız devam eden bu süreç içerisinde incelenmesi gereken –ki sorunun temel kaynağı olarak ifade edilebilecek- önemli bir başlık daha bulunmaktadır.

Bir önceki örneğimizde uygulama ekranımız üzerine yerleştirilen standart bir button’ un üzerinde gerçekleştirilebilecek en standart eylemden ; üzerine tıklamaktan bahsettik. Bu noktada mantık çerçevesinde düşünüldüğünde ekran üzerinde aynı anda iki butona tıklayamayacığımız açık ve net bir sonuçtur.

Olaya bu açıdan baktığımızda standart yaklaşımla gerçekleştirdiğimiz eylemlere karşılık olarak gönderilen mesajlar işletim sistemimiz üzerinde belirli bir sırayla gönderilip işletilmektedir. Özel, spesifik bir durum dışında bir eylem sonucunda belirli bir iş gerçekleştirildiğinde işletim sistemi üzerinden gönderilen diğer mesajlar uygulama tarafında bekletilmekte ; bir önceki mesajın sonucu başlatılan iş tamamlanana kadar işletilmemektedirler. Peki bu noktada yaşanan nasıl bir problem olabilir ; biraz bu konuya değinelim.

Örnek bir senaryo olarak makalemizin başında adresi verilen Asenkron Mimari ile ilgili makalemizde gerçekleştirilen bir senaryoyu ele alalım. Uygulama içerisinde belirli iki sayı arasında ; ya da belirli bir koşul gerçeklendiği zaman sürecinde onlarca belki yüzlerce kez çalışması gereken bir döngünün olduğunu düşünelim. Bu döngünün döndürüldüğü ; başka bir deyişle çalıştırıldığı süreç içerisinde ise görsel anlamda bazı görevleri yerine getirelim-ki örnek vermek gerekirse gelen her sayıyı bir liste kutusu içerisine eklemek olabilir.

Bir önceki paragrafta anlatıldığı üzere bu “iş” gerçeklenirken işletim sistemi üzerinden onlarca ; belki yüzlerce mesaj fırlatılmakta, fakat o süreç boyunca sistem “döngü” ‘ ye odaklandığı ve onunla ilgili mesajları işlediği için diğer mesajları kuyrukta bekletmektedirler.

Peki az önce üzerinde konuştuğumuz üzere ; özel & spesifik bir durumdan bahsediyorsak ; yani döngü dönerken liste kutusu içerisine eklenen rakamları canlı olarak görmek istiyorsak ; daha açık anlatmak gerekirse gelen rakamların liste kutusuna eklenmesi ile ilgili işletim sistemi üzerinden gelen mesajların döngü çalışırken işletilmesi için nasıl bir yapıyı uygulamamız gerekmektedir ?

İşte bu noktada makalemizin başlığını oluşturan bir metot ; Application sınıfı içerisinde bulunan DoEvents() metodu karşımıza çıkmaktadır.

Application.Run() metodu ile yaşam sürecine başlayan Windows Form uygulamamız içerisinde kuyrukta bekletilen mesajların işlenmesi ile ilgili bir metot olan DoEvents() metodu makalemizinde konusunda ifade edildiği üzere bu tip bekletme durumlarında hayat kurtarmaktadır. Özellikle döngü, koşul bazlı süreçler ele alındığında kullanıcılar kuyrukta bekletilen mesajları işleterek sistemin “olması gerektiği gibi” çalışmasını sağlayabilmektedirler.

Bu noktada konunun daha rahat anlaşılabilmesi açısından örnek bir uygulama geliştirmek çok doğru olacaktır. Senaryomuza göre bir while döngüsü içerisinde koşul sağlandığı sürece o an aktif sayaç değeri liste kutusuna eklenecek ; bu ekleme işinin görsel sonucu canlı olarak ekranda gösterilecektir.

Bunun için ilk olarak bir Smart Device C# uygulaması açıyoruz.

Bir sonraki adımda form üzerine bir buton ve bir liste kutusu kontrolü yerleştiriyoruz.

Ve şekildeki kodları yazarak uygulamamıza devam ediyoruz :

Kodu incelediğimizde basit bir while döngüsünün hazırlandığını rahatlıkla farkedebiliriz. Gerçekleştirdiğimiz tek eylem ise Button’ a tıkladığımızda koşulun sağlanıp sağlanmadığını kontrol etmek ; koşul sağlandığı süre içerisinde de Sayac değerini liste kutusu içerisine eklemek olacaktır. Bu şekilde uygulamamızı çalıştırdığımızda ise :

Scrollbar’ ın küçüldüğünü ; yani sayıların eklenmesi ile ilgili mesajların geldiğini fakat bunların görsel anlamda işletilemediğini rahatlıkla görebiliriz. Bu noktada yaşanan problem ile ilgili yazının başında ayrıntılı bir açıklamada bulunmuştuk. Yapmamız gereken tek şey bekletilen mesajların kuyruktan çekilmesi ve işletilmesi olacaktır ; ki bu noktada Application.DoEvents() metodu karşımıza çıkmaktadır.

Application.DoEvents() metodu her çağırıldığında kuyrukta bekletilen mesajlar otomatik olarak işlem görmektedir. Bu noktada döngü her döndüğünde bu mesaj sayısı yükselmekte ; haliyle kimi zaman tıkanmalara sebep olabilmektedir. Bizim bu noktada yapabileceğimiz tek şey döngü her döndüğünde Application.DoEvents() metodunu çağırmak ve anlık olarak sırada bekletilen mesajı ; yani sayının liste kutusuna eklenmesi ile ilgili işlemi gerçekleştirmemiz olacaktır. Kodu şekildeki gibi tekrar düzenleyip çalıştırıyoruz :

Uygulamayı çalıştırdığımızda ise :

Ve sonuç mükemmel ! İşlem devam ediyor olmasına karşın sayılar ekran üzerinde başarıyla görüntülenmektedir.

Bu makalemizde Application.DoEvents() metodu ile kuyrukta bekletilen işletim sistemi mesajlarını kuyruktan çekmeyi mercek altına aldık. Başka bir makalede daha görüşmek üzere.

Sql Server 2005 Compact Edition uygulama geliştiricilerin beğenisine sunulduğunda birçok yenilikle sahneye çıkmıştı. Bunlardan en önemlisi Sql Server 2005 Compact Edition artık Mobil Cihaz’ lardan sonra Masaüstü uygulamalarında da kullanılabilecekti.

Performans, optimizasyon, birlikte çalışılabilirlik gibi özelliklerini incelediğimizde Basit ve Lokal Veri Depolama senaryolarında Sql Server 2005 Compact Edition çok doğru bir seçenek olacaktır. Bu noktada geliştirilen uygulamaların Sql Server 2005 Compact Edition (bu noktadan sonra Sql CE olarak anılacaktır)veri depolama altyapısı üzerinden programlanabilmesi için managed kod uygulama geliştiriciler sistemlerine Sql CE yükleme paketini kurmaları gerekmektedir. Bu kurulum ile birlikte sistemimize managed Windows Masaüstü ve Mobil Cihaz uygulamalarında kullanabileceğimiz System.Data.SqlServerCe ismi ile kullanabileceğimiz bir referans yüklenmektedir.

Bu referans üzerinden uygulama geliştiriciler tam Sql Server 2005 Compact Edition entegre çalışan uygulama geliştirebilir ; üzerinde aktif olarak çalışıyor oldukları veritabanı üzerinde veri bazlı ve yönetimsel seviyede işlemler gerçekleştirilebilirler. Bu makalemizde bu referans üzerinden uygulama geliştiricilerin kullanımına sunulan ; Sql Server 2005 Compact Edition uygulama geliştirme senaryolarında en temel sınıf olarak kabul edilen bir sınıfı ; SqlCeEngine sınıfını mercek altına alacağız.

SqlCeEngine sınıfı temel anlamda adından da anlaşılabileceği üzere bir Sql Server 2005 Compact Edition motorunu ifade etmektedir. Buradaki motor kelimesinden çıkarmamız gereken anlam temel yönetimsel işlemler gerçekleştirebilecek bir sınıf olarak ifade edilebilir. Genel hatlarıyla sınıfın elemanlarına bakacak olursak ;

listenin çokta karmaşık olmadığını rahatlıkla farkedebiliriz. Metotların ne işe yaradığını teorik olarak anlatmaktansa mobil bir cihaz üzerinde geliştireceğimiz küçük bir örnek bu noktada daha yararlı olacaktır. Örnek .NET Compact Framework 2.0 yüklü Windows Mobile 5.0 işletim sistemine sahip bir Pocket PC cihazı hedef alınarak geliştirilecektir. Bunun için sisteminizde Windows Mobile 5.0 SDK’ nın kurulu olması gerekmektedir.

İlk olarak işe yeni bir Mobil Windows Projesi açarak başlıyoruz.

Bir sonraki adımda makalemizin temel konusu olan sınıfımızın bulunduğu referansı ; System.Data.SqlServerCe referansınızı projemize referans olarak ekliyoruz.

Referansı projemize ekledikten bir sonraki adımda uygulamamızı geliştirmeye hızlı bir şekilde devam edelim. Bu noktadaki amacımız yukarıda ifade ettiğimiz üzere bu referans içerisinde bulunan SqlCeEngine sınıfının metotlarını ve temel amacını mercek altına almak olacaktır.

Hızlı bir şekilde örneğimize devam edelim. Genel hatlarıyla sınıfımızı incelediğimizde yapının nasıl çalıştığını Constructer’ ı üzerinden rahatlıkla anlayabiliriz. Sınıfın Instance’ ını almak istediğimiz zaman karşımıza 2 farklı overloaded constructer çıkmaktadır.

Bunlardan ilki kullanıcıdan herhangi bir parametre istemez iken ikincisi kullanıcıdan mobil cihazınız üzerinde fiziksel olarak bulunan ya da bulunacak olan veritabanına bağlantı kurulacağı noktada kullanılacak olan bir bağlantı cümleciği istemektedir. Bağlantı cüm