Caner Tosuner

Leave your code better than you found it

Web Api Projesi Oluşturma

Şöyle bir örnek proje yapalım. TodoApi adında bir WebApi projemiz olsun ve bu Api'a bir tane controller tanımlayıp içerisine TodoList dönen bir metot yazalım.

İlk olarak Visual Studio açıyoruz ve File => New => Project diyoruz ve aşağıdaki görselde olduğu gibi Web kategorisine tıklayıp sonrada ASP.Net Web Application'ı seçiyoruz ve projenize bir isim verdikten sonra OK'e tıklıyoruz.

 

Daha sonra açılam ekrandan Empty kategorisini tıklayıp ekranın orta kısmında bulunan checkbox'lardan WebApi'ı seçiyoruz ve OK'e tıklıyoruz.

 

Artık solution'da projemiz hazır. Şimdi ilk olarak Models klasörü içerisine TodoItem isminde aşağıdaki gibi bir class tanımlayalım.

namespace TodoApi.Models
{
    public class TodoItem
    {
        public string Key { get; set; }
        public string Name { get; set; }
        public bool IsComplete { get; set; }
    }
}

Şimdi ise TodoController adında controller'ımızı tanımlayalım. Bunun için solution'da bulunan Controller klasörünün üzerine gelip sağ tıklayıp Add diyelim sonrasında açılan ekrandan Controller'ı seçelim ve Controller'a TodoController ismini verip OK'e tıklayalım.

Artık TodoController'ınıda oluşturduk şimdi sırada GetAllTodoItems isminde HTTPGET request'i atılabilen ve geriye List<TodoItem> dönen bir metot yazalım.

public class TodoController : ApiController
    {
        [HttpGet]
        public List<TodoItem> GetAllTodoItems()
        {
            var responseList = new List<TodoItem>
            {
                new TodoItem{
                    Key="SD2",
                    Name="Görev1",
                    IsComplete=true,
                },
                new TodoItem{
                    Key="SD11",
                    Name="Görev2",
                    IsComplete=true,
                },
                new TodoItem{
                    Key="SD251",
                    Name="Görev3",
                    IsComplete=true,
                },
                new TodoItem{
                    Key="SD8",
                    Name="Görev4",
                    IsComplete=true,
                },
                new TodoItem{
                    Key="SD01",
                    Name="Görev5",
                    IsComplete=true,
                },
                new TodoItem{
                    Key="SD42",
                    Name="Görev6",
                    IsComplete=true,
                },
            };

            return responseList;
        }

Api projemiz var. Şimdi gelin bu Api'a requestte bulunup ne response dönüyor onu görelim. Projeyi çalıştıralım ve her hangi bir rest client tool kullanarak aşağıdaki link'e requestte bulunalım.

  • http://localhost/api/Todo/GetAllTodoItems

Ben genelde Postman'i kullanıyorum ve aşağıdaki gibi Postman ile GET request'i atıyoruz.

 

Dönen response'a baktığımızda aşağıdaki gibi json formatında response geldiğini göreceğiz.

 

WebApi candır arkadaşlar ve servis tarafında geliştirme yapıyorsanız da çok ama çok önemlidir. Bir Microsoft yetkilisi bir konferansta şuna benzer bir cümle kurdu "Biz daha iyisini yapana kadar en iyisi bu !".

 

Web Api Projesine Cache Ekleme - OutPutCache

Server-side tarafında geliştirme yapan arkadaşlar bilirler ki request-response time ları çok büyük önem sarf etmektedir. Örnek olarak, bir muhasebe DB niz var ve her gün gece 23:59 da günlük raporlar giriliyor veya 3 dkka yeni kayıt girilen bir yapıda olabilir. İlgili tabloda şuana kadar 200 bin kayıt girilmiş diyelim. select * from Raporlar dediniz ve size 200 bin kayıtı ortalama 15 sn de getirdi (DB nin serve edildiği Pc nin özellikleri ve network hızı gibi çeşitli etkenlere göre değişir). Aslında bu gibi yapılarda ilgili  StoraProcedure e paging parametreleri vererek daha performanslı ve hızlı bir sorgu yazabiliriz ancak bu durum için bile Cache yapısını uygulamamıza entegre edebiliriz. Şimdi bu raporları feed eden bir mobil uygulamamız, Web Sayfanız veya bir masaüstü uygulamanız olabilir ve iş ilgili uygulamanın kullanım oranına göre dakikada 100-200 request te bulunuyor olabilirsiniz. Bu uygulamalara db ile connection'ı sağlayan bir Web Api uygulamamız olsun. Şimdi yukarıda ki case de uygulamada bulunan RaporlarController 'ına dakikada 100-200 arası istek bulunmakta. Ne yapacağız peki sürekli olarak DB ye git select * from Raporlar deyip 200 bin kayıtı almak için 15 sn sürsün network vs işlemlerinden dolayı 2 sn de ordan olsun artı birde kullanıcının internet hızı kotalımı dersin :) ttnet sağolsun hızı düşürmüş 2 mb'e ve oda yaklaşık olarak 5 sn sürsün diyelim (değerler tamamiyle dummy dir). Şimdi küçük bir matematik işlemiyle ortalama kaç sn de veriyi getiriyoruz;

DB QueryResult : 15 sn

WebApi projesinin Download Süresi : 2 sn

Client uygulamasının Download Süresi : 5 sn

Client uygulamasının bu veriyi ekrana çizmeside yaklaşık 2 sn diyelim (Performanslı cihazlarda)

int[] arr = { 15 , 2, 5, 2 };
 
int sumResult = arr.Sum();
Console.WriteLine(sumResult); 
24 saniye 

Adama "Oh My God" dediğinde "Yes your god" diye cevap verirler. 

Tamı tamına 24 saniye  (biraz abartmışta olabiliriz ). Günde ortalama 100 kişinin kullandığını düşündüğümüzde her gelen 24 sn beklicek. Böyle bir projeyi al çöpe at derler adama. Benzer bir olay daha önce çalıştığım bir şirkette başıma geldi ve page_load da db ye gidip 4.600.000 kayıt için sorgu atılıyordu ve bazı işlemler yapılmaya çalışılıyordu. Projeyi bana assign edip müşteri sayfayı açamıyormuş bi bakarmısın dediler ve sorunu anladığımda yazılımdan soğmuştum diyebilirim. 

Her neyse gelelim konumuza. Projeyi bu halde bırakmayalım ama çöpede atmayalım. Projemize sağ tıklayıp nugetten WebApi OutPutCache.Core ve OutPutCache.v2 dll lerini ekleyelim.

Senaryomuz şu şekilde olacak;

1-Controller bazında hem server side için hemde client için iki tarafta da cache sağlayacak bir yapı yapıyoruz. Kullanacağımız kütüphaneye 2 parametre vericez  ServerTimeSpan  ve ClientTimeSpan .  Biri ServerSide için cache'i sağlicak yani kendine gelen ilk request'in response'ını alıp set edilen süre boyunca aynı requestle başka bir kullanıcı geldiğinde cache den alıp o yeni gelen kullanıcıya verecek. Diğeri ise ClientSide için clienta dönen response'un header'ına Cache-Control →max-age=60 eklicek. Bu şu anlama geliyor; Client'a diyor ki arkadaş ben bu respons'u 60 sn cache ledim ve sende istersen gelen response'u biyerde tutup bana 60 sn boyunca gelmeyebilirsin. 60  sn sonra tekrardan gel. Şimdi gelelim code tarafına ilk olarak WebApiCacheAttribute adında CacheOutputAttribute inherıt olan bir attribute tanımlıyoruz. Alında direkt olarak CacheOutputAttribute  controllerımızın içerisindeki metodların başına ekleyebilirdik ancak yönetimi daha kolay olur düşüncesiyle araya işimi daha kolaylaştıran WebApiCacheAttribute  adında CustomAttribute ünü yazdım.

public class WebApiCacheAttribute : CacheOutputAttribute
    {
        public ApiCacheAttribute()
            : this(WebConfigApiClientCacheDuration,WEebConfigApiServerCacheDuration){ }

          public ApiCacheAttribute(int clientCacheDuration = 0,
                                 int serverCacheDuration = 0)
        {
            base.ServerTimeSpan = serverCacheDuration;
            base.ClientTimeSpan = clientCacheDuration;
        }
    }

Üstte görüldüğü gibi bu Cache attribute'ü 2 parametre alıyor. Bu parametreleri attribute implementasyon sırasında aşağıda olduğu gibi biz değer atamaz isek WebConfig dosyasında tanımlı olan değerli alarak Cache sürelerini set ediyor.

WebConfig de appsettings de kayıtlı olan değerleri okuyarak cache işlemini yapar

[WebApiCacheAttribute]
public IHttpActionResult GetItems()
{
      var products= new IkiYuzBinKayit(); //db den 200 bin kayit getirmişiz varsayalım
      return Ok(product);
}

Ama istersek aşağıda olduğu gibi bizde bu değerleri set edebiliriz

[WebApiCacheAttribute(ApiServerCacheDuration=120,ClientCacheDuration=120)]
public IHttpActionResult GetItems()
{
     var products= new IkiYuzBinKayit(); //db den 200 bin kayit getirmişiz varsayalım
     return Ok(product);
}
 

Sonuç olarak web api projemizde cache attribute eklediğimiz metoda yapılan sorgular set edilen sürelere göre cache lenir ve o süre boyunca aynı parametrelerle gelen bütün kullanıcılara cachelenmiş olan response döner. Süreç server cache süresi bittiğinde sonlanır ve yeniden gelecek olan ilk sorgu beklenir ve döngü şeklinde devam eder.

 

Not ! Cache Cache'dir ancak hangi datanın cachelenip cachelenmemesi konusu çok ama çok önemlidir !! İyice düşünüp karar verilmesi gereken bir konudur.

Asp .Net Web Api Nedir

Daha önceki yazılarımızda Web Api dedik, Cache dedik, Exception Handling dedik ama Web Api nedir bir türlü bahsedemedik. Bu yazımızda kısaca Api & Asp.Net Web Api nedir konuşuyor olacağız.

Api Nedir ?

Asp .Net Web Api'a geçmeden önce Api nedir ondan bahsedelim. Aoi açılımı "Application Programming Interface" olan Türkçe'de uygulama geliştirme arayüzü anlamına gelir ve sahip olduğumuz service veya verileri dış dünyaya açıp başka uygulamaların-platformların kullanımına sunmak için belli kurallar çerçevesinde tanımlamalar yaptığımız arayüz dür. 

 

Asp .Net Web Api Nedir ?

Microsoft yetkilileri Web Api sunumlarından birinde şuna benzer bir şey söyledi "Biz daha iyisini yapana kadar en iyisi bu..!"

Asp .Net Web Api ise farklı türde sayısız client (browsers, mobile phones, tablets, pc, etc.) tarafından consume edilebilen HTTP protokolü üzerinden haberleşebilen servisler oluşturmak için kullanılan bir framework şeklinde tanımlayabiliriz. Asp .net MVC ile routing, controllers, action results, filter, model binders gibi ortak feature'lara sahip olduklarından bir takım benzerlikler göstermektedir ancak MVC Framework'ün bir parçası değildir. Asp .net Web Api Core Asp .Net'in bir parçasıdır ve MVC veya diğer web application türleri ile birlikte kullanılabilir. Aynı zamanda bütün bunlardan bağımsız stand-alone Web services application olarakta kullanılabilir. 

 

Neden Asp.Net We Api ?

Günümüz dünyasında teknolojini gelişmesiyle birlikte firmalar artık web tabanlı uygulamalar üzerinden müşterilerine tam olarak ulaşamaz hale geldiler. İnsanlar artık günlük hayatlarının nerdeyse %50 sini akıllı telefonlar, tablet pc vs ile geçiriyorlar ve bu cihazlarda insanların hayatlarını kolaylaştıracak olan milyonlarca uygulama mevcut. Bunların yanında birde İOT ile birlikte gelecek 5 yılda dünyada 30 milyara yakın internete bağlanabilen cihazlar olacağından bahsediliyor ve buda belki milyonlarca Api geliştirmesi demek.

Firmalar veya uygulama geliştiriciler müşterilere daha kolay ve hızlı bir şekilde ulaşmada kullanmak için servislerini ve sahip oldukları verilerin bir kısmını browserlar yada internete bağlanabilen bu akıllı cihazlar tarafından consume edilebilmeleri için Api'lar geliştirmeleri gerekmektedir. Çünkü Api'lar yapısı gereği bütün programlama dilleri tarafından ortak kabul görmüş medya tiplerini (XML-JOSN..etc.) response olarak alıp gerekli parse işlemlerinden sonra kolayca kullanabilir. 

 

Web Api sahip olduğunuz veri ve servisleri birçok farklı cihazda kullanıma sunmak için expose edebilmenizi sağlayan şahane bir framework ve dahası Web Api .Net Framework üzerinde RESTful servisler inşa etmenizi sağlayacak ideal bir open source platform. WCF Rest service'lerinin aksine Web Api HTTP protokolünün bütün özelliklerini kullanır (URIs, request/response headers, caching, versioning, çeşitli content format'ları) WCF Rest Service'lerinde yapıldığı gibi farklı cihazlar için extra config ayarları vs yapmamıza da gerek bulunmamaktadır. Request'i yapılırken dönmesi gereken response'un XML mi yoksa JSON formatında mı olacağına client'ın seçimine bırakılmıştır çünkü Web Api birden fazla medya formatında response dönebilmektedir.

 

Başlıca Web API Özellikleri

  • Http Get, Post, Put ve Delete metodlarıyla çalışabildiğinden CRUD işlemelrini destekler,
  • Response'larda HttpStatusCode ve Accept Header parametreleri bulunur,
  • Response'lar kullanıcının istediği türde MediaTypeFormatter tarafından formatlanabilir,
  • OData desteği bulunmaktadır ve Query yazması oldukça kolaydır,
  • Bir uygulama içerisinde veya IIS üzerinde host edilebilir,
  • MVC'nin bazı özelliklerini taşır (routing, controllers, action results, filter, model binders)

 

Neden Web Api'ı Seçmeliyiz ?

  • Bir web service'e ihtiyacınız varsa ve soap'a ihtiyacınız yoksa en iyi seçenek Web Api dir,
  • Geliştirme sürece WCF de olduğu kadar zahmetli ve sıkıntılı değildir,
  • Http tabanlı olduğundan Rest-ful servisler geliştirmek için en iyi seçenektir,
  • Exception ve Cache mimarileri oldukça performanslı ve yönetilebilir dir,
  • Open Source olduğundan sürekli olarak geliştirilip yeni feature'lar eklenmektedir,
  • Microsoft yetkilileri Web Api sunumlarından birinde şuna benzer bir şey söyledi "Biz daha iyisini yapana kadar en iyisi bu..!" bu demek oluyor ki tam destek.

yield nedir nasıl kullanılır

Bilineceği üzere bir class ın foreach iterasyonuna sahip olabilmesi için IEnumerable interfacesini implement etmesi gerekmekte. IEnumerable 'ı implemente eden class bu implementle birlikte override edilmesi gereken GetEnumerator metoduna sahip olur ve bu metodun içerisini doldurduktan sonra artik bu class da foreach ile gezebilecek duruma gelir. GetEnumerator metodunu override ederken, MoveNext(), Reset() metotlarini ve Current isimli propertyleri ile ilgili logic'i handle etmemiz gerekiyordu. İşte yield sayesinde bunları yapmaktan kurtuluyoruz. 

Mantigi oldukca basit ama bazi projelerde uygulamaya entegrasyonu sıkıntı çıkarabiliyor. Iste bu  sıkıntıları gidermek için C# 2.0 ile birlikte gelen yield keywordu sayesinde bu işlemlerin tumu bizim için arka planda yapilmis olacak.

Senaryomuz şu şekilde olsun; geriye db de kayıtlı olan ürünleri dönen bir metodumuz var ve bu metodu yield kullanmadan ve yield kullanarak yazmaya çalışalım.

Yield kullanmadan

     public static IEnumerable<Product> GetAllProducts()
            {
                using (var db = new DbEntity())
                {
                    var productList = from product in db.Product
                                      select product;
                    return productList.ToList();
                }
            }

 

Bu normal şartlarda kullandığımız yöntem. İlgile metodu aşağıdaki gibi çağırıp dönen listeye direk olarak erişebilirsiniz.

var productList = GetAllProducts();

yield kullanarak ise şu şekilde yazabiliriz 

Yield Kullanarak

public static IEnumerable<Product> GetAllProducts()
            {
                using (var db = new DbEntity())
                {
                    var productList = from product in db.Product
                                   select product;
                    foreach (var item in productList)
                    {
                        yield return product;
                    }
                }
            }

yield da ise şu şekilde çalışır;

döngüye her girdiğinde yield return product satırında fonksiyonun çağrıldığı yere ilgili product item'ını döner yani return'ü gördü diye foreach den ve metoddan direkt çıkmaz ve listenin içindeki tüm elemanlar bitinceye kadar bu işlemi yapmaya devam eder.

IL Disassambler(ILDASM) acarak code tarafında MoveNext,Reset ve Current gibi uyeler yazmamamiza ragmen yield keywordu sayesinde arka planda bunlarin yazildigini goruyoruz.

 Bir diğer örnek olarak ise şunu verebiliriz; 

public void Consumer()
{
    foreach(int i in Integers())
    {
        Console.WriteLine(i.ToString());
    }
}

public IEnumerable<int> Integers()
{
    yield return 1;
    yield return 2;
    yield return 4;
    yield return 8;
    yield return 16;
    yield return 45;
}

Foreach de dönerken her bir int i için IEnumerable<int> Integers() metoduna giderek değerleri bize teker teker döndürebiliyor.

INotifyPropertyChanged Nedir Nasıl Kullanılır

WPF, Windows10 (Mobile,Desktop etc.) uygulama geliştirme ile uğraşan arkadaşlar bilirler ki arayüz tarafında XAML (Extensible Application Markup Language) kullanılır ve codebehind'dan yani C# tarafından uygulama ekranında bulunan herhangi bir UI Control'ünün değeri değiştirme işlemlerini sık sık yaparız. İşte bu gibi işlemleri örneğin TextBlock'un Text'ini değiştirme işlemini C# tarafında tblName.Text="Caner"; yazmak yerine INotifyPropertyChanged interface'ini kullanarak bu gibi işlemleri kolaylıkla ve daha yönetilebilir bir şekilde yapabiliriz. (Tabi sadece TextBlock için geçerli değil, Button'un click event'i gibi durumlarda da INotifyPropertyChanged'İ kullanabiliriz)

INotifyPropertyChanged nedir dersek kısaca şöyle tanımlayabiliriz ;

"C# tarafında yani CodeBehind da tanımlı olan bir class'ın property'sinin değeri değiştiğinde bu değişimden UI'ı yani XAML tarafını bilgilendirmesi" demektir.

 

 

 

Şöyle bir örneğimiz olsun; bir adet Windows Phone uygulaması ve ekranda 2 tane TextBox, 1 tane Button ve 1 tane de Label olsun. Kullanıcı bu 2 TextBox'a birer sayı girecek ve Button'a tıkladığında hemen altında bulunan Label'da bu iki sayının toplamını yazacak.

 

 

HesaplaViewModel.cs class

MVVM pattern ile daha önce uğraşan arkadaşlar bilirler hiyerarşi Model, View, ViewModel diye ayrılır. Bizim uygulamamızda şuan Model yok ancak MainPage.xaml View'i ve hemen aşağıda bulunan ViewModel class'ımız var. Bu class View'imizin DataContext'i olacak ve UI tarafı ile bütün haberleşme bu class üzerinden gerçekleşecektir. ViewModel içerisinde tanımlı olan parametreleri UI'a DataContext üzerinden Binding işlemleri yapıp propertChanged anından UI thread'den durumu haberdar edip Bind olduğu UI Control' deki değerini update edecektir veya bir event ise o event'in davranışına göre çalışacaktır.  

  public class HesaplaViewModel : INotifyPropertyChanged
    {
        private ICommand _HesaplaCommand;
        private int _ilkSayi;
        private int _ikinciSayi;
        private int _sonuc;

        public HesaplaViewModel()
        {
            HesaplaCommand = new RelayCommand(Sum);
        }

        public int İlkSayi
        {
            get { return _ilkSayi; }
            set
            {
                _ilkSayi = value;
                OnPropertyChanged("İlkSayi");
            }
        }

        public int İkinciSayi
        {
            get { return _ikinciSayi; }
            set
            {
                _ikinciSayi = value;
                OnPropertyChanged("İkinciSayi");
            }
        }

        public int Sonuc
        {
            get { return _sonuc; }
            set
            {
                _sonuc = value;
                OnPropertyChanged("Sonuc");
            }
        }

        public ICommand HesaplaCommand
        {
            get { return _HesaplaCommand; }
            private set
            {
                _HesaplaCommand = value;
                OnPropertyChanged("HesaplaCommand");
            }
        }

        private void Sum(object obj)
        {
            Sonuc = İlkSayi + İkinciSayi;
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            var handler = PropertyChanged;
            if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }

 

RelayCommand.cs class

RelayCommand button'a tıklandığında çalışacak olan event gibi düşünebiliriz, Butonun click statelerini aşağıda ki metodlar sayesinde handle edip yönetimini sağlıyoruz

    public class RelayCommand : ICommand
    {
        private Action<object> _action;
        public RelayCommand(Action<object> action)
        {
            _action = action;
        }
        public bool CanExecute(object parameter)
        {
            return true;
        }
        public event EventHandler CanExecuteChanged;
        public void Execute(object parameter)
        {
            _action(parameter);
        }
    }

 

App.xaml 

Burda HesaplaViewModel'ini Resource olarak tanımlama işlemini yapıyoruz.

<Application
    x:Class="App1.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:App1">
    <Application.Resources>
        <local:HesaplaViewModel x:Key="HesaplaViewModel" />
    </Application.Resources>
</Application>

 

MainPage.xaml View'ı

App.xaml de tanımlaış olduğumuz Resource'u DataContext = "{StaticResource HesaplaViewModel}" olarak View'imize verip Binding işlemlerini yapacağız.

<Page
    x:Class="App1.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:App1"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"
    DataContext="{StaticResource HesaplaViewModel}">

    <Grid>
        <Grid HorizontalAlignment="Center" VerticalAlignment="Center">
            <Grid.RowDefinitions>
                <RowDefinition Height="auto"/>
                <RowDefinition Height="auto"/>
                <RowDefinition Height="auto"/>
                <RowDefinition Height="auto"/>
            </Grid.RowDefinitions>
            <TextBox Grid.Row="0" Text="{Binding İlkSayi,Mode=TwoWay}" PlaceholderText="İlk Sayı" Width="200" HorizontalAlignment="Left"/>
            <TextBox Grid.Row="1" Text="{Binding İkinciSayi,Mode=TwoWay}" PlaceholderText="İkinci Sayı" Width="200" HorizontalAlignment="Left"/>
            <Button Grid.Row="2" Content="Hesapla" Width="200" Command="{Binding HesaplaCommand}" />
            <StackPanel Orientation="Horizontal" Grid.Row="3">
                <TextBlock Text="Sonuç : " FontSize="20"/>
                <TextBlock Text="{Binding Sonuc,Mode=TwoWay}" FontSize="20"/>
            </StackPanel>
        </Grid>
    </Grid>
</Page>

 

OnPropertyChanged() metoduna parametre olarak string bir değer almakta. Bu değer propertychanged anında hangi değerin değiştiğini anlamak için bir nevi ID ye benzer bir string değer veriyoruz ve ilgili property'nin değerinin update olma anında hangi property ise bu string parametrelere bakrak anlayabiliriz. Ama bu parametreyi vermek zorunda da değiliz eğer OnPropertyChanged() metodunu bu şekilde kullanırsak da otomatik olarak proeprty'nin ismini alacaktır.

 

Sonuç olarak ise hesapla butonuna tıklandığında çıktı şu şekilde olacaktır.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Görüldüğü üzre yazımızın başında bahsettiğimiz gibi code behind da tblName.Text="Caner";  gibi bir işlem yapmayıp bunu yerine INotifyPropertyChanged interface'inden faydalanıp işlemlerimizi öyle yaptık. Bu bize ne katar dersek, büyük çaplı projelerde genellikle MVVM pattern'i kullanılır ve INotifyPropertyChanged de bu pattern'in ayrılmaz bir parçasıdır. Bu şekilde yazdığımız kod hem daha "kaliteli"(tırnak içinde) hemde daha yönetilebilir oldu. Yarın bir gün dendi ki aynı işlevi yapan bir WPF app geliştirelim. Bu gibi bir durum için yazmış olduğumuz HesaplaViewModel'ini aynen olduğu gibi tek bir satır bile değiştirmeden referans olarak verilen ilgili proje içinde kullanabilir ve böylece çok büyük bir yazılım maliyetinden de kurtulmuş oluruz.

 

Dependency Injection

Yazılımla ilgilenen kişiler bilirler ki proje geliştirmede süreçler çok önemlidir. Müşteriye gidilir, ihtiyaç olan şey dinlenir, analiz edilir ve analiz yazılıp müşteriye sunulur. Müşteri analizi kabul eder ve development süreci başlar. Analiz developera gelir ve 3 ay sonra işini bitirdikten sonra müşteriye projenin sunumu yapılır ve müşterinin çenesi o anda açılır. Bunu da ekleyelim, şunu da yapalım, bu da olsa daha iyi olur.. süreli olarak bu gibi cümleler duymamak hiçten bile değildir. Bu gibi durumları göz önüne alarak projeyi olabildiğince esnek hazırlamak yararımıza olacaktır.

Proje içerisindeki modüllerin bir birlerine gevşek bağlı(loosely coupled) olması, üstte bahsettiğimiz gibi sonradan oluşabilecek talepler için minimum efor sarf change request leri yani sonradan istenilen değişiklikleri hayata geçirmemize katkıda bulunabilir. Bir senaryo ele alalım;

Person ve Car adında classrımız olsun ve bu classların içerisinde Drive adında bir metodumuz olsun ve kullanıcı classının instance alınıp Drive metodu çağrıldığında kullanıcı Car classının Drive metodu çağrılarak araba kullanıyor olsun.

public class Person {
  private Car myCar = new Car();
 
  public void Drive()
  {
     this.myCar.drive();
  }
}

 

Müşterinin isteğine göre araba sürebilen bir Person objesi yaratmış olduk. Peki ya müşteri 2 ay sonra "bu person kamyonda sürsün, motorsiklette sürsün.." derse ? İşte bu gibi durumlar için üstte yazdığımız class işimizi görmicektir ve müşterinin istediğini geliştirmemiz belkide bu güne kadar ki development süresi kadar zaman alabilir de (projenin büyüklüğü gibi vs. konulara bağlı). Üstteki sorunumuz Person objesi Car objesine bağlı ve bu nedenle Bus ve Motorcycle classlarını Person objesine entegre etmemize engel oluyor. İşte Dependency Injection burda devreye giriyor. Amacımız Person objesinin bağımlılığını en aza indirgemek. Bunun için ilk olarak IVehicle adında içerisinde Drive metodu bulunan bir interface yazıyoruz.

public interface IVehicle {
  void Drive();
}

Sonrasında ise bizim Car, Bus ve Motorcycle class larımız IVehicle implemente etsinler

public class Car : IVehicle 
{
  public void Drive()
  {
    Console.WriteLn("Araba sürülüyor");
  }
}

public class Bus : IVehicle 
{
  public void Drive()
  {
    Console.WriteLn("Otobüs sürülüyor");
  }
}

public class Motorcycle: IVehicle 
{
  public void Drive()
  {
    Console.WriteLn("Motorsiklet sürülüyor");
  }
}

Yukarıda ki geliştirmeler ile birlikte artık Person class'ımızın Car Bus gibi objelere olan bağlılığını ortadan kaldırmış olduk yani birbirlerine gevşek bağlı(loosely coupled) halede getirdik diyebiliriz.

Person classımızın yeni hali aşağıdaki gibi olacaktır.

public class Person {
  private IVehicle vehicle {get; set;}

  public Person(IVehicle Vehicle)
  {
    this.vehicle = Vehicle
  }
 
  public void Drive()
  {
     this.vehicle.Drive();
  }
}

 

Person classımızı kullanacağımız yerde artık şu şekilde yazabiliriz;

//Araba sürmesini istediğimizde
var person=new Person(new Car());
person.Drive();

//Otobüs sürmesini istediğimizde
var person=new Person(new Bus());
person.Drive();

Burada IVehicle interfaceîni implemente eden sayısız nesne ekleyebiliriz veya bu nesneler üzerinde değişiklik yapabiliriz ancak bu durum Person classını hiç ilgilendirmiyor çünkü herhangi bir nesneye bağlı değildir.

 

C# "params" Kullanımı

C# dilinde yazmış olduğumuz bir metoda params keyword'ü ile parametre tanımlaması yaptığımızda bu o metodun çok sayıda parametresi olduğuna işaret eder ve bu parametreleri teker teker metodu çağırdığımız yerde ayrı ayrı "," ile ayırıp set etmek yerine bir sefer de parametre olarak verebiliriz. Parametre olarak bir array alan metod olmalı ve tanımlarken tip belirtecinden önce "params" keyword'ü eklenmelidir. Göndereceğimiz array tek boyutlu olmalı ve bir metodda tek bir params anahtar sözcüğü kullanmalıyız. Params keyword'ü alan ilgili metoda yanında başka parametrelerde gönderebiliriz. ancak dikkat etmemiz gereken şey params tanımlamasını tüm parametrelerden sonra yazmamız gerektiği.

Örnek olarak bir tane int array alan bir metod olsun ve metod bu aldığı array de bulunan sayıların toplamını geriye return etsin.

Params kullanmadan

int SayilariTopla(int a, int b, int c, int d, int e)
{
    return a+b+c+d+e;
}

static void Main(string[] args)
{
     int result = SayilarTopla(2,1,4,5,7);
}

Yukarıda ki örnekte görüldüğü gibi 5 tane int parametre alan bir metod ve geriye bu sayıların toplamını dönüyor. Peki bu metod 6-7 veya 1-2 parametre alarakta çalışmasını istersek ne yapacağız ? Ayrı ayrı birkaç metod daha yazacak değilizdir. İşte burda params'ın gücü devreye giriyor

 

Params kullanarak 

int SayilariTopla(params int[] sayilar)
{
  int toplam= 0;
  foreach (int i in sayilar) 
  {
     toplam+= i; 
  }
  return toplam;
}

static void Main(string[] args)
{
    int result1= SayilariTopla(5);
    int result2= SayilariTopla(1, 2,-3);
    int result3= SayilariTopla(-4,4,3,7,-7,1,8,0);
}

Params ile birlikte yukarıda ki gibi SayilariTopla metoduna artık istediğimiz kadar parametre geçip kullanabiliriz. 

C# Indexer Nedir

Indexer özel tanımlı bir property'dir ve sadece class içerisinde tanımlanabilir. Tanımlandığı class'a indexlenebilir özelliği kazandırır. Array işlemlerinde kullandığımız [ ] operatörünü tanımlamış olduğumuz bir bir class'ı diziymiş gibi işlemler yapabilmek içinde kullanabiliriz. Örneğin Department diye bir class olsun ve departman isimlerini önce ayrı bir array içerisinde sonrada indexer yardımıyla class içerisinde tutalım.

Önce çalışan isimlerini ayrı bir List array'de kullanmak istediğimizde nasıl yazıyoruz ona bakalım.

	public static void Main()
	{
		var arr = new List<string>();
		arr[0]="Bilgi İşlem";
		arr[1]="Proje Yönetimi";
		arr[2]="Analiz";
		arr[3]="İş Geliştirme";
		arr[4]="Destek Sistemler";	
	}

Yukarıda da olduğu gibi gayet basit bir şekilde bir List tanımlayıp departman isimlerini bu List'in içine attık.

 

Indexer kullanarak bunu nasıl yapardık birde ona bakalım,

 	public static void Main()
	{
		Department dprt = new Department();
		
		dprt[0]="Bilgi İşlem";
		dprt[1]="Proje Yönetimi";
		dprt[2]="Analiz";
		dprt[3]="İş Geliştirme";
		dprt[4]="Destek Sistemler";	
		
		Console.WriteLine(dprt[4]); //Destek Sistemler
	}

	public class Department
	{
		public string Name { get; set; }
		public int ID { get; set; }

		//indexer tanımlaması
		private string []names = new string[5]; 
		public string this [int index] 
		{ 
		   get 
		   { 
			   return names[index]; 
		   } 
		   set 
		   { 
			   names[index] = value; 
		   } 
		} 
	}

Yukarıda da görüldüğü üzre Department class'ımıza indexer kullanarak indexlenebilir özelliği kazandırdık ve [ ] kullanarak tıpkı array kullanıyormuş gibi değer atama ve değer okuma işlemlerini yapabildik

Görüldüğü gibi bir class içerisinde property tanımlar gibi indexer tanımlayabiliyoruz. Düşünüldüğünde çok gerek duyulan bir özellik değil gibi duruyor çünkü genelde başka şekilde ihtiyacımızı görüyoruz ama ama örnek olarak Ado.net ile uğraşan arkadaşlar SqlDataReader class'ını bilirler database'den den belli bir column'da bulunan değeri okumak için aşağıdaki gibi dr["Name"] yazarak o değere ulaşmamızı sağlar bunu yapabilmemizin sebebi SqlDataReader class'ı içerisinde indexer tanımlandığından dolayı [ ] diyerek get işlemi yapabildik

SqlDataReader dr = cmd.ExecuteReader();  
ArrayList names= new ArrayList();  
while (dr.Read())  
{  
     names.Add(dr["Name"]); //SqlDataReader class'ı içerisinde indexer tanımlandığından dolayı [ ] diyerek get işlemi yapabildik 
}  

 

C# Kodlarının Derlenip Çalıştırılması - CLR,IL,CLS,CTS Kavramları

C# yazıyoruz çalışıyor, VB yazıyoruz çalışıyor, C++ yazıyoruz çalışıyor, ne hikmettir pek bilmesek bile bir F# dilimiz var onu yazıyoruz .Net sağolsun onu da çalıştırıyor... 

Peki ama bütün bunlar nasıl oluyor ?..

.Net framework içerisinde geliştirme yapabilmek için bir çok dil mevcuttur ancak C# bunlardan en torpillisidir diyebiliriz heralde. Tamamen OOP dayalı bir dil olmasıyla beraber günümüz .Net ailesinde en çok tercih edilen dil haline gelmiştir.

Aşağıdaki resimde de görüldüğü üzre v1.0 dan başlayıp v4.5' e kadar gelen süreçte ne gibi yenilikler geldi, ilk başlarda neler yapabiliyorken son sürümle birlikte ne gibi yeni özellikler geldi bunları görebiliriz. 

Bütün bunlar güzel hoşta arkadaş bunları üstte bahsettiğimiz .Net ailesi içerisinde bulunan çeşitli programlama dilleriyle yapıyoruz ama nasıl oluyor da C# ile yazılan projenin çıktısı ayrı, F# ile yazılanın ki ayrı, VB ile yazılanın ki ayrı iken framework bunları yorumlayıp çalıştırıabiliyor ?.. 

Yazılmış olan kodların direkt olarak derlenip çalıştırılması gibi bir cevap düşünecek olsak o zamanda her bir programlama dili için ayrı ayrı bu işlemleri yapan logic'ler gerekecektir bu da çok fazla iş yükü,maliyet vs demektir ve aslında mümkünde değildir.

 

Aşağıda bulunan görsel aslında yazmış olduğumuz projelerin çalışmasına kadar olan süreci özetliyor gibi.

 

CLR - Common Language Runtime

.Net framework altında bulunan dillerden herhangi biriyle program yazdığımızda kodlar ilk olarak CIL (common intermadiate language) diğer bir deyişle IL dediğimiz byte kodlara dönüşür. Bu IL kodları aslında çalıştırılabilir kodlar değildir ve çalıştırılabilmesi için bir ara programa ihtiyaç vardır. Bu ara program da CLR'dır. CLR dönüştürülmüş olan byte IL kodlarını alıp bir JIT (Just-In-Time) derleyicisini etkinleştirerek makine koduna dönüştürür ve çalıştırır.

 

CLS- Common Language Specification

CLS için .Net framework çatısı altında bulunan programlama dillerinin ortak noktalarını barındırır ve programımızın diğer dillerle olan etkileşimini sağlar. Diller arasında ortak kullanılan yapılar ve onların birtakım kuralları bulunmaktadır. Yazdığınız kodların diğer programlama dilleriyle geliştirilen projelerde de kullanabilir olması istiyorsanız, Common Language Specification kurallarına uyumlu kodlar yazmamız gerekmektedir. Bu kurallara uygun geliştirdiğiniz kodlar, CLS desteği olan diller tarafından yorumlanabilir ve böylece diller arasında ki iletişim sağlanmış olur.

 

CTS- Common Type System

CTS CLR'ın bir alt kümesidir diyebiliriz. Şöyle ki; Common Type System sayesinde programlama dillerinde kullanılan veri türlerinin(int,double,byte,string etc.) arasında da uyum sağlanmış olur.

Örnek olarak; .Net framework altında bulunan bütün dillerde int,double,float vs. gibi tiplerin ram'da kapladıkları yer aynıdır ve bu dillerden biri için derlenen kodlar referans olarak diğerinde de kullanılabilmektedir. Bu nedenle Framework içerisinde bulunan tüm dillerde CTS den dolayı ayni kurallara sahip veri tiplerini kullanılır farklı olan şey syntax'dır.