10 Eylül 2023 Pazar

.Net Core'da Swagger UI Kullanımı

 

.Net Core'da Swagger UI Kullanımı

Web API geliştirirken API de yazılan metodların ne iş yaptığı? Hangi parametreleri aldığı? Ne cevap döndüğü? Gibi bilgilerin yer aldığı dökümanlar hazırlanması gerekir. Çünkü o API ile, uygulamasını haberleştiren yazılımcı, nasıl bir veri alıp göndereceğini bilmesi gerekir. İşte bu noktada Swagger UI devreye girmektedir.

Swagger UI, OpenAPI (Swagger) spesifikasyonu ile tanımlanan bir API için, dökümantasyonları görsel olarak oluşturan açık kaynaklı bir projedir. Swagger UI, GitHub’tan indirip kullanılabilirsiniz.

Swagger UI API’lere arayüz görevi görmektedir. Yazılımcıların nasıl bir entegrasyon yapacağını görmelerini sağlar. Swagger UI arayüzünü oluştururken verileri “swagger.json” dan okur. Eğer API’nizi Node.js ile yazıyorsanız maalesef “swagger.json” dosyasını kendiniz hazırlamanız gerekiyor(en son öyleydi yeni bir araç çıkmadıysa). Aşağıdaki örnek gibi.

 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
{
    "swagger": "2.0",
    "info": {
        "version": "1.0.0",
        "title": "İsmail KAŞAN-NodeJS-Api-MongoDB",
        "description": "A minimal and easy to follow example of what you need to create a CRUD style API in NodeJs",
        "license": {
            "name": "MIT",
            "url": "https://opensource.org/licenses/MIT"
        }
    },
    "tags": [
        {
            "name": "Todos",
            "description": "API for todos in the Personel List"
        }
    ],
    "consumes": [
        "application/json"
    ],
    "produces": [
        "application/json"
    ],
    "paths": {
        "/todos": {
            "get": {
                "tags": [
                    "Todos"
                ],
                "summary": "Get all todos",
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/TodoList"
                        }
                    }
                }
            },
            "post": {
                "tags": [
                    "Todos"
                ],
                "summary": "Create a new todo",
                "produces": [
                    "application/json"
                ],
                "parameters": [
                    {
                        "name": "model",
                        "in": "body",
                        "description": "todo detail",
                        "required": true,
                        "schema": {
                            "$ref": "#/definitions/Todo"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/Todo"
                        }
                    },
                    "400": {
                        "description": "Failed. Bad post data."
                    }
                }
            }
        }   
    "definitions": {
        "TodoList": {
            "type": "object",
            "properties": {
                "_id": {
                    "type": "string"
                },
                "title": {
                    "type": "string"
                },
                "date": {
                    "type": "string"
                },
                "completed": {
                    "type": "string"
                }
            }
        },
        "Todo": {
            "type": "object",
            "properties": {
                "title": {
                    "type": "string"
                },
                "date": {
                    "type": "string"
                },
                "completed": {
                    "type": "string"
                }
            }
        }     
    }
}

 

.Net Core tarafında ise işler biraz daha kolaylaştırılmış. “Swashbuckle.AspNetCore” Nuget paketi ile gelen dll’ler sizin için işi kolaylaştırıyor. Metodlarınızın ve Class’larınızın üzerine yazdığınız Summary’leri alıp “swagger.json”dosyasını sizin için otomatik oluşturuyor.

 

Projemize Swagger UI eklemek için aşağıdaki komut ile Nuget üzerinden ilgili kütüphaneyi ekliyoruz.

1
dotnet add package Swashbuckle.AspNetCore

 

Paketi indirdikten sonra ilgili ayarlar için, Startup.cs dosyasında aşağıdaki eklemeleri yapmamız gerekiyor.

 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
            // Add in ConfigureServices Method            
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo { Title = "Net Core Example Api", Version = "v1" });
                c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
                {
                    Description = @"JWT Authorization header using the Bearer scheme. \r\n\r\n 
                      Enter 'Bearer' [space] and then your token in the text input below.
                      \r\n\r\nExample: 'Bearer 12345abcdef'",
                    Name = "Authorization",
                    In = ParameterLocation.Header,
                    Type = SecuritySchemeType.ApiKey,
                    Scheme = "Bearer"
                });
                c.AddSecurityRequirement(new OpenApiSecurityRequirement()
                {
                    {
                        new OpenApiSecurityScheme
                        {
                            Reference = new OpenApiReference
                            {
                                Type = ReferenceType.SecurityScheme,
                                Id = "Bearer"
                            },
                            Scheme = "oauth2",
                            Name = "Bearer",
                            In = ParameterLocation.Header,
                        },
                        new List<string>()
                    }
                });
            });
            // Add in Configure Method  
            app.UseSwagger();
            app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "ResponseCache v1"));

 

AddSecurityDefinition ve AddSecurityRequirement metodlarını sistemdeki yetkilendirme yapısında, arayüz üzerinden atılan isteklerde token bilgisinin eklenebilmesi için ayar yapıyoruz.

Sistemde yetkilendirme yok ise 5. satırdaki kod yeterli olacaktır. Configure Metodunda middleware’e Swagger UI eklemeyi unutmuyoruz.

 

1
2
app.UseSwagger();
app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "NetCoreExampleApi v1"));  

 

Kurulum ve ayarlama işlemi bu kadar basit. Artık projeyi çalıştırabiliriz. Projeyi çalıştırıdığımızda tarayıcıda böyle bir ekran karşılıyor bizi.

 

.Net core swagger kullanimi
Metodların türleri(Get,Post vs.) ile url yapıları renkli bir görsel ile çok güzel bir şekilde gösterilmiş. Class’ların şema yapısı da mevcut. Authorize butonuna tıklandığında token eklemek için bir pop-up açılacaktır.


.Net core swagger kullanimi
Swagger UI üzerinden yapılan isteklerin Authorization Header’ına token eklemek için açılan pop-up.


Bu arayüz üzerinden ilgili methodlar test edilebilir. Apinin fonksiyonlarına veri gönderebilir ve veri çekebilirsiniz. Postman gibi programlara gerek kalmadan yazdığınız API’yi hızlıca test edebilirsiniz.

 

Bazen gözden kaçan ufak tefek durumlarda, Swagger UI sistemdeki dinamik oluşan “swagger.json” dosyasını okuyamaz.Bu hata aşağıdaki gibidir.

 

.Net core swagger kullanimi

 

 

Bu hatanın sebep olduğu olayı şu şekilde açıklayabiliriz. Aynı Controller içinde bulunan farklı iki metodun aynı Http metodu ile işratelenmesidir. Aşağıdaki örnekte iki metod da [HttpGet] atribütü ile işaretlenmiş. Dolayısıyla swagger.json dosyasında yanı route sahip 2 farklı metod olduğu için hata vermektedir.

 

.Net core swagger kullanimi
[HttpGet] ile işaretlenmiş metodlar

Eğer Controller içinde 2 den fazla Http metod attribütü ile işaretlenmiş metod varsa,bunların url bilgilerini [Route(“”)] atribütü ile belirtmemiz gerekir. Yoksa Swagger UI url yapısına karar veremiyor. Aşağıdaki gibi olması gerekiyor.

 

.Net core swagger kullanimi
[HttpGet] ve [Route(“”)] atribütleri ile işaretlenmiş metodlar
 

 

Elimden geldiğinde anlatmaya çalıştım. Umarım faydalı bir içerik olmuştur.

Yararlanılan kaynaklar;

Örnek Proje kodları buradan indirilebilir.

https://swagger.io/tools/swagger-ui/



 

TypeScript Nedir?

TypeScript Nedir?

Merhaba bu yazıda kod detaylarına girmeden genel çerçevede TypeScript nedir? Değinmek istiyorum. Özellikle yazılım dünyasına yeni girenler için genel çerçeveli bir yazı olacak.

TypeScript Microsoft tarafından gelişirilen JavaScript'e statik tipler ekleyen açık kaynaklı bir dildir. Bilindiği gibi JavaScript'te tip ayrımı yoktu bütün değerler object olarak tutulurdu. Yani JavaScript dinamik tiplidir. Değişkenlere hangi tip değer atanırsa o değişkenin değeri o oluyordu. Fakat TypeScript'e değişkenlere tip verebiliyoruz.  TypeScript JavaScript'in bir üst kümesi olduğu için JavaScriptin sahip olduğu bütün söz dizimlerini içerir.

TypeScript ile hem frontend(Angular, React, vb.) hemde backend(Node.js, Deno) uygulamaları geliştirilebilir. Hatta çok tercih ediliyor desekte yeridir. Ama en nihayetinde TypeScript ile yazılan kodlar derlendiğinde core JavaScript'e çevrilir. Çıktı her zaman JavaScript'tir. Bu işlem için varsayılan TypeScript Compiler(TSC) kullanılabilir. Yada Babel derleyicisi kullanılabilir. Çünkü TypeScript ile yazılan en sonunda bir JavaScript motorunda çalışması gerekir ve JavaScript mtorları JavaScript kodunu çalıştırır. 

TypeScript derleyicisinin kendisi TypeScript'te yazılmıştır ve JavaScript'e derlenmiştir. Apache Lisansı 2.0 kapsamında lisanslanmıştır. C#'ın baş mimarı ve Delphi ile Turbo Pascal'ın yaratıcısı Anders Hejlsberg, TypeScript'in geliştirilmesi üzerinde çalışmıştır.

TypeScript büyük projelerin daha mimarisel anlamda geliştirilmesi için ortaya çıkmıştır. Object oriented yapısını destekleyen bir dildir. Diğer object oriented olan dillerin sahip olduğu neredeyse bütün özellikleri barındırmaktadır. Örneğin, Kalıtım(Inheritence), Çokbiçimlilik(Polymorphizm), Soyutlama(Abstraction) ve Sarmalama(Encapsulation).

TypeScript'in bazı temel özellikleri:

  1. Statik Tipleme: TypeScript, değişkenlerin ve nesnelerin veri türlerini tanımlamanıza izin verir. Bu sayede kodunuzun derlenmesi (compile) sırasında hataları tespit etmek daha kolay hale gelir. Tip hatalarını önler ve kodun daha güvenli ve sürdürülebilir olmasını sağlar.

  2. ES6 ve Sonrası Desteği: TypeScript, ECMAScript 6 (ES6) ve sonrası JavaScript özelliklerini destekler. Bu, modern JavaScript özelliklerini kullanmanıza olanak tanır ve kodunuzun güncel ve verimli olmasını sağlar.

  3. Modülerlik: TypeScript, modüler programlamayı destekler ve CommonJS, AMD, UMD gibi modül sistemleriyle uyumludur. Bu, kodunuzu daha düzenli ve yönetilebilir hale getirir.

  4. Tooling Desteği: TypeScript, geliştirme araçları ve entegrasyonlarla zengin bir ekosisteme sahiptir. Özellikle popüler geliştirme ortamları ve IDE'ler (Integrated Development Environment) tarafından desteklenir.

  5. Hızlı Gelişim: TypeScript, geliştiricilere otomatik tamamlama, hata denetimi ve kod dökümantasyonu gibi özellikler sunar. Bu, kodun daha hızlı yazılmasını ve bakımının daha kolay yapılmasını sağlar.

  6. Geniş Topluluk: TypeScript, büyük ve aktif bir geliştirici topluluğuna sahiptir. Sorularınızı sormak, rehberlik almak ve kaynaklara erişim sağlamak için birçok kaynak bulunmaktadır.

TypeScript, özellikle büyük ölçekli uygulamalar geliştiren geliştiriciler için güçlü bir seçenektir. Statik tipleme ve modern JavaScript özelliklerini kullanarak daha güvenli ve verimli kod yazmanıza olanak tanır. Umarım faydalı olmuştur.

Yararlanılan Kaynaklar.

https://en.wikipedia.org/wiki/TypeScript

 

9 Eylül 2023 Cumartesi

JavaScript Nedir?

 

JavaScript Nedir?

Merhaba bu yazıda kod detaylarına girmeden genel çerçevede JavaScript nedir? Ne işe yarar? Değinmek istiyorum. Özellikle yazılım dünyasına yeni girenler için genel çerçeveli bir yazı olacak.

JavaScript, web geliştirme için temel bir programlama dilidir ve modern web uygulamalarının vazgeçilmez bir parçasıdır. İlk olarak 1990'ların sonlarında Netscape Communications tarafından geliştirilen bu dil, tarayıcı tabanlı uygulamaların oluşturulmasını sağlar. JavaScript, kullanıcıların web sayfalarıyla etkileşimde bulunmasına, dinamik içerik oluşturmasına ve web uygulamalarıyla veri iletmelerine olanak tanır.  

JavaScript, tarayıcılar tarafından doğrudan desteklenir. JavaScript tarayıcılarda bulunan JavaScript motorlarının(Chrome V8 Engine, Firefox SpiderMonkey, Safari JavaScriptCore, Internet Explorer Chakra) yorumlaması sonucunda web sayfalarına dinamiklik kazandıran betik bir dildir ve olay tabanlıdır. Kullanıcıların web sayfalarında gezinirken çeşitli işlevler gerçekleştirmelerini sağlar. Bu işlevler arasında formların doğrulaması, animasyonlar, veri alışverişi (AJAX), oyunlar ve daha fazlası bulunur. Yani daha da açmak gerekirse mouse tıklama olayı, klavyeden bir tuşa basma anındaki olay veya hut sayfanın yuklenmesi olayı gibi zamanlarda web sayfasının içeriklerinin dinamik bir şekilde manupule edilmesini sağlar.

JavaScript, tarayıcıların yanı sıra sunucu tarafında da kullanılıyor. Sunucu tarafında JavaScript kodlarının çalışmasını sağlayan platform Node.js'tir. Node.js V8 JavaScriptmotoru üzerinde çalışır. V8 Google tarafından geliştirilen Chrome web browserlarının da üzerinde çalıştığı C, C++ ve JavaScript dilleri ile kodlanan açık kaynak kodlu bir motordur. V8 JavaScript motoru hakkında daha detaylı bilgi almak için buraya tıklayabilirsiniz. Node.js sunucu tarafı uygulamaları geliştirmek için kullanılır. Genellikle hızlı ve ölçeklenebilir ağ uygulamaları oluşturmak için kullanılır. Node.js JavaScript ile yazılmış bir kodu çalıştırmak için gerekli her şeyi içerir.

JavaScript'in Tarihçesi

JavaScript, Netscape Communications tarafından 1995 yılında geliştirilmeye başlandı. O dönemde "Mocha" olarak adlandırılan bu dil, daha sonra "LiveScript" ve sonunda Java dilinin o dönemki popülerliğinden faydalanmak için "JavaScript" olarak adlandırıldı.

  1. Netscape ve Internet Explorer Savaşı (1990'lar): JavaScript, Netscape Navigator tarayıcısında popülerlik kazandı ve web geliştiricileri tarafından kullanıldı. Bu, Microsoft'un Internet Explorer tarayıcısını piyasaya sürmesiyle bir rekabet dönemine yol açtı.

  2. ECMAScript Standardının Oluşturulması (1997): JavaScript'in standartlaştırılması amacıyla European Computer Manufacturers Association (ECMA) tarafından çalışmalar başladı. Bu çalışmalar sonucunda ECMAScript adı verilen bir standart oluşturuldu. JavaScript, bu standart üzerine inşa edildi ve resmi adı "ECMAScript" oldu.

  3. Ajax ve Web 2.0 (2000'ler): JavaScript, web geliştirme için önemli bir araç haline geldi. Özellikle Ajax (Asynchronous JavaScript and XML) teknolojisinin ortaya çıkması, web sayfalarının daha hızlı ve dinamik hale gelmesini sağladı.
     
  4. jQuery ve Diğer Kütüphaneler (2000'ler): jQuery gibi JavaScript kütüphaneleri, web geliştiricilerinin JavaScript'i daha kolay ve etkili bir şekilde kullanmasına yardımcı oldu. Bu kütüphaneler, tarayıcı uyumsuzluklarını ele alarak geliştirme sürecini kolaylaştırdı.
  1. Node.js'in Ortaya Çıkışı (2009): Node.js, sunucu tarafında JavaScript çalıştırmak için kullanılan bir platform olarak ortaya çıktı. Bu, JavaScript'i sadece tarayıcıda değil, sunucu tarafında da kullanılabilir hale getirdi.

  2. Modern JavaScript (ES6 ve Sonrası): ECMAScript 6 (ES6) ve sonraki sürümleri, JavaScript'i daha güçlü ve modern bir dil haline getirdi. Arrow fonksiyonları, sınıflar, modüller gibi yeni özellikler ekledi ve JavaScript'i daha geliştirici dostu hale getirdi.

  3. Bugünkü Kullanım (2020'ler): JavaScript, web geliştirmenin temel taşıdır ve sayısız web sitesi, web uygulaması ve hatta mobil uygulama geliştirmek için kullanılır. Modern web geliştirme çerçeveleri ve kütüphaneleri, JavaScript'i daha güçlü hale getirirken, geliştiriciler için daha verimli bir deneyim sunar.

JavaScript, web geliştirme dünyasının vazgeçilmez bir parçası olarak varlığını sürdürüyor ve sürekli olarak evriliyor. Günümüzde, tarayıcı tabanlı uygulamalardan sunucu tarafı geliştirmeye kadar birçok farklı alanda kullanılıyor.

JavaScript Frameworkleri

Javascript şuan yazılım geliştirme dünyasında öyle bir yere oturmuş ki neredeyse her alanda çalışan bir yazılım geliştiricisinin yolu illaki bir şekilde JavaScript ile kesişmektedir. Farklı uygulamalar geliştirmek için JavaScript üzerine yazılmış bir sürü framework ve kütüphanaler bulunmaktadır. Kısaca değinecek olursak bunlardan bazıları şöyledir;

  1. Angular: Google tarafından geliştirilen Angular, büyük ve karmaşık web uygulamaları oluşturmak için kullanılan bir JavaScript çerçevesidir. Bağlayıcı veri bağlama, modülerlik ve güçlü bir bileşen tabanlı mimari sunar.

  2. React: Facebook tarafından geliştirilen React, kullanıcı arayüzlerini oluşturmak ve yönetmek için kullanılan bir JavaScript kütüphanesidir. Component tabanlı bir yaklaşım sunar ve sanal DOM (Virtual DOM) kullanarak performansı artırır.

  3. Vue.js: Vue.js, JavaScript tabanlı bir açık kaynaklı frameworktür. Kolay öğrenilebilir ve kullanımı basittir. Vue, bileşen tabanlı bir yaklaşım sunar ve hızlı geliştirme için mükemmel bir seçenektir.

  4. Ember.js: Ember.js, büyük ölçekli uygulamalar oluşturmak için tasarlanmış bir JavaScript frameworktür. İyi tanımlanmış bir klasör yapısı ve kod organizasyonu ile geliştiriciye rehberlik eder.

  5. Backbone.js: Backbone.js, web uygulamaları oluşturmak için kullanılan hafif bir frameworktür. Model, görünüm ve denetleyici bileşenlerine dayanır ve uygulamanın ön yüzünü organize etmeye yardımcı olur.

  6. Express.js: Express.js, Node.js tabanlı bir web uygulama çerçevesidir. Özellikle sunucu tarafı geliştirmek için kullanılır ve hızlı ve hafif bir yapı sunar.

  7. Meteor: Meteor, hem sunucu hem de istemci tarafı kodunu aynı dil olan JavaScript kullanarak geliştirmenizi sağlayan bir platformdur. Gerçek zamanlı uygulamalar ve hızlı prototipleme için uygundur.

  8. Svelte: Svelte, web uygulamaları oluşturmak için kullanılan bir frameworktür. İlginç bir özelliği, kodun derlenmiş olmasıdır. Bu, daha hızlı çalışan uygulamalar oluşturmanıza olanak tanır.

Bu frameworklerin her biri farklı gereksinimlere ve kullanım durumlarına yöneliktir. Geliştirme ihtiyaçlarınıza ve tercihlerinize bağlı olarak en uygun olanını seçebilirsiniz.

JavaScrip'in Avantajları 

JavaScript, web geliştirmenin vazgeçilmez bir parçasıdır ve birçok avantaja sahiptir. İşte JavaScript'in bazı avantajları:

  • Tarayıcı Desteği: JavaScript, neredeyse tüm modern web tarayıcıları tarafından desteklenir. Bu, web uygulamalarını farklı platformlarda ve tarayıcılarda sorunsuz bir şekilde çalıştırmanıza olanak tanır.

  • Hızlı Geliştirme: JavaScript, hızlı prototipleme ve geliştirme için uygundur. Hızlı sonuçlar almanızı ve projelerinizi hızla iterasyonlara tabi tutmanızı sağlar.

  • Geniş Topluluk ve Kaynaklar: JavaScript, büyük ve aktif bir geliştirici topluluğuna sahiptir. Bu, sorularınızı sormak, rehberlik almak ve sorunları çözmek için geniş kaynaklara erişim sağlar.

  • Modülerlik ve Kütüphaneler: JavaScript ile birçok modülerlik sağlayan kütüphane ve framework bulunmaktadır. Bu, kodunuzu yeniden kullanmanıza ve geliştirme sürecini hızlandırmanıza olanak tanır.

  • Etkileşimli Kullanıcı Arabirimi: JavaScript, kullanıcılarla etkileşimde bulunmanızı sağlar. Form doğrulamaları, animasyonlar, oyunlar ve gerçek zamanlı güncellemeler gibi etkileşimli özellikler eklemek için kullanılır.

  • Sunucu Tarafı ve İstemci Tarafı: JavaScript, hem sunucu tarafında (Node.js) hem de istemci tarafında kullanılabilir. Bu, tam yığın (full-stack) web geliştirme için idealdir.

  • ES6 ve Sonrası Güncellemeler: ECMAScript 6 (ES6) ve sonraki sürümleri, JavaScript'i daha güçlü ve modern hale getirdi. Bu güncellemeler, kodun daha okunabilir ve sürdürülebilir olmasını sağlar.

  1. Veri İletişimi: AJAX (Asynchronous JavaScript and XML) kullanarak veri alışverişi yapmak için JavaScript kullanılabilir. Bu, web uygulamalarının veritabanlarıyla iletişim kurmasını ve dinamik içerik sağlamasını sağlar.

JavaScript, web geliştirme süreçlerini hızlandıran ve daha iyi kullanıcı deneyimi sunan birçok avantaja sahiptir. Ancak, iyi bir kod yazımı ve güvenlik uygulamalarına dikkat etmek önemlidir.

JavaScript'in özelliği, tarayıcılarla etkileşimde bulunmanın ötesinde, öğrenmesi ve kullanılması kolay bir dil olmasıdır. Ayrıca, büyük bir geliştirici topluluğu tarafından desteklenir ve sürekli olarak geliştirilmektedir. Bu nedenle, web geliştirme dünyasında önemli bir yer tutar ve web uygulamalarının interaktif, kullanıcı dostu ve işlevsel olmasını sağlar. Umarım faydalı olmuştur.

Yararlanılan Kaynaklar.

https://tr.wikipedia.org/wiki/JavaScript

8 Eylül 2023 Cuma

Node.js Nedir?

 

Node.js Nedir?

Bu yazıda kısaca Node.js' den bahsedeceğim fakat JavaScript'e detaylı girmeyeceğim. Bilindiği gibi JavaScript tarayıcıların JavaScript motorlarının(Chrome V8 Engine, Firefox SpiderMonkey, Safari JavaScriptCore, Internet Explorer Chakra) yorumlaması sonucunda web sayfalarına dinamiklik kazandıran betik bir dildir ve olay tabanlıdır. Yani mouse tıklama olayı, klavyeden bir tuşa basma anındaki olay veya hut sayfanın yuklenmesi olayı gibi zamanlarda web sayfasının içeriklerinin dinamik bir şekilde manupule edilmesini sağlar.

Node.js ise JavaScript tabanlı bir platformdur ve sunucu tarafında V8 JavaScript motoru üzerinde çalışır. V8 Google tarafından geliştirilen Chrome web browserlarının da üzerinde çalıştığı C, C++ ve JavaScript dilleri ile kodlanan açık kaynak kodlu bir motordur. V8 JavaScript motoru hakkında daha detaylı bilgi almak için buraya tıklayabilirsiniz. Node.js sunucu tarafı uygulamaları geliştirmek için kullanılır. Genellikle hızlı ve ölçeklenebilir ağ uygulamaları oluşturmak için kullanılır. Node.js JavaScript ile yazılmış bir kodu çalıştırmak için gerekli her şeyi içerir.

 İşte Node.js'in bazı temel özellikleri:

  1. Hızlı ve Verimli: Node.js, V8 JavaScript motoru tarafından desteklenir ve hızlı bir şekilde çalışır. Bu, yüksek performanslı uygulamaların oluşturulmasına yardımcı olur.

  2. Olay İşleme: Node.js, olaylar temelinde çalışır. Bu, çok sayıda eşzamanlı bağlantıyı yönetmek için uygundur, bu nedenle gerçek zamanlı uygulamalar için idealdir.

  3. Paket Yönetimi: Node.js, npm (Node Package Manager) adlı güçlü bir paket yöneticisine sahiptir. Bu, binlerce hazır paketin kullanılmasını ve kodun hızlı bir şekilde genişletilmesini sağlar.

  4. Çapraz Platform Desteği: Node.js, Windows, macOS ve Linux gibi birçok platformda çalışabilir, bu da geliştiricilerin farklı işletim sistemlerinde uygulama geliştirmesini kolaylaştırır.

  5. Topluluk Desteği: Node.js'in geniş ve aktif bir topluluğu vardır. Bu, sorunlarınızı çözmek veya yeni özellikler eklemek için yardımcı olabilecek kaynakların bolca bulunduğu anlamına gelir.

Node.js, özellikle web sunucuları, API'ler ve gerçek zamanlı uygulamalar gibi ağ yoğun uygulamalar geliştirmek için popüler bir seçenektir. JavaScript dilini kullanmanın yanı sıra, sunucu ve istemci tarafında aynı dili kullanmanın avantajlarından birine sahiptir.

3 Eylül 2023 Pazar

Abstract Factory Design Pattern Nedir?

 

Abstract factory design pattern nedir?

Merhabalar, bu yazımızda Abstract Factory Design Pattern ile ilgili örnek bir proje gerçekleştireceğiz.Önceki yazımızda Factory Design Method Pattern ile ilgili örnek bir proje yapmıştık. Peki Factory Design Method ile Abstract Factory Design arasındaki fark nedir ? Sorusuna cevap vermeye çalışalım.

Factory Method’ta ilişkisel olan birden fazla nesnenin üretimini ortak bir arayüz aracılığı ile tek bir sınıf üzeriden oluşturur.Nesne üretimi esnasında istemcinin üretilen nesneye olan bağımlılığını ortadan kaldırmayı hedefler.

Abstract Factory ise ilişkisel olan birden fazla nesnenin üretimini tek bir arayüz üzerinden değil de her ürün grubu için farklı bir arayüz tanımlayarak sağlamaktadır.Yani birden fazla ürün grubu ile çalışacaksak bunları istemciden bu yöntemle soyutlayarak nesneler üretilir.

Şimdi örnek projeye başlayalım.Öncelikle interface tanımlarını yapalım. 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
    /// <summary>
    /// Araba nesnelerimin türetildiği base interface
    /// </summary>
    public interface IAraba
    {
        /// <summary>
        /// Arabanın adını getiren method
        /// </summary>
        /// <returns></returns>
        string GetArabaModeli();
    }

    /// <summary>
    /// Jant Nesnelerimin türetileceği base interface
    /// </summary>
    public interface IJant
    {
        /// <summary>
        /// Jantın çapını getiren method
        /// </summary>
        /// <returns></returns>
        int GetJantCapi();
    }
    
    /// <summary>
    /// Marka oluşturan base interface
    /// </summary>
    public interface IMarkaFactory
    {
        /// <summary>
        /// Araba Nesnesini oluşturan method
        /// </summary>
        /// <returns></returns>
        IAraba ArabaOlustur();

        /// <summary>
        /// Jant nesnesini oluşturan method
        /// </summary>
        /// <returns></returns>
        IJant JantOlustur();
    }

 

 Yine araba markaları üzerinden anlatım yapacağım.Şimdi de arabaların modellerini oluşturuyorum.

 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
    /// <summary>
    /// BMW nesnesi IAraba interfaceden türettim
    /// </summary>
    public class Bmw : IAraba
    {
        /// <summary>
        /// Araba modelini getirir
        /// </summary>
        /// <returns></returns>
        public string GetArabaModeli()
        {
            return "7.40";
        }
    }
    
    /// <summary>
    /// Mercedes nesnesi IAraba interfaceden türettim
    /// </summary>
    public class Mercedes : IAraba
    {
        /// <summary>
        /// Araba Modelini getirir.
        /// </summary>
        /// <returns></returns>
        public string GetArabaModeli()
        {
            return "CLA 350";
        }
    }
    
    /// <summary>
    /// OPEL nesnesi IAraba interfaceden türettim
    /// </summary>
    public class Opel : IAraba
    {
        /// <summary>
        /// Araba Modelini getirir.
        /// </summary>
        /// <returns></returns>
        public string GetArabaModeli()
        {
            return "Insignia";
        }
    }

 

 Şimdide araba modellerinde bulunacak olan jantları oluşturacağım.

 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
    /// <summary>
    /// Bmw jantının nesnesini Ijant interfaceden türetiyorum
    /// </summary>
    public class BmwJant : IJant
    {
        /// <summary>
        /// Jant çapını getiren method
        /// </summary>
        /// <returns></returns>
        public int GetJantCapi()
        {
            return 19;
        }
    }
    
    /// <summary>
    /// Jant nesnesini Ijant interfaceden türetiyorum
    /// </summary>
    public class MercedesJant : IJant
    {
        /// <summary>
        /// Janbt çapını getiren method
        /// </summary>
        /// <returns></returns>
        public int GetJantCapi()
        {
            return 18;
        }
    }
    
    
    /// <summary>
    /// Opel Jantlarını Ijant interfaceden türetiyorum
    /// </summary>
    public class OpelJant : IJant
    {
        /// <summary>
        ///JAnt çapını getiren method
        /// </summary>
        /// <returns></returns>
        public int GetJantCapi()
        {
           return 17;
        }
    }

 

Şimdide araba nesnesini oluşturacak factory classları yazıyoruz.Bu kısımda IMarkaFactory interface’inde yaptığımız tanımlamalara göre bize araba ve jant nesnesinden oluşan bir marka objesi üretme işlemi gerçekleştireceğiz. Aşağıdaki kodlara bakıldığında daha iyi anlaşılacaktır.

 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
    /// <summary>
    /// BmwFactory Bmw fabrikası gibi düşünebirlirsiniz.
    /// IMarkaFactory interfaceden Bir tane araba 
    /// ve jant oluşturan methodlarla araba ve jant oluşturuyoruz.
    /// </summary>
    public class BmwFactory : IMarkaFactory
    {
        public IAraba ArabaOlustur()
        {
            return new Bmw();
        }

        public IJant JantOlustur()
        {
            return new BmwJant();
        }
    }
    
    /// <summary>
    /// MercedesFactory Mercedes fabrikası gibi düşünebirlirsiniz.
    /// IMarkaFactory interfaceden Bir tane araba ve jant oluşturan
    /// methodlarla araba ve jant oluşturuyoruz.
    /// </summary>
    public class MercedesFactory : IMarkaFactory
    {
        public IAraba ArabaOlustur()
        {
            return new Mercedes();
        }

        public IJant JantOlustur()
        {
            return new MercedesJant();
        }
    }
    
    
    /// <summary>
    /// OpelFactory Opel fabrikası gibi düşünebirlirsiniz.
    /// IMarkaFactory interfaceden Bir tane araba ve jant
    /// oluşturan methodlarla araba ve jant oluşturuyoruz.
    /// </summary>
    public class OpelFactory : IMarkaFactory
    {
        public IAraba ArabaOlustur()
        {
            return new Opel();
        }

        public IJant JantOlustur()
        {
            return new OpelJant();
        }
    }

İnterface ve class tanımlamalarımız buraya kadardı.Biz şimdi burada ne yaptık ? IAraba ve IJant interface yasesinde istediğimiz kadar farklı jant ve araba tipi üretebiliriz. IMarkaFactory interface’i sayesinde istediğimiz kombinasyonlarda marka üretebiliriz. ImarkaFactory interface’i sayesinde Bmw, Mercedes, Opel markalarını üretebiliyorum.

Ama bu üretim için DunyaMarkalari class’ını kullanıyoruz. İstediğim markanın özelliklerine göre markayı üretip objeyi geri dönüyor bize.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
    /// <summary>
    /// Clientların marka,araba ve jant oluşturmak istediklerinde bu objeyi kullanacaklar
    /// </summary>
    public class DunyaMarkalari
    {
        /// <summary>
        /// oluşturulacak arabayı tuttuğumuz değişken
        /// </summary>
        private readonly IAraba _araba;

        /// <summary>
        /// Oluşturulacak jantı tuttuğumuz değişken
        /// </summary>
        private readonly IJant _jant;

        /// <summary>
        /// Nesneye constructor da hangi markayı verirsem o markanın objesini oluşturur.
        /// </summary>
        /// <param name="markaFactory"></param>
        public DunyaMarkalari(IMarkaFactory markaFactory)
        {
            _araba = markaFactory.ArabaOlustur();
            _jant = markaFactory.JantOlustur();
        }

        /// <summary>
        /// Oluşturulan arabanın modelini getirir. 
        /// </summary>
        /// <returns></returns>
        public string ArabaModeli()
        {
            return _araba.GetArabaModeli();
        }

        /// <summary>
        /// Oluşturulan jantın çapını getirir. 
        /// </summary>
        /// <returns></returns>
        public int JantCapi()
        {
            return _jant.GetJantCapi();
        }
    }

 Şimdi örneğimizdeki 3 farklı markayı üretip özelliklerine bakalım.

 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
            BmwFactory bmwFactory = new BmwFactory();
            OpelFactory opelFactory = new OpelFactory();
            MercedesFactory mercedesFactory = new MercedesFactory();

            DunyaMarkalari dunyaMarkalari = new DunyaMarkalari(bmwFactory);
            Console.WriteLine(String.Format("Araba Modeli:{0}, Jant Çapı:{1}", dunyaMarkalari.ArabaModeli(), dunyaMarkalari.JantCapi()));

            Console.WriteLine(Environment.NewLine);

            DunyaMarkalari dunyaMarkalari2 = new DunyaMarkalari(opelFactory);
            Console.WriteLine(String.Format("Araba Modeli:{0}, Jant Çapı:{1}", dunyaMarkalari2.ArabaModeli(), dunyaMarkalari2.JantCapi()));

            Console.WriteLine(Environment.NewLine);

            DunyaMarkalari dunyaMarkalari3 = new DunyaMarkalari(mercedesFactory);
            Console.WriteLine(String.Format("Araba Modeli:{0}, Jant Çapı:{1}", dunyaMarkalari3.ArabaModeli(), dunyaMarkalari3.JantCapi()));

 

 


 

 Umarım faydalı olmuştur.Kaynak kodları github’a koydum oradan bakıp inceleyebilirsiniz.Esen kalın.

Yararlandığım Kaynaklar

Kaynak Kodu 

https://medium.com/@hakantopuz/abstract-factory-design-pattern-nedir-ne-zaman-ve-nas%C4%B1l-kullan%C4%B1l%C4%B1r-25dea188477c

https://www.gencayyildiz.com/blog/c-abstract-factory-design-patternabstract-factory-tasarim-deseni/ 

Factory Method Design Pattern Nedir ?

 

Factory method design pattern nedir ?

Merhabalar, bu yazımızda Factory Method Design Pattern ile ilgili bir örnek proje gerçekleştireceğiz. Bu tasarım kalıbıyla yapılmak istenen amaç, oluşturmak istediğimiz sınıfın kendisinden bir örnek istemek yerine Factory Method Pattern'i sayesinde tek bir instance üzerinden gerekli nesnenin üretilmesini sağlamaktır.

Uygulamamızda belirli adımlarda farklı tiplerde nesnelere ihtiyacımız olabilir. Bu nesneleri if - else veyahut switch yapıları aracılığıyla, duruma göre oluşturabiliriz. Tabi bunu her seferinde yapmanın zaman ve kod açısından çok tasarruflu olduğunu düşünülemez. İşte böyle durumlarda Factory Method Pattern'ini kullanabiliriz.

Bir başka deyişle, elinizin altındaki birden çok ilişkisel sınıftan nesne üreteceksek, söz gelimi her defasında ilgili nesneye özel üretme gramerini uygulamanıza gerek kalmayacak, tek bir sınıf üzerinden oluşturacağımız nesne talebiyle istediğiniz nesneyi elde edebileceğiz.

Şimdilik şöyle bir örnek üzerinden gidelim.Bir galeri düşünelim Bmw, Opel, Mercedes markalarını satıyor. Factory Method Pattern'i ile istediğimiz araba nesnesini üretelim.

Abstract Class İle Factory Method Design Pattern

Kurgulanan senaryoya göre tüm arabalarin türetilecek abstract class’ı dizayn edelim.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryMethodDesign.AbstractClass
{
    /// <summary>
    /// Soyutlanacak base class abstract kelimesi ile belirtilir
    /// </summary>
   abstract class ArabaMarkasi
    {
        /// <summary>
        /// MarkaAdi methodu abstract kelimesi ile işaretlenerek ArabaMarkasi clasından kalıtılan
        /// classta bu method override edilmek zorunda. Oyuzden gövdesi burada doldurulmaz.
        /// </summary>
        public abstract void MarkaAdi();
    }
}

 

Şimdide arabalarımızı tasarlayalım ve oluşturmuş olduğumuz “ ArabaMarkasi ” abstract class’ından bu ürünleri türetelim.

Bmw:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryMethodDesign.AbstractClass
{
    /// <summary>
    /// Bmw class'ını soyutlanmış ArabaMarkasi class'ından türetiyorum.
    /// Ve ArabaMarkasi class'ındaki abstract olarak tanımlanmış methodu override ederek methodun body'sini dolduruyorum
    /// </summary>
    class Bmw : ArabaMarkasi
    {
        /// <summary>
        /// ArabaMarkasi class'ından iplement'e edilen ve override edilen method
        /// </summary>
        public override void MarkaAdi()
        {
            Console.WriteLine("Bu araba abstarc'tan Oluşturuldu ve Bmw dir.");
        }
    }
}


Mercedes:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryMethodDesign.AbstractClass
{
    /// <summary>
    /// Mercedes clasını soyutlanmış ArabaMarkasi clasından türetiyorum.
    /// Ve ArabaMarkasi klasındaki abstract olarak tanımlanmış methodu override ederek, methodun body sini dolduruyorum
    /// </summary>
    class Mercedes : ArabaMarkasi
    {
        /// <summary>
        /// ArabaMarkasi clasından iplemente edilen ve override edilen method
        /// </summary>
        public override void MarkaAdi()
        {
            Console.WriteLine("Bu araba Abstarctan Oluşturuldu ve Markası Mercedes tir.");
        }
    }
}

 

Opel:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryMethodDesign.AbstractClass
{
    /// <summary>
    /// Opel platformunun clasını soyutlanmış ArabaMarkasi clasından türetiyorum.
    /// Ve ArabaMarkasi klasındaki abstract olarak tanımlanmış methodu override ederek, methodun body sini dolduruyorum
    /// </summary>
    class Opel : ArabaMarkasi
    {
        /// <summary>
        /// ArabaMarkasi clasından iplemente edilen ve override edilen method
        /// </summary>
        public override void MarkaAdi()
        {
            Console.WriteLine("Bu araba Abstarctan Oluşturuldu ve Markası Opel dir.");
        }

    }
}

 

Araba ürünlerimi Abstract class olan ArabaMarkasi sınıfından türeterek sınıflarımı oluşturdum. Artık bu sınıflardan nesne üretecek olan Creater sınıfını oluşturalım ve içerisine Factory işlemini yapacak metodumuzu tanımlayalım.

Ama öncelikle bu method hangi tipten nesne üreteceğini nerden bilecek? Bu durumu Enumaration ile halledebiliriz. Aşağıdaki Enumaration FactoryMethod’un hangi tipte nesne üreteceğine yardımcı olacaktır.

Araba Çeşitleri:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryMethodDesign.AbstractClass
{
    enum Markalar
    {
        Bmw,
        Opel,
        Mercedes
    }
}

 

 Bu işlemden sonra FactoryMethod’u tam olarak inşa edebiliriz.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
using System;
using System.Collections.Generic;
using System.Text;

namespace FactoryMethodDesign.AbstractClass
{
    /// <summary>
    /// Creator clasımız objelerin oluşturulmasından sorumlu obje
    /// </summary>
    class Creator
    {
        /// <summary>
        /// ArabaMarkasi tipinde obje oluşturan factory method 
        /// </summary>
        /// <param name="oyunTipi"></param>
        /// <returns></returns>
        public ArabaMarkasi FactoryMethod(Markalar arabaMarkasi)
        {
            ArabaMarkasi araba = null;
            switch (arabaMarkasi)
            {
                case Markalar.Bmw:
                    araba = new Bmw();
                    break;
                case Markalar.Opel:
                    araba = new Opel();
                    break;
                case Markalar.Mercedes:
                    araba = new Mercedes();
                    break;
                default:
                    break;
            }
            return araba;
        }
    }
}

 

Gördüğünüz gibi FactoryMethod parametresinde belirttiğimiz tipe göre istediğimiz nesneyi oluşturacak bir işleyişe sahip oldu. Burada dikkat etmeniz gereken husus, her bir araba ürününün “ArabaMarkasi” abstract class’ından kalıtım almasından dolayı çok biçimlilik kullanılarak “ArabaMarkasi” referansında tutulabilmekte ve geriye döndürülebilmektedir. Sıra geldi istediğimiz nesneyi üretmeye…

Ekran görüntüsü aşağıdaki gibi oluyor.

 

Tabi ilişkisel sınıflar ve algoritmada ki ihtiyaca göre üretilmesi gereken sınıflar üzerinde bu tasarım desenini uygulamak en doğrusudur.

Eğer Factory Method tasarım desenenini interface kullanarak uygulamak istiyorsanız, “ArabaMarkasi” isimli abstract sınıfını interface’e çevirmeniz yeterlidir. Tabi bu çevrim sırasında interface kurallarını dikkate almalı ve arabalari interfaceden türetirken yapılacak implementte override komutu olmadan uygulama gerçekleştirilmelidir. Bununla ilgili yazıda kod parçaaı koymayacağım ama github taki projede o kodlar mevcut.Umarım faydalı olmuştur iyi çalışmalar.

 Yararlandığım Kaynaklar

Kaynak Kodu 

https://www.gencayyildiz.com/blog/c-factory-method-design-patternfactory-method-tasarim-deseni/ 

http://www.canertosuner.com/post/factory-method-pattern-nedir-nasil-kullanilir 

Singleton Design Pattern Nedir ?

 

Singleton Design Pattern Nedir ?

Merhaba arkadaşlar bu yazımızda yazılımcılar tarafından en çok kullanılan tasarım kalıbı olan Singleton tasarım kalıbından bahsedeceğiz.Ama öncelikle çalışma mantığından bahsedelim.

Programlamada yaratılan her nesne ve değişken bellekte yer kaplar.Bazı nesneler vardır ki her istekte tekrar yaratılmasına ve bellekte yer kaplamasına gerek yoktur.Örneğin Db connection nesnesi veya Log nesnesi gibi. Her istek için ayrı ayrı bu nesneyi oluşturmak performans kaybına sebep olacaktır. Singleton ile oluşturulan nesneler tek bir örnek üzerinde kalır ve her istek bu örneği kullanır.

Signleton Design Pattern Kullanımı

Singleton design pattern deseninin 6 farklı şekilde kullanımı mevcut fakat ben en basit halini göstereceğim.Geri kalanlarına detaylı olarak buradan bakabilirsiniz.

En önemli kural burada Singleton ile ilgili sınıf dahilinde instance alınmasını önlemek, bu işlem için private ve protected access modifier ile classı tanımlayarak da yapılabilir fakat bizim isteklerimizden bir diğeri de yalnızca bir defa instance alınabilmesini sağlamak. O halde ilgili sınıfın içinde bir yerlerde nesnemizin oluşması gerekiyor. Bunu property veya statik bir metotla yapabiliriz.

Burada aslında en önemli noktalardan birinden bahsetmek istiyorum. Buradaki asıl amaç manuel olarak instance oluşturulmasını engellemek. Bu amaçla yola çıkarak Teksinif class’ımızın default constructor’unu private yapıyoruz ve ikinci bir instance oluşturulmasını engelliyoruz. Oluşturacağımız nesne sadece sınıf içerisinden oluşturulacağı için tek bir instance oluşturulmasını garantilemiş olacağız. Şimdi Teksinif class’ımızı görelim:

 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
using System;
using System.Collections.Generic;
using System.Text;

namespace Singleton
{
    public class SingleClass
    {
        private SingleClass()
        {
            Random r = new Random();
            deger = r.Next();
        }
        private static SingleClass _instance;
        private static SingleClass instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new SingleClass();
                }
                return _instance;

            }
            set
            {
                _instance = value;
            }

        }
        public int deger;
        public static SingleClass getInstance()
        {
            return instance;
        }
    }
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
using System;

namespace Singleton
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            SingleClass tek = SingleClass.getInstance();

            Console.WriteLine("\n Ilk Instance: {0}", tek.deger);

            SingleClass tek2 = SingleClass.getInstance();
            Console.WriteLine("\n Ikinci Instance: {0}", tek2.deger);
        }
    }
}

Göründüğü üzere yapıcı metodumuz private erişim belirleyicisi ile korunmakta. Burada altını çizmem gereken yapıcı metodumun içerisinde deger değişkenimi random bir sayı ile doldurmam yani Main metodumda iki adet getInstance yaptığımda tek bir nesne ile mi çalıştığımızı anlayabilmek için.

Main tarafında test etmek için getInstance metodunu kullandık ve degerlerini test ediyoruz. Çıktı aşağıdaki gibi olmalı yani sayılar eşit olmalı.

 

 

Umarım faydalı olmuştur.Bir sonarki yazımızda görüşmek üzere.

Yaralanılan Kaynaklar

Kaynak Kodu 

http://sehmusgokce.com/singleton-tasarim-deseni-design-pattern-nedir-ve-nasil-kullanilir-324.html 

http://www.ismailgursoy.com.tr/singleton-pattern-design-tek-nesneler/

 

Design Pattern Nedir?

 

Design Pattern Nedir? 
 
Yazılım dünyasında temel bir yazılım diline sahip bir yazılımcı küçük çaplı projeleri rahatlıkla yazabilir. Fakat projeler büyüdükçe işler farklılaşmaya başlar. Örneğin küçük bir blog sitesi, bir araba kiralama tanıtım sitesi gibi projelerden temel bir dil bilgisiyle başa çıkılabilir. Ancak bir devletin vatandaş portali gibi yada tüm dünyada satış yapan bir e-ticaret platformu gibi projeler büyükçe işler biraz daha da değişiyor. Kullanıcı sayısı artıkça performansın da önemi ortaya çıkmaya başlıyor.
 
Haliyle de teknoloji sürekli değişiyor ve yeni teknolojiler çıkıyor. Projenin bu değişikliğe en hızlı şekilde adapte olması gerekiyor. Bu adapte sürecinde kodların çok yalın ve karmaşık olmaması lazım. İşte bu noktada tasarım kalıplarının zorunluluğu ortaya çıkmış oluyor.
 

Peki Design Pattern Nedir?

Tasarım desenleri, deneyimli nesne yönelimli yazılım geliştiriciler tarafından kullanılan en iyi uygulamaları temsil eder. Tasarım kalıpları, yazılım geliştiricilerin yazılım geliştirme sırasında karşılaştıkları genel sorunların çözümleridir. Bu çözümler, oldukça uzun bir süre boyunca sayısız yazılım geliştiricisi tarafından deneme yanılma yoluyla elde edilmiştir.
 

Desing Pattern’lerin Kullanımı

Tasarım desenleri yazılım geliştirmede iki ana kullanım alanına sahiptir.Bunlar;

Geliştiriciler için ortak platform: Tasarım desenleri standart bir terminoloji sağlar ve belirli senaryolara özgüdür. Örneğin, bir singleton tasarım deseni, tek bir nesnenin kullanımını belirtir, böylece tek tasarım modeline aşina olan tüm geliştiriciler, tek nesneden yararlanır ve programın bir singleton modelini takip ettiğini söyleyebilirler.

Pratik Uygulamaları: Tasarım Desenleri uzun bir süredir gelişmiştir ve yazılım geliştirme sırasında karşılaşılan bazı sorunlara en iyi çözümleri sunmaktadır. Bu kalıpları öğrenmek, deneyimsiz geliştiricilerin yazılım tasarımını kolay ve hızlı bir şekilde öğrenmelerine yardımcı olur.

Design Pattern Türleri: 1994 yılında dört yazar Erich Gamma, Richard Helm, Ralph Johnson ve John Vlissides, Yazılım geliştirmede tasarım deseni kavramını başlatan tasarım desenleri — Yeniden Kullanılabilir Nesneye Yönelik Yazılım Öğeleri başlıklı bir kitap yayımladı. Buradan bakabilirsiniz.

Bu yazarlar toplu olarak Dörtlü “Gang of Four” olarak bilinir. Bu yazarlara göre tasarım desenleri öncelikle nesne yönelimli tasarım ilkelerine dayanmaktadır. Bu dörtlü kitaplarında 3 kategoride 23 farklı kalıba yer vermişlerdir.

Creational: Nesneleri yaratmakta kullanılan 5 adet tasarım kalıbı. Yazılım sistemindeki nesnelerin yaratılışı hakkında yol gösterirler. Bunlar;

  1. Factory Method
  2. Singleton
  3. Abstract Factory
  4. Builder 

Structural: Nesneler arasındaki yapıları ifade eden ilişkilerden 7 adet tasarım kalıbı. Yazılım sistemindeki nesnelerin birbirleriyle olan ilişkilerini gösteren kalıptır.

  1. Adapter
  2. Bridge
  3. Composite
  4. Decorator
  5. Facade
  6. Flyweight
  7. Proxy

Behavioral: Nesnelerin çalışma zamanına ait davranışlarını değiştirmek için oluşturulan tasarımlardan 11 adet tasarım kalıbı var. Nesne davranışlarını takip eden kalıptır.

  1. Iterator
  2. Observer
  3. Memento
  4. Mediator
  5. Chain of Responsibility
  6. Command
  7. Observer
  8. State
  9. Strategy
  10. Template Method
  11. Visitor

Tasarım kalıpları, yazılım mühendisliği alanında yaygın olarak kullanılan bir yaklaşım olup, birçok yazılım projesinin tasarım ve geliştirme süreçlerinde başarıyla uygulanmaktadır. Bu kalıplar, çözümlenmesi zor olan sorunlara karşı etkili bir şekilde çözümler sunmak için kullanılan standart çözüm yaklaşımlarını temsil eder. Tasarım kalıpları, yazılım geliştiricilerinin tekrarlanan problemleri yeniden keşfetmelerini önleyerek, kodun yeniden kullanılabilirliğini ve sürdürülebilirliğini arttırır. Buna ek olarak, tasarım kalıpları, yazılım uygulamalarının performansını, güvenilirliğini ve esnekliğini artırabilir. Bu nedenle, tasarım kalıplarının kullanımı, yazılım geliştirme süreçlerinde çok önemlidir ve yazılım mühendislerinin bilgi birikimlerinde yer almalıdır.

Yararlanılan kaynaklar

https://www.tutorialspoint.com/design_pattern/factory_pattern.htm

https://medium.com/nsistanbul/design-patterns-factory-method-pattern-615457e9560b 

 

.Net Core'da Swagger UI Kullanımı

  Web API geliştirirken API de yazılan metodların ne iş yaptığı? Hangi parametreleri aldığı? Ne cevap döndüğü? Gibi bilgilerin yer aldığı ...