ASPNET MVC CORE NEDİR?

Microsoft’un son dönemde gündeme getirdiği ASP.NET MVC Core teknolojisi nedir ? Konuyu ASP.NET üzerine 8 kitap yazmış olan Zafer Demirkol’dan öğrenin.
Reklamlar

CSharp await async keyword Windows Phone MessageBox MessageDialog

Kaynakça: TAŞDELEN Aykut, Bahçeşehir Üniversitesi, Windows Phone Programlama Dersi Notları

CSharp await async keyword ile Windows Phone MessageBox MessageDialog Kullanımı

Visual Studio 2015 güncellemesi sonrasında Windows Phone tarafında da birtakım değişiklikler yaşanmıştır. Sözgelimi mesaj kutusu diyaloğu görüntülemek için geçmişte MessageBox.Show() metodu kullanılırken bu güncelleme sonrasında MessageBox isimli sınıfın yerini MessageDialog sınıfına bıraktığı gözlemlenmektedir. En primitif haliyle bir mesaj kutusu diyaloğu aşağıdaki gibi görüntülenebilir:

// btnTest isimli bir düğmeye tıklandığı varsayılırsa

private async void btnTest_Click(object sender, RoutedEventArgs e)
{

MessageDialog dlg = new MessageDialog(“Kayıt gerçekleşti”, “CSD”);

var result = await dlg.ShowAsync();

}

Bu şekliyle üzerinde sadece başlık ve mesaj bir de varsayılan durumda Kapat yazan bir düğme ile mesaj kutusu görüntülenir.

Burada dikkat edilmesi gereken ayrıntı; ShowAsync() isimli metodun asenkron bir işlem yapıyor olması nedeniyle çağrımında await anahtar sözcüğünün kullanılmış olması, buna bağlı olarak da butona ait event handler’ın da async anahtar sözcüğü ile tanımlanmış olmasıdır.

await anahtar sözüğü; yapılmakta olan asenkron işlemin sonuna kadar beklenmesini sağlar. Bu anahtar sözcüğün kullanıldığı bir çağırma ifadesin yer aldığı fonksiyonlar ise async anahtar sözcüğü kullanılarak tanımlanmak zorundadırlar.

Şayet mesaj kutusu diyaloğu üzerine birden çok buton (en fazla 2 adete izin verilmiştir) eklenmek ve butonlara basılarak birtakım eylemler yaptırılmak istenilirse bu kez:

private async void btnTest_Click(object sender, RoutedEventArgs e)
{
MessageDialog dlg = new MessageDialog(“Kayıt gerçekleşti”, “CSD”);

dlg.Commands.Add(new UICommand() { Id = “1”, Label = “Kaydet”});
dlg.Commands.Add(new UICommand() { Id = “2”, Label = “Vazgeç” });

IUICommand cmd = await dlg.ShowAsync();

switch (cmd.Id.ToString())
{
case “1”:
grd.Background = new SolidColorBrush(Colors.Blue);
break;
case “2”:
grd.Background = new SolidColorBrush(Colors.Red);
break;
}
}

Bu örnekte; List<IUICommand> türündeki Commands isimli property’e IUICommand interface’ini implemente eden UICommand türünde iki adet nesne eklenmiş ve Label property’lerine atanan değerler ile butonların üzerindeki metinler belirlenmiş ayrıca Id olarak da “1 ve 2” değerleri kullanılmıştır.

ShowAsync() metodunun dönüş değeri kullanıcının hangi butona basarak diyaloğu kapattığı bilgisini temsil eder. Bu bağlamda örnekte dönüş değeri üzerinden Id’ye bakılarak hangi buton ile diyaloğu kapatıldığı anlaşılmakta ve ona göre sembolik bir işlem gerçekleştirilmektedir. Aynı şey farklı bir yöntem ile aşağıdaki gibi de yapılabilirdi:

private async void btnTest_Click(object sender, RoutedEventArgs e)
{
MessageDialog dlg = new MessageDialog(“Kayıt gerçekleşti”, “CSD”);
dlg.Commands.Add(new UICommand(“Kaydet”,  new UICommandInvokedHandler(Save)));
dlg.Commands.Add(new UICommand(“Vazgeç”, new UICommandInvokedHandler(Cancel)));
await dlg.ShowAsync();
}

public void Save(IUICommand cmd)
{
grd.Background = new SolidColorBrush(Colors.Green);
}

public void Cancel(IUICommand cmd)
{
grd.Background = new SolidColorBrush(Colors.Yellow);
}

IIS Express Custom HttpHandler, HttpModule Çalışmama Sorunu

İpucu : IISExpress Custom HttpHandler Çalıştırmak

Visual Studio 2013 öncesi versiyonlarda bir ASP.NET uygulamasının Development Server veya IIS Express ile çalıştırılması mümkündü. Örneğin Visual Studio 2010’da bu seçim proje menüsü ile belirlenebilmekteydi. Oysa 2013 ile birlikte söz konusu seçenek ortadan kaldırıldı ve  geliştiriciler IIS Express’e adeta mahkum edildi.

Şayet uygulamalarda custom HttpHandler veya HttpModule’ler yazıyorsanız bunların IISExpress’te çalışmadıklarını gözlemleyebilirsiniz. Bu sorunun çözümü ise custom handler’ın konfigürasyonunu web.config dosyasında eskisinden farklı olarak <system.WebServer> elementi içerisinde aşağıdaki gibi yapmaktır :

<system.webServer>

<handlers>
<add name=”isim” path=”path_bilgisi” type=”handler tür ismi” verb=”*” />
</handlers>

</system.webServer>

Google Aramaları : 

  • IISExpress custom http handler doesnt work
  • IISExpress http handler çalışmıyor
  • IISExpress Development Server Custom HttpHandler Visual Studio 2013 problem

 

C++ Saf Sanal Fonksiyonlar, Overriding ve Polimorfizm

Dikkat : Aşağıdaki yazı C++, Java, C# ile UML ve Dizayn Paternleri kitabımdan sınırlı bir alıntıdır. Dolayısıyla bu yazının izinsiz kopyalanması suç kapsamına girmektedir. 

Sanallık mekanizması türemiş sınıf yoluyla taban sınıfın davranışlarının değiştirilmesi için kullanılır. C++ programlama dilinde şayet taban sınıftaki bir fonksiyon virtual anahtar sözcüğü ile tanımlanmışsa fonksiyon sanal hale gelir. Bunun pratik anlamı fonksiyonun üyesi olduğu sınıftan türetme yapıldığında türeyen sınıfın söz konusu fonksiyonun davranışını değiştirebileceğidir.

#include "stdafx.h" 
#include <iostream> 
using namespace std;
class A 
{
public:     
    void Foo()    
    {        
        cout << "A::Foo" << endl;    
    } 
};
class B : public A 
{ 
public:     
    void Foo()     
    {         
        cout << "B::Foo" << endl;      
    } 
};
int main() 
{      
    A *obj = new B();      
    obj -> Foo();      
    return 0; 
}

Dikkat edilirse obj isimli gösterici (pointer) A taban sınıfı türünde olup, göstericiye B sınıfı türünde bir adres atanmıştır. Bu durum literatürde Liskov’un yerine geçme prensibi olarak isimlendirilir.

uml ve dizayn paternleri

C++ Java ve C# ile UML ve Dizayn Paternleri

Yukarıdaki örneğin çıktısı A::Foo şeklinde olacaktır zira çağrılan Foo fonksiyonu  sanal değildir başka bir deyişle A sınıfına ilişkin Foo çalışmıştır. Oysa Foo aşağıdaki sanal hale getirilirse;

 
#include "stdafx.h"
#include <iostream>

using namespace std;

class A
{
public:
   virtual void Foo()
   {
       cout << "A::Foo" << endl;
   }
};

class B : public A
{
public:
    void Foo() 
    {
        cout << "B::Foo" << endl; 
    }
};

int main()
{

     A *obj = new B();

     obj -> Foo();

     return 0;
}

Bu kez çıktı B::Foo şeklinde olacaktır. C++ 11 ile gelen override anahtar sözcüğü ise opsiyoneldir ve bu noktada kullanımının farklı bir etkisi  olmayacaktır.

class B : public A
{
public:
    void Foo()  override
    {
        cout << "B::Foo" << endl; 
    }
};

C++’ta saf sanal fonksiyonlar ise soyut yani abstract sınıflar içerisindeki implementasyon kodu bulunmayan fonksiyonlardır. Bir sınıfın soyut  olabilmesi için bir tane saf sanal fonksiyona sahip olması yeterlidir. Örneğin aşağıdaki A sınıfı soyut Foo() ise saf sanaldır :

class A
{
public:
      virtual void Foo() = 0; 
};

Buradaki sıfır ataması aslında bir atama değil sadece fonksiyonun saf sanal (pure virtual) olduğunu sintaks açısından gösteren bir dil kuralıdır.

O halde böyle bir fonksiyon ne amaçla yazılmıştır ya da ne zaman anlamlı şekilde kullanılabilir ? Bu soruların cevabı; çok biçimlilik yani  polimorfizmdir.

#include "stdafx.h"
#include <iostream>
using namespace std;
class A
{
public:
       virtual void Foo() = 0; 
};
class B : public A
{
public:
      void Foo() override
      {
              cout << "B::Foo" << endl;
      }
};
class C : public A
{
public:
      void Foo() override
      {
               cout << "C::Foo" << endl;
      }
};
///////////// GLOBAL ///////////////
void Test(A *a)
{
         a -> Foo();
}
int main()
{
         Test(new B());
         Test(new C());
         return 0;
}

Yukarıdaki örnekte A soyut sınıfından iki sınıf (B ve C) türetilmiş ve Foo() fonksiyonu bu sınıflarda farklı şekillerde override edilmiştir. Ayrıca   Test(A *a)    isimli global bir fonksiyon yazılmıştır.  main içerisinde Test(), B ve C türündeki nesneler parametre geçilerek çağırıldığında bu iki nesne için farklı davranış göstermiştir. Yani çok biçimli veya polimorfik davranmıştır.

Polimorfizmin marjinal faydası; ileriye uyumluluktur. Bu örnek üzerinden gidilirse sisteme yeni eklenecek olan bir sınıf örneğin D için Test() fonksiyonunun kodunda herhangi bir değişikliğe ihtiyaç yoktur.

class D : public A
{
public:
    void Foo() override
    {
        cout << "D::Foo" << endl;
    }
};
///////////// GLOBAL ///////////////
void Test(A *a)
{
      a -> Foo();
}
int main()
{
     Test(new B());
     Test(new C());
     Test(new D());
     return 0;
}

Dikkat : 

C++’ta saf sanal fonksiyonlara “genellikle” implementasyona yönelik kodlama yapılmaz. Ama bu bir kural değildir yani istenirse yapılabilir :

virtual void Foo() = 0
 {
    cout << "A::Foo" << endl;
 }

Yukarıdaki kod geçerlidir. Oysa C# ve Java’da saf sanal fonksiyonların karşılığı olan soyut abstract metotlara “asla” implementasyon yapılamaz. Bu dillerde aynı durum  interface içindeki üyeler için de geçerlidir.

Sonuç :

  • Polimorfizm nesne yönelimli programlamanın temel prensiplerinden birisi olup geleceğe uyumlu kod yazabilmeyi sağlar.
  • Sanallık, polimorfizm’in anahtarı olmasına rağmen doğru gerekçelerle kullanılmalıdır ve performans maliyeti olduğu akıldan çıkarılmamalıdır. Maliyetin sebebi; late binding ya da diğer adıyla dinamik binding (bağdaştırma) işleminin çalışma zamanında virtual table mekanizması yoluyla gerçekleşmesidir.

Referanslar : 

1. K ASLAN. C++ Ders Notları, C ve Sistem Programcıları Derneği 

2. A TAŞDELEN. UML ve Dizayn Paternleri (C++, Java ve C# ile), Pusula Yayıncılık

Overt Coupling & C++ Friend Class

C++ Friend Sınıf Mekanizması Overt Coupling’e Neden Olur

Bir sınıf başka bir sınıfa ilişkin üyeleri belli bir izin dahilinde kullanıyorsa aralarında overt coupling söz konusudur. Örneğin C++ programlama dilindeki friend anahtar sözcüğüyle belirlenen arkadaş sınıf mekanizması overt coupling’e neden olur. Hatırlanacağı üzere friend sınıf mekanizması, arkadaşlığın tanımlanmış olduğu sınıfa, arkadaşlığın tanımlandığı sınıfın private ve protected üyelerine özel bir erişim yetkisi vermek demektir.

Okumaya devam et

WPF, Windows Phone Command Binding Event Handling

WPF ve Windows Phone’da Command Binding İşlemiyle Event Handling

Aşağıdaki uygulama Windows Phone için yazılmıştır. Windows Phone, WPF/Silverlight altyapısı üzerine geliştirilmiş olduğu örnekte kullanılan bu özellik WPF ile geliştirilen masaüstü veya Silverlight ile geliştirilen web uygulamalarında da kullanılabilir.

NOT : Bu yazı Aykut TAŞDELEN’in C++ Java ve C# ile UML ve Dizayn Paternleri kitabından alıntıdır izinsiz kullanılıp alıntı yapılamaz ! Konunun devamı söz konusu kitapta yer almaktadır.

WPF’te event handling konusuna command patern’i bağlamında yeni bir boyut getirilmiştir. System.Windows.Input.ICommand interface’i ile command patern’i uygulanarak event handling işlemi gerçekleştirilebilir.

public interface ICommand

{

event EventHandler CanExecuteChanged;

bool CanExecute(object parameter);

void Execute(object parameter);

}

Command nesneleri bir eyleme ilişkin lojiği enkapsüle eder. Böylece uygulamanın çeşitli unsurları bir eylemi gerçekleştirmek istediğinde bunu ilgili command nesnesi yoluyla yapabilir. Aşağıdaki örnekte ICommand interface’inin gerçekleştirimi olan TestCommand sınıfı görülmektedir.

namespace WPhoneCommandBinding

{

public class TestCommand : System.Windows.Input.ICommand

{

public bool CanExecute(object parameter)

{

return true;

}

public event EventHandler CanExecuteChanged;

public void Execute(object parameter)

{

MessageBox.Show(“Test : ” + parameter);

CanExecuteChanged(this, new EventArgs());

}

}

}

Bu sınıfın Execute() metodu parametresine gönderilen bilgiyi mesaj kutusu içinde göstermektedir. Ancak bu sınıfa ait bir nesnenin kullanımı ve Execute() metoduna parametre gönderilişi oldukça ilginçtir zira XAML içerisinden dekleratif şekilde yapılmaktadır.

<phone:PhoneApplicationPage

xmlns:tst=”clr-namespace:WPhoneCommandBinding”>

<StackPanel>

<StackPanel.Resources>

<tst:TestCommand x:Key=”komut” />

</StackPanel.Resources>

<Button
Command=”{StaticResource komut}”
CommandParameter=”Deneme123″
Name=”btnTest” Content=”Test” />

</StackPanel>

</phone:PhoneApplicationPage>

XAML kodu incelenirse öncelikle WPhoneCommandBinding namespace’inin tst kısaltmasıyla tanımlandığı daha sonra buradaki TestCommand türünde komut isimli bir kaynak tanımlanıp bu kaynağın da daha sonra Button’un Command property’sine bind edilerek kullanıldığı görülmektedir. Örnek emülatörde çalışırılıp denendiğinde ise ekrana gelen mesaj kutusu içerisinde “Deneme123” metninin sunulduğu görülecektir.

Dependency Injection & Inversion of Control

NOT : Bu yazı Aykut TAŞDELEN’in C++ Java ve C# ile UML ve Dizayn Paternleri kitabından sınırlı bir alıntıdır izinsiz kullanılıp alıntı yapılamaz ! Konunun devamı söz konusu kitapta yer almaktadır.

c++ java ve c# ile uml ve dizayn paternleri kitap

İlk Türkçe C++ ile Dizayn Paternleri kitabı çıktı !

7.1 Dependency Injection ve Inversion of Control Nedir ?

7.1.1 Giriş ve Tespit

Bu patern basit bir anlatımla bağımlılıkların (dependency) yönetimiyle ilgilidir. Nesne yönelimlilik paradigmasına göre yazılım geliştirmek demek; varlıkları nesneler ile modellemek, ve bu nesneler arasındaki olası ilişkiler ve iletişime dayalı programlama yapmak anlamına gelir. Bu durumun doğal sonucu nesnelerin birbirlerine bağımlı hale gelmeleridir. Bağımlılık algısı gerçek hayatta olduğu gibi nesne yönelimli programlama için de olumsuzdur. Bağımlılıklar mümkün olduğunca azaltılmalı ve yönetilebilir olmalıdır. Dependency Injection patern’i bu noktada bir çözüm sağlamayı hedefler.

Okumaya devam et