Decorator Nedir?

Decorator, sınıflarla ve içindeki methotlarla, parametrelerle, property’lerle, erişimcilerle etkileşime girebilen bir tür özel fonksiyonlardır. Bu bahsettiğimiz şeyleri değiştirmemize, içine yeni değerler eklememize, değerlerine göre farklı aksiyonlar almamıza ve de bunlara meta data olarak adlandırdığımız bilgi yükleme olanaklarını bize sağlar.

JavaScript’te Dekoratörler henüz stage 2 seviyesinde olup TypeScript’te ise deneysel olarak kullanılmaktadır. TS 5.0 ile stage 3 seviyesine ilerlemiş ve kullanımında değişiklikler yapılmıştır. Bu yazı stage 2 özelliklerini anlatmaktadır.

Decorator’lar ile annotations ve meta-programming yapılması mümkün hale gelmiştir. Meta data’nın ne olduğunu ve bununla neler yapılabileceğini “C# Attribute’lara Derinlemesine Bakış” adlı yazımdan detaylıca öğrenebilirsiniz.

Bunlar dışında nesne üzerindeki verileri doğrulayabilir, fonksiyonunuz çağrıldığında ondan önce çalışacak bir sarmayalıcı oluşturabilirsiniz.

Nasıl kullanılır?

Decorator’ler hala dile tam olarak eklenmediği için TypeScript Compailer’a decorator kullanacağımızı belirtmemiz gerekiyor. Derleme komutunuza --target ES5 --experimentalDecorators ekleyerek ya da tsconfig.json dosyanıza aşağıdaki key’i ekleyerek kullanıma hazır hale gelebilirsiniz.

"compilerOptions": {
  "target": "ES5",
  "experimentalDecorators": true
}

Dekorator’ler @decoratorİsmi şeklinde çağrılır. Run time anında decoratorİsmi fonksiyonuna ifade ettiği alanın bilgileri verilerek çağrılır. İlgili alanların önüne ya da bir üst satırına yazılarak kullanılabilirler ve içlerine parametre alabilirler.

@veritabanıTabloİsmi('users')
class Kullanıcı {
  @benzersizOlmalı
  email: string;
  
  @yöneticiMi
  set birimNumarası() {}  
  @methodDekoratörü
  fly( @büyükOlmalıdır(10) meters: number ) {}  
}

Çoklu Decorator kullanımı

Aynı alan için bieden fazla dekorator kullanımı mümkündür.

Aralarına boşluk bırakarak tek satırda yazılabilir.

@a @b @c
function kaydet(){}

veya alt alta kullanabilirsiniz.

@a
@b
@c
function kaydet(){
  console.log('kaydet fonksiyonu çalişti');
}

Değerlendirilme ve Çağrılma Sıraları

Sınıf dekoratörü new anahtar kelimesi kullanıldığında diğerleri ise bulunduğu method tetiklendiği anda ilk önce değerlendirilir ardından ise çağrılır. Değerlendirme işlemi Decorator Factory kısmında bahsedeceğimiz fonksiyonların gövdesinden ibarettir. İlk önce alana tanımlı olan Factory gövdeleri çalıştırılır ardından ise Factory’nin geri döndüğü ana dekoratör.

Üyeler arasındaki sıralama

Dekoratörlerin birbirleri arasındaki çağırılma sırası şu şekildedir:

1- Parametre dekoratörleri ardından method, erişimci ve son olarak property dekoratörleri sınıftan üretilen instance için çalıştırılır.

2- Parametre dekoratörleri ardından method, erişimci ve son olarak property dekoratörleri sınıfın statik üyeleri için çalıştırılır.

3- Kurucu fonksiyonların parametre dekoratörleri çalıştırılır.

4- Sınıfın dekoratörü çalıştırılır.

Yani daha akılda kalıcı olacak şekilde söylersek dekoratörler içeriden dışarıya doğru sıralanır. parameter -> method -> accessor -> property -> constructor -> class

Aynı üyedeki birden fazla dekoratörün sıralaması

class Kullanıcı{
  @a @b @c
  function kaydet(){
    console.log('kaydet fonksiyonu çalıştı');
  }
}
let k = new Kullanıcı();
k.kaydet();

Bunların çalıştırma sırası alana en yakın olandan en uzak olana doğrudur. Matematikdeki birleşim özelliği bunun en güzel açıklamasıdır a(b(c(kaydet))) veya (a o b o c)(kaydet) fakat değerlendirme sırası ise en dışarıdan en içeriye doğrudur.

Nasıl Kendi Decorator’ımızı Oluştururuz?

Her dekoratör ait olduğu üyeyi ve ona ait diğer özellikleri içine alır böylece o üyeyi manipüle edebiliriz.

Class Decorator

Tek parametresi vardır o da sınıfın constructor fonksiyonudur. Burada sınıfın içine yeni method veya property ekleyebilir yada olanları ezebiliriz.

// toString fonksiyonunu ezen ve JSON stringfy yapan dekoratör
function toString<T extends Consturctor>(BaseClass: T) {
  return class extends BaseClass {
    toString() {
      return JSON.stringify(this);
    }
  };
}

@toString
class C {
  public foo = "foo";
  public num = 24;
}

Dekoratörün geri dönderdiği değer sınıfla değiştirilecektir.

Method Decorator

Üç parametresi vardır bunlar sırasıyla: hedef aldığı fonksiyon, fonksiyonun ismi ve method için Property Descriptor tipindeki bit tanımlayıcı.

Methodu yeniden atamak, method çağrıldığında log’lama ve benzeri işlemler yapmak için kullanılabilir.

Descriptor içinde şu key’ler bulunur:

• value
• writable
• enumerable
• configurable

function logger(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const original = descriptor.value;

  descriptor.value = function (...args) {
    console.log('params: ', ...args);
    const result = original.call(this, ...args);
    console.log('result: ', result);
    return result;
  }
}

class C {
  @logger
  add(x: number, y:number ) {
    return x + y;
  }
}

const c = new C();
c.add(1, 2);
// -> params: 1, 2
// -> result: 3

Kendisini veya yeni bir PropertyDescriptor geri dönmelidir.

Property Decorator

İki paraketresi vardır ve bunlar sırasıyla bulunduğu sınıfın kendisi ve hedef aldığı property’nin ismidir.

Genellikle doğrulama yapmak için kullanılır.

function resit(target: any, key: string) {
  const setter = function (newVal: number) {
    if (newVal < 18) {
      throw new Error("Yaş 18'den büyük olmalıdır.");
    }
    this[key] = newVal;
  };

  // Property'i tanımlama
  Object.defineProperty(target, key, {
    set: setter,
    enumerable: true,
    configurable: true,
  });
};

class C{
  @resit
  yas: number
};

Geri dönüş değeri yoktur.

Accessor Decorator

Method dekoratörleriyle aynı parametreleri alır. TypeScript get ve set erişimcileri için tek bir Property Descriptor üretir bu yüzden işlem yapılırken bu göz önünde bulundurulmalıdır. Bu nedenle descriptor yapısı method dekoratörlerinden farklıdır.

Descriptor içinde şu key’ler bulunur:

• get
• set
• configurable
• enumerable

Genellikle erişim yapılabilecek durumları düzenlemede, erişim için tetiklendiğinde log’lama yapmak gibi işlemlerde kullanılır.

Kendisini veya yeni bir PropertyDescriptor geri dönmelidir.

Parameter Decorator

Üç tane parametresi bulunur ve bunlar sırasıyla: bulunduğu sınıf, bulunduğu method’un ismi ve o method’un kaçıncı parametresi olduğunun index’idir.

genellikle parametrelerin doğrulanması için kullanılır.

function resit(target: any, key: string, index: number) {
  const originalMethod = target[key];

  // Hedef methodun yerine yeni bir method tanımlıyoruz
  target[key] = function (...args: any[]) {
    const paramValue = args[index];
    if (paramValue < 18) {
      throw new Error("Parametre değeri 18'den büyük olmalıdır.");
    }
    return originalMethod.apply(this, args);
  };
}

class C{
  createUser(isim: string, @resit yas: number) {
    //...
  }
}

Geriye bir değer döndürmez.

Decorator Factory

Şu ana kadar nasıl dekoratör oluşturabileceğimizi sistemin bize hangi bilgileri sağladığını ve bunlarla ne yapabileceğimizi gördük peki kendimiz de dışarıdan kendimiz parametre almak istediğimizde ya da dekoratör çağrılmadan önce de bir şeyler yapmak istedimizde ne yapmalıyız sorusuya baş başayız.Bu sorunun cevabı oldukça basit. “Dekoratörü de bir fonksiyonla sarmalıyız.”

Tek yapmamız gereken almak istediğimiz parametreleri dışarıdan almak ve geriye bir dekoratör döndermek.

function büyükMü(sayi){
  return function(target, propertyIsmi){
    if(target[propertyIsmi] > sayi)
      throw new Error(`${propertyIsmi} ${sayi}'dan büyük   olmalıdır.${propertyIsmi}:${target[propertyIsmi]}`);  
  }
}
class Kullanici{
  @büyükMü(18)  
  yas: number;
}

Not: Decorator factory ile oluşturulan dekoratörler mutlaka () ile kullanılmalıdır aksi taktirde sadece factory gövdesi çalışmaktadır.

Örnek Senaryo:

Şu ana kadar öğrendiklerimizle basit bir routing uygulaması yazabiliriz. Bu uygulama gelen Class ve methodlara verilen dekoratörlere göre gelen istekleri yönlendirecektir. Class’lara path(p: string) isteğin geleceği path’in ana kısmını method’lara ise get , post , delete gibi dekoratörlerle dinleyeceği methodu ve varsa ana path üzerine eklenecek şeyi bilirecektir. Ana uygulama tüm class’ların metalarını toplayıp gelen istekreki path’i ve method’u parçalayarak ilgili method’u çağıracaktır.

Örnek sınıf:

@path('/users')
class UserController{
  @get('/:id')
  getUser(request, response){}
  
  @get()
  getUsers(req, res){}
  
  @post()
  createUser(req, res){}
}

Kaynakça:

• Documentation - Decorators
• A Complete Guide to TypeScript Decorators
• How To Use Decorators in TypeScript | DigitalOcean
• Typescript Decorator Nedir?

Forwarding’i anlayabilmek için gelin ilk önce üstünkörü X11'in nasıl çalıştığına bakalım.

Xlib Nedir?

C programlama dili ile geliştirilmiş ve Linux dünyasının duayen grafik kütüphanesi haline gelmiş olan Xlib, sunucu ve client mantığı ile çalışır.

Client(kullanıcı, masaüstü uygulaması) çizim fonksiyonlarını kullanarak X protokolü ile sunucuya istek gönderir. Sunucu gelen isteği yorumlar ve yapılması gereken çizimi hesaplar ve çizdirir.

Sunucu kendi bilgisayarınızda olabileceği gibi başka bir bilgisayarda da olabilir. Xlib ile uygulama yazarken kodunuzda bunu belirtebilirsiniz veya sisteminize doğrudan varsayılan bir adrese bağlanmasını söyleyebilirsiniz.

Uzak Sunucuya Bağlanmak

Uzak sunucuya bağlanma ve X11 ile konuşma işini bizim için ssh programları yapar.

Linux bir bilgisayardan Linux bir sunucuya bağlanmak için doğrudan ssh komutunu kullanabiliriz, Windows’tan bağlanmak içinse PuTTY gibi bir ssh client işimizi görecektir.

Sunucuyu hazırlamak:

X11 yönlendirmesini kullanabilmek için sunucunuza forwarding ayarı yapılmalıdır.

Sunucunuzda /etc/ssh/sshd_configadresinde bulunan ssh config dosyasına X11Forwarding yes eklemeniz veya # ile başlıyorsa bunu silip yorum satırından çıkarmanız gerekmektedir. Ardından ssh server’ınızı “systemctl” veya “systemd” gibi programlarla yeniden başlattığınızda kullanıma hazırız.

Güvenlik için lütfen cookie ve XAUTHORITY ayarlarına bakın

Sunucuya bağlanmak

Linux üzerinde ssh komutunuza -X eklediğinizde X11 yönlendirmesini devreye alacaktır.

Örnek olarak:

ssh -X kullanici@adres.com

Windows bilgisayarda ise PuTTY veya kullandığınız ssh client’ının ayarlar bölümünden “X11 Forwarding” alanını aktifleştirmeniz gerekmektedir.

Sunucuya ssh bağlantısı kurduktan sonra çalıştıracağınız ve normalde arayüz ayağa kaldıran komutların çıktısı otomatik olarak bilgisayarınıza yansıyacaktır.

Örnek vermemiz gerekirse code . komutunu çalıştırdığınızda VS Code bulunduğunuz klasörü açacaktır. VS Code, dolphin, gedit, gimp ve birçok uygulamayı bu yöntemle uzaktan açabilirsiniz.

Tüm iletişim internet üzerinden yapıldığı için donanımınıza ve internet hızınıza göre gerçeğe yakın veya ortalama 1 saniye kadar gecikleyle işlemlerinizi gerçekleştirebilirsiniz.

Kodumuzun düzgün bir biçimde çalışıp çalışmaması kadar da geliştirilebilir ve anlaşılır olup olmadığı da onun ne kadar kaliteli bir kod olduğunu belirliyor.

Kodumuzu daha anlaşılabilir en etkili yollarından birisi de onu nitelikli bir şekilde açıklamaktan geçtiğini unutmayalım. Peki gerçekten kaç kişi hem koduna yorum düşüp hem de ayrıca nasıl çalıştığı hakında bir doküman yazıyor? Bir elin parmakları kadar mı? Gelin bu iki işi aynı anda yapmanın kolay yolu olan otomatik doküman oluşturuculara JavaScript dili için bir göz atalım.

Otomatik Doküman Oluşturucu Nedir?

Otomatik doküman oluşturucu aslında ayrı bir program olup tek yaptığı iş kodunuzu okuyup yorumlamaktır. Bu program kodunuzu string olarak okur, dil yapısına göre parçalar ve eklediğiniz yorumları da kullanarak bir HTML olarak ya da eklentilerle MarkDown gibi formatlarda doküman oluşturabilir, küçük eklemeler yaparak bunları doğrudan websitesi olarak kullanabilirsin.

Java için Javadoc, PHP için phpDocumantor, JavaScript için ise JSDoc programlarını örnek gösterebiliriz.

Avantajları Nelerdir?

• Kaynak koduna yorum düştüğünüz için kod yabancı kişilerce daha kolay anlaşılır.
• Kodun kullanımı ve püf noktaları hakkında ayrıca doküman yazmanıza gerek kalmaz. Sadece kaynak kodunuza yorum düşmeniz bunu yapmak için yeterlidir.
• Popüler olarak kullanılan çoğu IDE ve bazı text editörler bu yorumları algılar ve kodunuzu kullanırken bu bilgileri görselleştirerek hızlı geliştirme yapmanıza olanak tanır.
• JavaScript gibi tip güvensiz diller için sanki derleme yapılıyormuş gibi tip kontrolü yapılmasına olanak sağlar

Nasıl kullanılır?

JSDoc kendi yorumlarının /** ile başlamasını zorunlu tutar. // , /* gibi normal yorum bloğu başlangıçlarını veya ikiden fazla yıldız olanları görmezden gelir.

/** JSDoc için uygun yorum yazımı */

/**
 * Bu şekilde de kullanabilirsiniz
 */
function foo() {
}

JSDoc’un parser’ının yorumlayacağı her özel kelimeye tag yani etiket denir.Etiketler @ karakteri ile başlar.

Bilgisayarınıza npm’i kurduktan sonra npm install -g jsdoc ile global olarak bilgisayarınıza veya npm install jsdoc komutu ile lokal olarak sadece şu an üzerinde bulunduğunuz projeye yükleyebilirsiniz.

Programı çok temel olarak jsdoc <dosya-ismi> şeklinde kullanıabilirsiniz. Bu size out adında bir klasör açacak ve çıktıları içine yükleyecektir. Kendi konfigrasyonunuzu json tipinde bir dosyaya yazarak bunu -c <json-dosyasının-yolu>ekleyeyerek kullanabilirsiniz.

Detaylar için bkz.:

• Configuring JSDoc with a configuration file
• Command-line arguments to JSDoc

Hangi Etiketler Var?

Aynı HTML’de olduğu gibi burada da block ve inline olmak üzere iki farklı etiket türü bulunuyor. Block etiketler tüm satırı kaplarken, inline etiketler ise satırın içindeki bir veya daha fazla kelimeyi kaplar. Inline etiketler normal yazıdan ayrılabilmek içi { } arasına yazılır.

Sıklıkla kullanılan bazı etiketler şöyledir:

Inline etiketler:

• link: Dokümandaki bir yere yahut harici bir bağlantıyı linkler.

Block etiketler:

• construct : Sınıfa ait kurucu fonksiyonları tanımlarken kullanılır.
• class : Sınıf tanımlarken kullanılır.
• default : Varsayılan değeri belirtir.
• description : Açıklama eklemenizi sağlar.
• summary : description ‘a benzer olsa da daha detaylı olarak anlatım yapılır.
• example : Örnek kullanım gösterirken kullanılır.
• function : Fonksiyon veya methodları tanımlamak için kullanılır.
• param : Fonksiyonun parametrelerini tanımlar. arg veya argument olarak da kullanılır.
• readonly : O alanda sadece okuma işlemi yapılabileceğini anlatır.
• return : Fonksiyonların dönüş değerini belirtir. returns olarak da kullanılır.
• property : Bir nesnenin property’sini tanımlar. prop olarak da kullanılır.
• see : Buna da bakılsa iyi olur dediğiniz linkleri gösterir.
• author : O elemanı yazan kişiyi belirtir.
• type : Tip kontrolü için kullanılır.
• name : Bir nesneye isim vermemizi sağlar.
• callback : Callback fonksiyonlarını tanımlarken kullanılır.
• copyright : Telif hakkı belirtir.
• ignore : Yazıldığı kısmın görmezden JSDoc tarafında görmezden gelinmesini sağlar.
• module : JavaScript modul’ü oluştururken kullanılır.
• namespace : Bir namespace’i tanımlar.
• override : Bir kalıtım alınan ebeveyn özelliğini ezdiğimizi vurgular.
• since : Bu özelliğin eklendiği tarihi gösterir.
• this : this anahtar kelimesinin neyi işaret ettiğinni belirtir.
• throw : Fırlatılacak hatayı gösterir.
• version : Ekleme yapıldığı versiyonu belirtir

Kullanabileceğiniz tüm etiketlere buradan ulaşabilirsiniz: https://jsdoc.app/index.html

Örnek Kullanımı

Sunucu adındaki modül içindeki portDinle adında, url ve port olarak iki parametre alan, bu bilgileri kullanarak gelen istekleri dinleyen fonksiyonumuz için örnek kullanım şöyle olabilir:

VSCode kullanırken fonksiyonun üstüne geldiğimizde çıkan bilgi kutusu:

Oluşan doküman:

Kaynakça:

• Index
• Documentation - JSDoc Reference

Çalıştırdığımız kodun nasıl yazıldığı kadar nasıl çalıştığı da hem geliştiriciler hem de kullanıcılar için büyük bir önem taşır. Yazımı kötü olan bir kodun okunması, çalışması ve üzerinde geliştirilme yapılması oldukça zahmetlidir. Kodumuzu clean code prensipleriyle yazsak bile sistemin çalışma sırasındaki işleyişine hakim değilsek bu bize kötü yazılmış kod kadar maaliyet yaratabilir.

Dosya işlemleri, veritabanlarıyla konuşmak veya ağ üzerinden harici yapılara bağlanmak saniyeler alabilir ve hatta fark bile edemeyeceğimiz hızlarda yapılan temel aritmetik işlemler uç uca eklendikçe artık can sıkıcı bir seviyeye gelebilir. Bilgisayarımızın kodları nasıl işlettiğine, zaman gibi bir maliyeti nasıl kısaltabileceğimize ve “Biliyor musun kodu bir refactor ettim, 2 saniyede çalışan kod 300 milisaniyede takır takır çalıştı.” gibi lafları nasıl kurabileceğimize gelin birlikte bakalım.

Programlama Dillerinin İşlemleri Çalıştırma Mantığı Nasıldır?

Propramlama dilleri, derleyiciler veya Node.js gibi çalıştırma ortamları kodumuzda bulunan satırları verdiğimiz parametrelere göre yahut dilin kendi yapısına göre ne zaman bir sonraki satıra geçeceğine farklı farklı karar verebilirler.

Bu işleyişi temel olarak şu şekilde iki bölüme ayırabiliriz:

Synchronous / Blocking

Arka arkaya birden fazla fonksiyon çağırdığımızda bu işleyiş stilinde her fonksiyon çalıştırılır ardından fonksiyondan cevap gelene kadar kodun bir sonraki adıma geçmesi engellenir.

Synchronous(senkron) ve Blocking(bloklamalı) yapılarının mantıkları aynı olsa da kullanıldığı yerler farklıdır.

Network gibi işlerde synchronous kelimesi kullanılırken dosya okuma örneğini verebileceğimiz IO gibi işlemlerinde ise blocking kelimesi kullanılır.

Asynchronous / Non-Blocking / Event Based

Bu yapıda ise fonksiyonlarımız çağrılır ve cevap gelmesi beklenmeden bir sonraki adıma geçilir. Genellikle birbiriyle mantıksal ilişkisi olmayan görevleri yaparken birinin başlaması için öbürünün bitmesinin gerekmediği durumlarda kullanılır.

Event based(olay bazlı) yapıda ise daha önceden belirlenmiş olaylar tetiklenmeden çalıştırma yapılmaz. Burada olayların hangi sırayla tanımlandığı değil hangi sırayla tetiklendiği önemlidir. HTML ve JavaScript’teki event’ler bunun en güzel örneğidir. Bu terim de yeni başlayanlar için soru işaretli olduğu için buna da değinmeyi uygun gördüm.

async/await Kullanımı

C# 5.0, C++20, Python 3.5, F#, Hack, Julia, Dart, Kotlin 1.1, Rust 1.39, Nim 0.9.4, JavaScript ES2017, Swift 5.5, Zig ve bazı eklentilerle birlikte deneysel olarak Scala asenkron porgramlama için uygun koşulları sağlar. Dilden dile bu anahtar kelimelerin yazımı farklılık gösterebilir.

Bir fonksiyonu asenkron işletebilmek için async ile bunu bildirmeliyiz. Tip güvenli dillerde fonksiyonumuzun dönüş tipini Task veya Promise olarak belirterek dönüşün uzun sürebileceğini belirtip içine generic olarak asıl dönüş tipini yazmalıyız.

async Task<int> getUserId(string username){
    int id;
    // Mantıksal işlemler
    return id;
}

“Senkron programlama tamam ama asenkron proramlama yaparken cevap gelmeden nasıl işime devam edeceğim ki?” sorusunu kendinize sorduysanız gelin bir de await anahtar kelimesine bakalım.

await ile asenkron işleyişi kırıp cevap gelene kadar işlemi beklenmesi gerektiğini belirtiyoruz.

async Task<int> getUserId(string username){
    User user = await findUserFromDatabase(username);
    return user.id;
}

Örnek Senaryo

Büyük bir Excell dosyasınında bulunan malzeme bilgilerini okuyacak, her satır için PDF olarak fatura oluşturacak ardından bunları bir kullanıcıya mail atacak ve excell’deki bilgileri veritabanına kaydedecek bir sistemimiz olduğunu düşünelim.

Bunu yapacak senkron kod basitçe şöyle olurdu:

Fonsiyonların sırasıyla 1, 2, 2 ve 1 birim zamanda çalıştığını varsayarsak şöyle bir zaman grafik elde ederiz.

Koddaki excellOku ve pdfOlusturVeGetir dışındaki fonksiyonlar birbirinden bağımsızdır. Bundan dolayı onları ayrık olarak çalıştırmayı deneyebiliriz.

faturaBilgilendirmeMailiGonder ve veritabaninaKaydet fonksiyonları çalıştırılmaya başlanacak ve hemen bir sonraki adıma geçilecek. Buna göre zaman çizelgesi şöyle olurdu:

Çizelgeden de anlaşılabildiği üzere son iki işi neredeyse aynı anda başlatarak zamandan tasarruf etmemiz mümkün oldu.

Sonuç

Düzgün kurgulanmış bir asenkron kodla çalışmak bize gözle görülebilir bir zaman kazancı sağlayacaktır. Unutulmamalıdır ki birden fazla yapıyla(fonksiyon, koşul, döngü) ilişki içinde olan verilerimizi korumak için özellikle de ona atama yapılacağı zaman await veya mutex gibi yapılarla o anda sadece bir işlemin onunla ilgilenmesini sağlamalıyız çünkü cpu’daki iş yükü, ağ yoğunluğu gibi belirleyemeyeceğimiz nedenlerden dolayı işlemlerimiz beklediğimizden farklı sürede çalışabilir ve bu da kodda yazdığımız sırayla atama yapılmasına engel olur.

Kaynakça:

• What's the difference between: Asynchronous, Non-Blocking, Event-Base architectures?
• Async/await - Wikipedia
• Asynchrony (computer programming) - Wikipedia

Bir nesneye her atama(set) veya okuma(get) yapıldığında belirli işlemleri nasıl yapacağımızı hiç düşündünüz mü? OOP kullanılabilen bir dille daha önce uğraştıysanız bu soruya haklı olarak “Tabii ki getter ve setter kullanarak.” cevabını vermiş olabilirsinizdir, JavaScript de bu özelliğe sahiptir ancak asıl nesnemize getter/setter eklemek istemediğimizde veya daha fazla işlemi takip etmek istediğimizde ne kullanacağız peki? İşte burada da Proxy nesneleri yardımımıza koşuyor.

Proxy Nedir?

ECMAScript 6 ile hayatımıza giren Proxy nesnesi, bir objeyi baz alarak get, set, yeni property tanımlama gibi temel obje operasyonlarını takip edebileceğimiz yeni bir obje oluşturur. Bu sayede obje üzerindeki işlemlere göre aksiyona geçebilir, veri doğrulayabilir, serileştirebilir, log’layabilir yahut benzeri işlemleri yapabiliriz.

Proxy üzerinden hedef nesnenin özellikleri değiştirildikçe hem proxy’deki veriler hem de hedef nesnenin içindekilerin değişeceği kullanılırken göz önünde bulundurulmalıdır.

Nasıl tanımlanır?

Proxy constructure’ının iki ana parametresi vardır. Bunlardan birincisi kopyasını çıkaracağımız hedef nesne ikincisi ise işlemler tetiklendiğinde çalışacak mantıksal yapımızın olduğu bir handler’dır. Her handler’ın kendine ait parametreleri vardır.

// target yerine orijinal nesnemizi,
// handler yerine takip fonksiyonlarımızın bulunduğu nesneyi yazarız.
// new Proxy(target, handler);

let user = {
  name: 'Alihan',
  surname: 'SARAC',
  age: 21,
};

const handler = {
  //  ilgili method'lar
};

let userProxy = new Proxy(user, handler);

Hangi obje işlemlerini takip edebiliriz?

Objelerin temel işlemlerinin birçoğunu takip edebiliriz. Bunların bir kısmı proxy üzerinden tetiklenebilirken bir kısmını da Object sınıfının method’ları ile tetikleyebiliriz.

• get : proxy’den okuma yapıldığında tetiklenir
• set :proxy’e atama yapılırken tetiklenir
• has :in operatörü kullanıldığında tetiklenir.
• apply : fonksiyondan üretilen proxy’lerde fonksiyon çağrıldığında tetiklenir.
• ownKeys : Object.getOwnPropertyNames ve Object.getOwnPropertySymbols ile proxy kullanıldığında tetiklenir
• construct : new operatörü kullanıldığında tetiklenir
• isExtensible : Object.isExtensible ile proxy kullanıldığında tetiklenir.
• deleteProperty : delete operatörü proxy üzerinde kullanılınca tetiklenir.
• defineProperty : Object.defineProperty ile proxy kullanıldığında tetiklenir.
• setPrototypeOf : Object.setPrototypeOf ile proxy kullanıldığında tetiklenir.
• getOwnPropertyDescriptor : Object.getOwnPropertyDescriptor ile proxy çağrıldığında tetiklenir.
• preventExtensions : Object.preventExtensions ile proxy kullanıldığında tetiklenir.

Nasıl kullanılır?

Proxy handler method’larının içine tanımlandığı nesnenin güncel halini parametre olarak gönderir. Key(property)’lere özel handler tanımlanamadığı için eğer key’lerle ilgili bir işlem yapılıyorsa key’in ismini de parametre geçer ve ardından ilgili işleme özel parametreleri de gönderir.

En temel 3 şey olan atama, getirme ve silme işlemlerine gelin birlikte bakalım.

Get:

// target: hedef nesnemizin kendisi
// property: okuma işlemi yapılan key
// reciever: proxy'nin kendisi yada ondan kalıtım alan bir nesne.
//
// temel işlemlerde "reciever" kullanmamıza gerek yoktur
// sadece ilk iki parametre alınabilir

get( target, property, reciever){
  // mantıksal işlemler
  return "geri dönülecek değer";
}

Get fonksiyonunun içinden target[property] diyerek şu an okuma yapılan değeri alabilir, ilgili işlemleri yaptıktan sonra istediğimiz değeri return diyerek kullanıcıya dönebiliriz.

Set:

// target: hedef nesnemizin kendisi
// property: okuma işlemi yapılan key
// value: property'e atanmak istenen değerdir
// reciever: proxy'nin kendisi yada ondan kalıtım alan bir nesne.
//
// temel işlemlerde "reciever" kullanmamıza gerek yoktur
// sadece ilk iki parametre alınabilir

get( target, property, value, reciever){
  // mantıksal işlemler
  return true;
}

Set fonksiyonu mutlaka geriye atama yapıldığına dair bool bir değer dönmelidir. Fonksiyonunun içinden target[property] diyerek atama yapmalısınız.

Delete:

// target: hedef nesnemizin kendisi
// property: okuma işlemi yapılan key

deleteProperty( target, property){
  // mantıksal işlemler
  delete target[property];
  return true;
}

deleteProperty , delete operatörü kullanıldığında tetiklenir ve silinme yapıldığının anlaşılması için bool bir değer döndürmelidir.

Geri alınabilir Proxy’ler

Eğer Proxy oluştururken Proxy.revocable fonksiyonunu kullanırsak proxy özelliği kapatılabilir bir proxy oluşturmuş oluruz. Oluşturulma şekli ve kullanımı normal proxy ile temel olarak aynıdır, tek fark mu fonksiyonun geriye proxy değil onu verecek ve iptal edecek olan nesneyi vermesidir.

let revocable =  Proxy.revocable(target, handler);
let userProxy = revocable.proxy;

revocable oluşturulduktan sonra revocable.revoke method’u ile proxy nesnesinin proxy’si kapatılır.

Unutulmamalıdır ki proxy kapatıldıktan sonra yukarıdaki “Hangi obje işlemlerini takip edebiliriz?” alanında bahsedilen tüm operasyonlar TypeError fırlatacaktır.

Örnek Kullanım Senaryoları:

Value Validation:

Proxy’lerin en popüler kullanım alanlarından biri de veri doğrulamasıdır. Atama işlemlerinde minimum-maksimum değer, email ve yazım tipi doğrulaması gibi birçok işlemde kullanılabilir.

Senaryomuzda bir kullanıcı olduğunu varsayalım. Yaş değerinin 0'dan büyük olması gerektiğini, silme işleminde sadece kullanıcının silme tarihi geçtiyse silinebileceğini ve sadece test kullanıcılarının şifresinin okunabileceğini varsayalım.

Orijinal nesnemizi tanımlayalım.

let user = {
  name: 'alihan',
  age: 21,
  password: '123456as.',
  isTestUser: true,
  expireAt: new Date(100000000000),
}

Proxy’nin handler’ını tanımlayalım.

const userProxyHandler = {
  get(target, key){
    let value = target[key];
    if(key === 'password' && !isTestUser){
      value = '***';
// gelen okuma password için yapılıyorsa ve kullancı test kullanıcısı değilse şifre '***' şeklinde gösterilir.
    }
    return value;
  }

  set(target, key, value){
    if(key === 'age' && value < 0){
      throw new Error('yaş değeri 0'a eşit veya büyük olmalıdır');
    }
    target[key] = value;
    return true;
  }

  deleteProperty(target, key){
    if(Date.now() > target[expireAt]){
      throw new Error('Kullanıcı bu tarihte silinemez');
    }
    delete target[key];
  }
}

Değişen key’leri ve eski değerlerini nesne içinde tutma:

Veritabanlarıyla uğraşıyorsanız, hele de benim gibi bir ORM yazmayı deniyorsanız her bir işlemin maliyeti sizin için oldukça önemlidir. İçinde sadece bir alanı değişmiş büyük bir nesneyi sisteme tekrardan kaydetmek gibi bir masraf kesinlikle istemeyeceğimiz bir şeydir bu durumu çözmek için hangi alanlarda değişiklik yapıldığını tutabilir ve sadece o alanı kaydedebiliriz. Proxy‘ler tam da bu iş için yaratılmış. Hadi nasıl yapacağımıza bakalım.

İlk önce handler’a bir set olayı yazmalıyız. Burada objemizin içinde _degisenDegerler adında, obje tipinde bir key tutacağız ve değişiklikleri buradan takip edebileceğiz. Her set işlemi çalıştığında ilgili key ilk önce target içindeki _degisenDegerler ‘e eklenmeli ve şu anki verisi buraya yazılmalı ardından ise target ‘ın içindeki key alanı gelen value ‘yu tutacak şekilde güncellenmeli böylece eski veri _degisenDegerler içine yazılmış ve yerine yenisi atanmış olur. Veritabanına kayıt yapıldıktan sonra da _degisenDegerler içindeki tüm key’ler kaldırılabilir.

let model = {
  isim: 'Alihan',
  _degisenDegerler: {},
};

let modelProxy = new Proxy(model, {
  set(target, key, deger){
    target._degisenDegerler[key] = target[key];
    target[key] = deger;
    return true;
  }
});

modelProxy.isim = 'ayşe';
modelProxy.yas=21;

console.log({ modelProxy });

//{
//  "modelProxy": {
//    "isim": "ayşe",
//    "yas": 21,
//    "_degisenDegerler": {
//      isim: "Alihan"
//      yas: undefined
//    },
//  }
//}

Kaynakça:

Proxy - JavaScript | MDN

Sunucularımız genellikle herkesin istek atmasına müsait olsa da her kullanıcının istediği bilgiye ulaşması sistemimizi ve diğer kullanıcıları tehlikeye sokabilir bu yüzden isteği atan kullanıcıyı doğrulamamız( authentication ) ve yetkilendirmemiz( authorization ) gerekmektedir. Temel olarak şu kimlik doğrulama yöntemleri kullanılabilir:

1 - Password Doğrulaması:

Kullanıcı kayıt olurken kullanıcı ismi, müşteri numarası, email adresi gibi benzersiz bir alan sahip olması istenir bu sayede kullanıcı sistemde doğrudan işaret edilebilir ve kullanıcıdan sadece kendisinin bileceği bir şifre tanımlaması istenir böylece kullanıcı adı bilinse bile şifresini sadece kendisi bileceği için sistem görece güvenli olur.

Veritabanında biraz önce bahsettiğimiz ID alanı herhangi bir gizleme yapılmadan tutulmasında son kullanıcı için bir sakınca yoktur çünkü bu değer şifreye sahip olmayan biri için önemsizdir fakat şifre açık bir şekilde(plain text) tutulduğunda veritabanına yapılacak saldırıda tüm kullanıcıların verisine artık tek hamlede erişilebilmesine yol açar. Bunun önüne geçmek için aşağıdaki gibi birkaç farklı şekilde koruma sağlayabiliriz.

Karıştırma:

Karıştırma yapılırken kelime katarındaki karakterler belli bir örüntüye göre yer değiştirilir yahut ötelenirler, çözümleme yapılırken de aynı algoritma tam tersi işletilerek katarın ilk haline ulaşılır.

Hash’leme:

Hash’leme, bir algoritma(hash function) ile bir karakter katarını(key) bir daha geri dönüştürülemeyecek şekilde yeni bir karakter katarına dönüştürme işlemidir. Şahsi algoritmanızı tasarlayarak yahut SHA, CRC, Fletcher, MD-2 gibi hazır algoritmalar kullanarak bu işlemi yapabiliriz. Zaruret olan bir durum olmadığı müddetçe farklı zümreler tarafından çok farklı koşullarda test edildiğinden dolayı bahsedilen hazır algoritmaların kullanılması tavsiye edilir.

Hash fonksiyonuna verilen ve içeriği aynı olan girdilerin çıktıları da aynıdır bu sayede sunucuya gönderilen şifre hash’lenerek veritabanında tutulan kullanıcı hash’i ile karşılaştırılabilir.

Hash-Salt:

Salt’lama bir karakter katarının bir yerine başka bir kelimeyi ekleme işlemine denir. En basit örneği kelimenin sonuna başka bir kelimeyi eklemektir.

Şifrelerde Hash’leme işlemi yapılsa bile elimizdeki tüm kombinasyonlar denenerek(brute force) hash’in gerçek karşılığı bir müddet sonra bulunabilir. Bu süreyi arttırmak için şifrelere salt’lama yapılır ve ardından hash’lenir, salt key’i sunucu ortamında tutulduğu için ayrık sistemlerde veritabanı ele geçirilse bile salt değeri bilinmez.

Şifre salt’landıktan sonra hash’lendiği için aynı hash’e sahip kayıtlardan sadece bir tanesinin bulunması hepsini ifşalayacaktır bundan dolayı salt’lar birbirinden farklı olacak şekilde oluşturulmalıdır. Hash’in ve Salt’ın aynı kayıt içinde tutulması başta güvenli değil gibi görünse de aslında rastgele olmayan salt kullanıldığında brute force ile salt bulunduktan sonra tüm şifrelerin çözülmesi oldukça hızlanacaktır ama salt’lar farklıysa her kayıt için tek tek salt-hash denemesinin yapılması oldukça maliyetli olacaktır.

2 - Token Doğrulaması:

Token’larla yapılan doğrulamayı basitçe iki arkadaş arasında bulunan gizli bir şifre olarak düşünebiliriz. Bu şifre uzaktan bakıldığında bir anlam ifade etmeyen, benzersiz olan bir karakter katarıdır. Sunucu bu token üretirken benzersiz olduğunu garanti eder ya da aynısından iki tane üretme olasılığı o kadar düşüktür ki bunu ihmal edebilir. Kullanıcı sunucuya istek üzerinden bu token’ı yollayarak kendini tanıtır. HTTP/HTTPS isteklerinde cookie, header, body yahut url içinde olabilir.

Token doğrulamasına çok benzer olarak ticket doğrulaması da vardır. Bunun için verebileceğimiz en popüler örnek Kerberos protokolüdür.

Kerberos network üzerinde kullanıcı doğrulaması yapılmasını sağlayan bir protokoldür. Kullanıcı gateway’le konuşur gibi ilk önce bir authentication sunucusuyla konuşur ve sunucudan bir ticket alır ardından bu ticket’ı konuşmak istediği sunucuya iletir ve aralarında veri akışı başlar.

3 - OAuth

Bazı durumlarda siz ne kadar güvenli bir sistem oluştursanız bile kullanıcı kişisel bilgilerini sisteminize girmek istemeyebilir. Böyle durumlarda kullanıcının güvenebileceği Google, Facebook, Apple gibi sistemlerden giriş yapmasını sağlayıp istediğimiz bilgilere onlar üzerinden ulaşabiliriz.

Sistemi basitçe şöyle anlatabiliriz:

Kullanıcı güvendiği sistemde kendini tanıtır ve o sistem bizim daha önce belirlediğimiz verilere ulaşabilmemizi sağlayacak bir token’ı bize iletir ve bu token ile kullanıcıyı doğrulayabilir ve verilerine ulaşabiliriz.

4 - Sertifika Bazlı doğrulama:

Sertifika bazlı doğrulamada kullanıcı sunucuya kullanıcı bilgisi ve şifre yahut token göndermek yerine tarafsız otoritelerce onaylanmış sertifika dosyasını göndererek bu sertifika trusted store denilen sertifika doğrulayıcısı tarafından doğrulanır ve kullanıcı kaynaklara erişebilir hale gelir.

Doğrulama yapmak için en çok kullanılan biri de HTTPS protokolünün zorunlu kıldığı SSL/TLS sertifikasıdır.

SSL/TLS’in Çalışma Şekli:

1. Kullanıcı “hello” mesajı yollayarak sunucuya güvenli session oluşturmak istediğini söyler
2. Server, server sertifikasını, CA bilgisini, ve public key’ini kullanıcıya gönderir
3. Kullanıcı sunucu sertifikasını trusted store içinde doğrulatır ve onay gelirse devam eder
4. Kullanıcı sunucuya sunucunun public key’ini kullanarak tek seferlik session key gönderir
5. Sunucu gelen key’i kendi private key’i ile şifreler ve kullanıcı ile sunucu arasında şifrelenmiş iletişim başlar

Bu SSL’in işleyişidir ve sadece kullanıcı sunucunun güvenli olduğunu doğrular, kullanıcıyı da doğrulamak için mutual SSL denilen, 3. adımdan sonra 2. ve 3.adımlar sunucu tarafında kullanıcı sertifikası için de yapan, başarılı olursa 4.adımdan devam eden yöntem kullanılmalıdır.

SSL’le Sunucu Tarafında Kullanıcı Doğrulaması

Sunucunun isteği kimin tarafından atıldığını bilebilmesi için kullanıcının da bir sertifikası olması gerekmektedir.

Sertifikanın önemli bazı alanları:

version: Protokolün versiyon numarasıdır.

certificate serial number: sertifikaya ait seri numarası.

Period of validity: sertifikanın geçerlilik süresi.

subject name: sertifika sahibinin bilgileri. İçinde sahibinin ülkesi, bölgesi, şehri, organizasyon ismi ve genel adı tutulabilir.

Signature: sertifikanın imzası.

SSL’le gelecek kullanıcılar, sertifikasında bulunan subject name , Signature veya Thumbprint gibi benzersiz olan alanlarına göre ayırt edilebilir, eğer kullanıcıya ait bir SSL sertifikası yoksa mutual SSL yönteminde sunucunun kendisi tarafından imzalanan(self-signed) bir sertifika oluşturulup kendisine gönderilebilir. Unutulmamalıdır ki self-signed yöntemi sadece localhost içinde çalışmaktadır.

Node.js için sertifika doğrulama örneği: https://github.com/julie-ng/nodejs-certificate-auth

C# için sertifika doğrulama örneği: https://github.com/niteshsinghal85/blogs/tree/main/CertificateAuthExample

Tavsiyelerim

Kullanıcıya ait bir ip adresinden birden fazla kullanıcı bilgisiyle doğrulamada kullanılabilecek hem kullanıcı hem de sunucu için en maliyetsiz olan yöntem, kullanıcıyı ilk önce hash-salt yöntemi ile doğruladıktan sonra ona kullanabileceği token vererek kullanıcıyı token ile doğrulamaktır çünkü kullanıcı sadece tek sefere mahsus giriş yapar ve ardından sistem tarafından otomatik olarak giriş yaptırtılabilir ama unutulmamalıdır ki bu girişler otomatik olarak yapılabileceği için kullanıcı bilgisi olmadan da giriş yapılmasına sebep olmaktadır, sunucu tarafında iste her girişte girilen şifreyle karşılaştırma yapmak için şifre hash’lenme gerekliliğini ortadan kaldıracaktır.

Eğer bir domain üzerinde sadece bir kullanıcı bulunacaksa sadece sertifika ile doğrulama yapılabilir çünkü sertifika geldiği ve gideceği adresi her zaman taahhüt eder.

Kaynakça:

• SSL vs. TLS - What are differences?
• Certificate authority - Wikipedia

Eğer C# ile herhangi bir Back-End içeren uygulama yazdıysanız illa ki köşeli parantezlerin içine yazılan, sanki kod yazarken koda başlık düşmüşüz gibi görülen kelimelerle karşılaşmışsınızdır. Peki bunların ne olduğunu, kullanımını ve arka planda nasıl çalıştıklarını hiç merak ettiniz mi? Hadi gelin bunları derinlemesine inceleyelim ve örnekleriyle anlayalım.

Attribute Nedir?

Öznitelik veya filtre olarak Türkçeye çevirebileceğimiz Attribute’lar, ilk bakışta geliştiricilere kod hakkında bilgi verici zımbırtılar olarak görünse de aslında kodun çalışma zamanında(run time) assembly, type, class, method, property ve benzeri şeylerle etkileşime girmek ve ilişkilendirmek için kullanılan bir özelliktir.

Attribute’lar, assembly’lere programımız hakkında bilgileri içeren Metadata’ları iletmemize olanak sağlar. Derleyiciler, kullandığımız paketler veya kodumuzun ta kendisi bu bilgileri okuyarak klasik işleyişi yerine farklı yöntemlerle işini gerçekleştirebilir böylece daha kolay ve esnek şekilde kod yazabiliriz.

Şu ana kadar temel olarak Attribute’ları konuştuk. Şimdi de hadi biraz teknik açıdan bakalım.

Nasıl kullanılır:

Attribute’ların en popüler kullanım yerlerini class’lar, method’lar ve property’lerdir. Bu alanların öncesine yahut bir üst satırına köşeli parantezler içine attribute ismi yazılır.

[AttributeA] public class User{
    [AttributeB]
    public string name { get; set; }
    public bool setPassword([In][Out] ref double x) { }
}

Bu kullanım Attribute’ü ilgili yerde aktif hale getirir.

Eğer Attribute’unuza derleyicinin just-in-time anında bilmesini istediğiniz bir metadata aktarmak istiyorsanız bunu parametrelerini kullanarak yapabilirsiniz. Normal bir constructor kullanır gibi sırayla parametre girebilir veya parametrenin ismini kullanarak atama yapabilirsiniz.

[Author("P. Ackerman", version = 1.1)]
class Users{
    // P. Ackerman için bazı mantıksal işlemler.
}

Aynı alan için yukarıdan aşağıya yahut soldan sağa birden fazla attribute yazabilirsiniz. Kullandığınız mantıksal yapıya göre bunların sırası önem gösterecektir.

Attribute’ları nasıl kullanadığımızı anladıysak şimdi de sistemin bize hangi attribute’ları verdiğine bakalım ve ardından kendi attribute’larımızı nasıl yazabileceğimizi konuşalım.

Build-in attribute’lar:

Obsolete: Kodunuzda artık kullanılmasını tavsiye etmediğiniz yerleri belirtmenize yarar. Derleyici bu alanlar kullanıldığında uyarı verir.

public class Users{
[ObsoleteAttribute("Bu fonksiyon guvenlik nedeniyle artik kullanilmamaktadır. Lutfen 'guncelSifreFonksiyonu' methodunu kullanin!")]
    public string tehlikeliSifreOluşturmaFonksiyonu() { }
    public string guncelSifreFonksiyonu(){}
}

tehlikeliSifreOluşturmaFonksiyonu çağrıldığında terminalde göreceğimiz çıktı şu şekildedir:

Conditional: Derleyicinin belirlediğimiz koşullar varsa o alanı çalıştırmasına olanak sağlar.

public class Users{
    [Conditional("DEBUG")] 
    public void tumBilgileriYazdir() { }
}

tumBilgileriYazdir fonksiyonu sadece “DEBUG” modundayken çalışır. Derleyici ayarlarınıza göre hata veya uyarı fırlatabilir ya da hiçbir şey göstermeyebilir. Sadece sistem durumlarını değil define anahtar kelimesi ile derleyiciye kendi tanımlayacağınız durumları da belirtebilirsiniz.

Bkz.: https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.conditionalattribute?view=net-6.0#examples

Serializable: Sınıflarınızın serileştirilebileceğini belirtir.

NonSerialized: Sınıflarınızın serileştirilemeyeceğini belirtir.

DLLImport: Yolunu vereceğiniz DLL’i kodunuza almanızı sağlar.

Bunlar En çok kullanıldığını düşündüğüm attribute’lardı fakat sistemde onlarca farklı attribute kurulu olarak gelmektedir.

Custom attribute oluşturmak:

Sıradan olmayan bir kod yazıyorsanız kendi işleyişinize uygun bir attribute bulmakta zorlandığınızda özel bir attribute’a ihtiyacınız olduğunu hissettiğinizde tek yapmanız gereken System.Attribute sınıfından kalıtım alarak kişisel bir attribute oluşturmak.

Senaryomuzda otomatik olarak fonksiyon çalıştığında log’lama yapılması gereksin ve içerisine bir mesaj ile birlikte log’lanma seviyesini alsın. Eğer iki bilgi de girilmediyse kullanıcıya uyarı versin. Bu işlemi yapacak kod aşağıdaki gibi olabilir:

using System;

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]

public class LoglayiciAttribute : Attribute {
    private string dosyaIsmi = "Log.txt";
    private string mesaj;
    public int logSeviyesi;

public LoglayiciAttribute(string mesaj){
        this.mesaj = mesaj;
        logSeviyesi = 1;
        dosyayaYaz();
    }

public LoglayiciAttribute(){
        // Kullanıcıya parametre vermediğimizde uyarı verecek kod
    }

private void dosyayaYaz(){
    // dosyaIsmi, mesaj ve logSeviyesi bilgilerini kullanarak dosyaya yazma islemleri
    }
}

AttributeUsage ile attribute’umuzun nerelerde ve nasıl çalışabileceğini belirliyoruz. Bu örneğimizde sadece method’larda çalışmasını istediğimiz AttributeTargets.Method değerini seçtik. Birden fazla yerde kullanılmasını istiyorsanız alanlar arasında | işareti koyarak yazabilirsiniz veya AttributeTargets.All diyebilirsiniz.

Kullanımı ise şu şekildedir:

[LoglayiciAttribute("Kod kullaniciSil fonksiyonuna girdi", logSeviyesi = 2)]
public bool kullaniciSil(int id){ }

Kullandığınız C# ortamının versiyonuna göre değişmekle birlikte attribute sınıfının ismini Attribute ile bitirseniz bile kullanırken sadece Loglayici diyerek de kullanabilirsiniz.

Attribute’ları middleware gibi kullanabilir miyiz? Method’lara giden parametrelere erişebilir miyiz?

Attribute’lar metadata üretmek için kullanılan yapılardır. Normalde Web API yazarken kullanabileceğiniz attribute’larla bir method’un parametrelerine veya controller’dan gönderilen bilgilere erişebilmek pek mümkün değildir fakat ASP.NET MVC yapısının bize sunduğu ActionFilter yapısı ile dolaylı yoldan bunu başarabiliriz. Action Filter bize aşağıdaki gibi 4 ana interface sunar.

• IAuthorizationFilter
• IActionFilter
• IResultFilter
• IExceptionFilter

Bu interface’lerden implemente edilmiş Attribute sınıflarından kalıtım alarak kısıtlı da olsa interface’ler üzerinden gelen bilgilerle bazı işlemlerimizi yapabilir, constructor’ı içinde middleware gibi davranmasını sağlayabilir, authorization(yetkilendirme) ve benzeri şeyleri yapabiliriz.

Fonksiyon parametrelerine erişme konusuna gelirsek bu pek mümkün değil ancak Web API yazıyorsak Controller’da bulunan HttpContext’e Action Filter üzerinden erişebilir ancak attribute’a parametre olarak klonlanan verinin tipi ref veya out olmadığı için controller’a gönderilen HttpContext değiştirilemez.

Unutulmamalıdır ki bu yöntem sadece Action Filter’ların kullanılabildiği yerlerde gerçeklenebilir.

Bir tipe bağlı attribute’ları bulmak:

Buraya kadar bir Attribute’u nasıl kullanacağımızı, nasıl kendimiz oluşturabileceğimizi konuştuk peki kimin hangi attribute’a sahip olduğunu nasıl öğreniriz ve buna karşılık neler yapabiliriz isterseniz de biraz bunları konuşalım.

Yazının en başında bahsettiğimiz her alanın içine hangi attribute’lara sahip olduğu sistem tarafından içine gömülür. Doğrudan bir tipin sahip olduğu attribute’ları sorgulayarak kod üzerinde örneğin sınıfları gruplayabilir veya bir nesnenin methodlarına mantıksal işlemler yapabiliriz.

Alanların custom attribute’larını getirmek için MemberInfo.getCustomAttributesData veya MemberInfo.GetCustomAttributes fonksiyonunu kullanmamız yeterlidir. İlk önce System.Reflection türünde olan alanın tipine erişmemiz lazım.

Tipin içinde bulunan GetCustomAttributes fonksiyonuna istediğiniz attribute tipini parametre veya generic olarak vererek arama yapabiliriz.

Attribute’a ulaştıktan sonra constructure ile içine verdiğimiz parametreler gibi normal bir sınıftan erişebileceğiniz her bilgiye erişebiliriz.

Sınıfın custom attribute’larına erişim:

Users adında bir sınıfımız olduğunu varsayalım, tipine iki farklı yöntemde erişip ardından attribute’ları sorgulayabiliriz.

// 1) typeof operatörüyle
System.Reflection.Type sinifTipi = typeof(Users);

// 2) nesnesinin getType methoduyla
Users u = new Users();
sinifTipi = u.getType();

sinifTipi.GetCustomAttributes( aranacak_Attribute_Tipi );
// sinifTipi.GetCustomAttributes< aranacak_Attribute_Tipi >()

Method custom attribute’larına erişim:

Sınıf tipine eriştikten sonra methodlarına oradan da method’un sahip olduğu attribute’lara erişebiliriz.

// Sınıfa ait tüm methodları getirir
System.Reflection.MethodInfo[] methodlar = sinifTipi.GetMethods();

// İstediğimiz methodu seçeriz ve "method" adındaki değişkene atarsak
method.GetCustomAttributes( //... ) 

Parametrelerin custom attribute’larına erişim:

Bir methoda eriştikten sonra parametrelerine erişebilir ve yukarıda yaptığımız işleri aynı şekilde yapabiliriz.

System.Reflection.ParameterInfo[] parametreler = method.GetParameters();

// ardından istediğimiz parametreyi seçeriz ve
// GetCustomAttributes ile ilgili işlemleri yaparız

Gerçek Dünya Problemleri ve Kullanımı

Attribute’lar hakkında yeterince bilgi sahibi olduk artık gerçek dünyada hem middleware olarak hem de metadata bilgilerini kullanarak nasıl çözümler bulabiliriz onlara bakalım.

1 ) Middleware gibi kullanıp yetkilendirme yapmak:

Yaptığım bir işte kullanıcı bazı end-pointlere sadece kendine ait SSL sertifikası da gönderildiyse kaynağa ulaşılabilmesini istedi. Burada işi middleware kullanarak ve url filtrelemesi yaparak çözebilirdim fakat bu bana Startup.cs ‘te karışık bir kod olmasına mâl olacaktı bu yüzden acaba attribute haline getirip istediğim yerlerde kullanabilir miyim dedim ve şöyle bir kod ortaya çıktı:

Bilgisayarın local’inde bulunan kullanıcıya ait tüm sertifikaları okur, interface sayesinde gelen HttpContext üzerinden kullanıcıdan yolladığı sertifikayı alır ve sistemdekilerle karşılaştırır eğer karşılığı yoksa HttpContext.Result üzerinden hata fırlatır.

2 ) Metadata olarak kullanıp API’ın route haritasını çıkarmak:

Daha önce bahsettiğimiz gibi attribute’lar sayesinde kodun belirli kısımlarına anlam yükleyebiliyoruz. Bu yüklediğimiz anlama göre objelerin içine veri eklemek, silmek, onları filtrelemek, farklı durumlarda fonksiyonları dinamik olarak çalıştırmak gibi onlarca faklı iş yapabiliriz biz ise bu örneğimizde ASP.NET yapısından hakim olduğumuz Controller attribute’larını kullanarak arka planda nasıl oluyor da bir route haritası çıkarılıyor buna bakacağız.

Biz bu örneği konudan sapmamak için sadece bir class için yapacağız fakat kodunuza “controllers” namespace’i altındaki tüm sınıfları da getirip bir döngü ile tüm controller’ları bu işe dahil edebilirisiniz.

Buradaki requestMethod, urlve method değişkenine artık istediğimiz şeyleri yapabiliriz. İstersek konsola basabilir istersek de url ‘i dinleyerek requestMethod tipinde istek geldiğinde method ‘u çalıştırabiliriz.

Kaynakça:

• A Walkthrough of C# Attributes
• Attributes (C#)
• How to plug method parameters into custom attribute

https://stackoverflow.com/questions/2676603/how-do-attribute-classes-work