Caner Tosuner

Leave your code better than you found it

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.

 

C# Extension Method Kullanımı

Kelime anlamı genişletilebilir metod olan Extension Method'lar C#3.0 ile hayatımıza girmiştir ve yaptığı iş itibatiyle kullanım açısından son derece faydalı metodlardır. Tek cümleyle özetlemek gerekirse class ve struct yapılarını modify etmeden ilgili struct yada class'için extension metodlar eklememizi sağlar.

 Extesion metod yazarken uymamız gereken bir kaç kural vardır. Bunlar;

  • Extension metodlar static bir class içerisinde static olarak tanımlanmalıdır. 
  • Extend edilecek class ilgili extension metoda metodun ilk parametresi olarak verilip önünde this keyword'ü ile tanımlanmalıdır
  • Extension metod da tanımlı parametrelerden sadece 1 tanesi this keyword'ü ile tanımlanır

Hemen bir örnek üzerinde inceleyelim. Case'imiz şu olsun; Bir tane extension metodumuz var ve bu metod integer bir değer alıp asal mı değil mi diye kontrol etsin.

public static class MyExtensions
   {
       public static bool IsPrime(this int integer)
       {
           //tembellik edip implementation'ı yazmakla uğraşmadım :)
           return true;
       }
   }

Yazdığımız metodu aşağıdaki görselde olduğu gibi kullanmak istediğimizde int tanımlı değişkenin adı"." nokta dediğimizde extensionMetod'u intellisense de görebileceğiz. 

class Program
{
    static void Main(string[] args)
	{
		int anyNumber = 123456;
		if(anyNumber.IsPrime())
		{
			//asal sayı
		}
		else
		{
			//asal sayı değil
		}
	}
}

Heralde en güzel yanı da bu olsa gerek metodu extension tanımladığımız için sanki o metod int struct'ına içerisinde tanımlı bir metodmuş gibi direkt olarak "." nokta deyip kullanabiliyoruz. 

Yukarıda ki örnekte int tipini baz alarak ilerledim ancak ihtiyaç dahilinde bütün tipler ve kendi tanımladığımız objeler içinde extension metodlar yazabiliriz.

Yine örnek olarak ; bir Person class'ımız ver ve içerisinde DateTime tipinde ismi BirthDate olan bir property olsun. Bir tane GetBirthDate adında extension metod tanımlayalım ve bu metod bize parametre olarak aldığı Person objesinde bulunan BirthDate alanını return ettirsin.

public class Person
{
	public string FullName {get;set;}
	public DateTime BirthDate {get;set;}
}

public static class MyExtensions
{
	public static DateTime GetBirthDate(this Person prs)
	{
			return prs.BirthDate;
	}
}

 

Şimdi bu metodu kullanan kısmı yazalım

using System;
					
class Program
{
    static void Main(string[] args)
	{
		Person prs=new Person();
		DateTime bDAte = prs.GetBirthDate();
	}
}

Görüldüğü gibi Extension metod kullanım alanımızı ihtiyaca göre genişletip metodlarımızı istediğimiz yerde "." nokta diyerek fıtı fıtı çağırıyoruz :)

.Net Assembly nedir ?

Assembly mi .Net Assembly mi ?

Genelde assembly nedir diye sorulduğunda belkide %80'imiz eski bir programlama dili olan assembly ile karıştırırız ancak aslında soruyu .Net Assembly nedir diye sorsak daha doğru bir soru olacaktır.

.Net Framework ailesindeki dillerden biriyle bir uygulama geliştirdiğimizde yazmış olduğumuz kodlar programlama dilinin derleyicisi kullanılarak bir .dll ya da .exe ye dönüştüğünde kodlar bir assembly içerisine koyulur. Nedir bunlar diye soracak olursak ;

.Net Assembly 4 bölümden oluşur

  1. IL
  2. Metadata
  3. Manifest
  4. Resources

 

 

1) IL

.Net ailesinde bulunan dillerden herhangi biri ile yazmış olduğumuz kodlar derlendikten sonra IL kodlarına dönüşür ve .Net Assembly'da ki IL katmanı bu kodları barındırır. Ancak bu kodlar makine kodu değildir, CLR tarafından makine koduna dönüştürülür. 

 

2) Metadata

Metadata içerisinde uygulamayı yazarken kullandığımız değişkenler, metodlar, external .dll' ler ve onların hangi metodlarının yada değişkenlerinin kullanıldığı bilgisi gibi tanımlamalar bulunur. Örneğin Main fonksiyonunda  Console.WriteLine("Caner Tosuner");  diye bir tanımlamamız olsun.

using System;

class MainApp
{
    public static void Main()
    {
        Console.WriteLine("Caner Tosuner");
    }
}

Metadata içerisinde Console sınıfının WriteLine metodunun kullanıldığı bilgisi yer alır. Yada bizim uygulamada kendi tanımladığımız class ların (Person class'ı gibi) bilgileri ve onların hangi property veya metodlarının kullanıldığı bilgisi de bulunur. Bu arada Visual Studio'da Metadata bilgisinden faydalanmayı ihmal etmemiş, intellisense de VS'da geliştirme sırasında bize öneriler sunarken aslında metadata bilgisinden faydalanmaktadır. 

 

3) Manifest 

Manifest assembly metadalarını diğer bir değişle kimlik bilgilerini tutar. Nedir bu bilgiler diye soracak olursak; assembly versiyon numarası, ürün adı, assembly adı, şirket bilgileri, yasal uyarılar, başka assembly'lerle referans yoluyla olan ilişkileri vs gibi bilgiler tutular. 

 

4) Resource

Uygulamada kullanılan kaynak dosyaların bulunduğu yer. Nedir bu dosyalar ; resim dosyaları, gif'ler, html-xml yada resource files vs olabilir.

 

Sharepoint Rest Get User By

Get All Users List 

http://your-site-name/_vti_bin/ListData.svc/UserInformationList

 

Get A User By Account or Any Other Property

http://your-site-name/_vti_bin/ListData.svc/UserInformationList?$filter=Account eq ‘contoso\administrator’&$select=Id,Name

 

Get Users by Content Type

http://your-site-name/_vti_bin/ListData.svc/UserInformationList? $filter=ContentType eq ‘Person’