31 Ağustos 2023 Perşembe

Asp .Net Core’da In-Memory Cache Kullanımı

 

Asp .Net Core’da In-Memory Cache Kullanımı
 

Bu yazımızda Asp.Net Core’un default built-in yapısında In-Memory Cache özelliğinden bahsedeceğiz. Asp.Net Core, uygulama performansını artırmak için çeşitli önbellekleme mekanizmaları sağlar. Bunlardan biri de In-Memory Cache kullanımıdır. In-Memory Cache, uygulamanın hafızasında tutulan önbellek verileridir.

In-Memory Cache Özelliğini Aktif Etmek

In-Memory Cache kullanmak için, öncelikle uygulamanızda Microsoft.Extensions.Caching.Memory paketinin yüklü olduğundan emin olunuz. Daha sonra, ConfigureServices() metodunda IMemoryCache arayüzüne ait bir instance oluşturmanız gerekmektedir. In-memory cache özelliği Asp.Net Core içerisinde bir service olarak bulunmaktadır. Bu servis default kapalı gelir yapmamız gereken Startup.cs içerisinde bulunan ConfigureServices metodunda aşağıdaki gibi cache servisini açmak. 

 

1
2
3
4
5
 public void ConfigureServices(IServiceCollection services)
 {
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
            services.AddMemoryCache();
 }

 

Bu kod parçası, ConfigureServices() metodunda services koleksiyonuna IMemoryCache instance’ı ekler.

IMemoryCache interface, Asp.Net Core projelerinde in-memory cache kullanmamızı sağlayan bir arayüzdür. Bu arayüze ait metotları kullanarak cache set, get, remove gibi işlemleri yapabiliriz. 


1
2
3
4
5
6
 public interface IMemoryCache : IDisposable
 {
         bool TryGetValue(object key, out object value);
         ICacheEntry CreateEntry(object key);
         void Remove(object key);
 }

 

In-Memory Cache Kullanımı

In-Memory Cache servisi aktifleştirdikten sonra IMemoryCache arayüzünü kullanmak istediğimiz katmana ait constructor’da inject ediyoruz. Bizde geriye Student listesi return ettiğimiz bir controller tanımlayarak IMemoryCache arayüzünü aşağıdaki gibi constructor injection parameter olarak verelim.

StudentController içerisindeki Get metodunda sırasıyla işlemlerimizi uygulayalım. _memoryCathe.Set(key, value, cacheOptions) metodu 3 tane parametre alıyor. cacheOptions parametresi de 2 tane değer alıyor. 

Bunlar;

AbsoluteExpiration: Cache expire süresi

Priority: Memory şiştiğinde cache objelerini hangi öncelikte silinecek.

 

 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
 using InMemoryCatchKullanimi.Domain;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Caching.Memory;
 using System;
 using System.Collections.Generic;
 namespace InMemoryCatchKullanimi.Controllers
 {
     [Route("api/[controller]")]
     [ApiController]
     public class StudentController : ControllerBase
     {
         private readonly IMemoryCache _memoryCache;
         public StudentController(IMemoryCache memoryCache)
         {
             this._memoryCache = memoryCache;
         }
         [HttpGet]
         public IEnumerable Get()
         {
             const string cacheKey = "studentListKey";
             if (!_memoryCache.TryGetValue(cacheKey, out List response))
             {
                 response = new List { new Student { Id = Guid.NewGuid(), Name = "ismail kaşan" }, new Student { Id = Guid.NewGuid(), Name = "serkan ulukoca" } };
                 var cacheExpirationOptions = new MemoryCacheEntryOptions
                 {
                     AbsoluteExpiration = DateTime.Now.AddMinutes(5),
                     Priority = CacheItemPriority.Normal
                 };
                 _memoryCache.Set(cacheKey, response, cacheExpirationOptions);
             }
             return response;
         }
     }
 }

 

Gelen ilk request için cache’de o key’e ait bir nesne olmadığından ilk request source’a gidip(bir repository yada service layer olabilir) bir veri alınır. Sonra bu veriye 5 dakikalık bir expire süresi set edilerek cache’e atılır. Artık ondan sonraki bütün request’ler 5 dakika boyunca source’a gitmeden response’u cache’den eturn edecektir. Expire süresi dolduğunda ise ilgili key ve obje cache’den silinecektir.

Set, Get yapabildiğimiz gibi Remove işlemide yapabiliriz. Bunun için cacheKey değerini parametre olarak Remove metoduna verip call yapmak yeterli.

 

1
_memoryCache.Remove(cacheKey);

 

CacheItemPriority enum’ı içerisinde Low, Normal, High, NeverRemove değerleri vardır. CachedObject Priority değerine göre memory de yer açmak için sırayla silinir. Memory’den otomatik silme işlemi yapıldığında bunun bilgisini bize iletmesini sağlayan bir callback handler metodunu aşağıdaki gibi options’a register edebiliriz ve silme işlemi yapılırken bu metot tetiklenerek bize haber verir. 


1
2
3
4
5
6
 cacheExpirationOptions.RegisterPostEvictionCallback(callback: EvictionCallback, state: this);

 private static void EvictionCallback(object key, object value,EvictionReason reason, object state)
 {
             var message = $"Entry was evicted. Reason: {reason}.";          
 }

 

Server-side bir uygulama için cache olmazsa özelliklerden biri haline gelmiştir. Asp.Net core’da da In-Memory Cache ve Distributed Cache işlemleri yapmamızı sağlayan servisler bulunmaktadır. Bu yazımızda basitçe In-Memory Cache özelliğini projemize nasıl entegre edeceğimize baktık. Umarım faydalı olmuştur.

Yararlanılan kaynaklar:

 Kaynak Kodu

http://www.canertosuner.com/post/asp-net-core-in-memory-cache 

 

 

C#'ta JSON Kullanımı

 

C#'ta JSON Kullanımı

JSON Nedir ?

JSON (JavaScript Object Notation) hafif bir veri değişim formatıdır.

  • İnsanların veriyi okuması ve yazması kolaydır.
  • Makinelerin ayrıştırması ve oluşturması kolaydır.
  • JavaScript Programlama Dili, ECMA-262 alt kümesini temel alır.
  • JSON, tamamen dilden bağımsız olarak veri taşıma formatıdır.
  • C ++, C #, Java, JavaScript, Perl, Python gibi bütün dillerde kullanılır.
  • Bu özellikler JSON’u ideal bir veri değişimi dili yapar.

Aşağıda örnek bir JSON veri yapısı bulunmaktadır.

1
2
3
4
5
"employees":[
    {"firstName":"John", "lastName":"Doe"}, 
    {"firstName":"Anna", "lastName":"Smith"}, 
    {"firstName":"Peter", "lastName":"Jones"}
] 

 C# ile JSON Kullanımı

C# programlama dilinde, JSON kullanımı oldukça yaygındır ve genellikle web servisleri ile iletişim kurmak için kullanılır. JSON, verileri kolayca okunabilir ve anlaşılabilir bir formatta temsil eder.

JSON verilerini C# programında kullanmak için, öncelikle Newtonsoft.Json paketinin projenize eklenmesi gerekmektedir. Asp.Net Core’da default olarak SDK nin içinde geliyor. Eğer projenizde yok ise Nuget üzerinden indirebilirsiniz. Bu paket, JSON verilerini C# nesnelerine dönüştürmek için kullanılır.

JSON verilerini C# nesnelerine dönüştürmek için, JsonConvert sınıfının DeserializeObject() metodunu kullanabilirsiniz. Bu metod, bir JSON veri dizisini C# nesnesine dönüştürür. Aşağıdaki örnek, bir JSON veri dizisini C# nesnesine dönüştürmektedir:

Öncelikle C# tarafındaki Member adlı sınıfı oluşturuyorum.

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

namespace DependencyInjection.Domain
{
    public class Member
    {      
        public string Name { get; set; }
        public string LastName { get; set; }
    }
}

C# ta kullanabilmek için öncelikle Newtonsoft.Json namespace’nin projenizde ekli olması gerekiyor. Şuan versiyon olarak 12.0.2 mevcut ama kendini sürekli geliştiren bir kütüphanedir. Newtonsoft hakkında detaylı bilgiye buradan erişebilirsiniz.

Örnekte Member tipinden oluşan listeyi JSON dizisine çevirelim.

 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
using System.Collections.Generic;
using System.Linq;
using DependencyInjection.Domain;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;

namespace DependencyInjection.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class OrnekJsonController : ControllerBase
    {
        // GET api/values
        [HttpGet]
        public ActionResult<string> Get()
        {
            List<Member> liste = new List<Member>
            {
                new Member { Name= "John", LastName= "Doe" },
                new Member { Name = "Anna", LastName = "Smith" },
                new Member { Name = "Peter", LastName = "Jones" }
            };
            string json = JsonConvert.SerializeObject(liste);
            return json;
        }      
    }
}

 Get methoduna istek attığımızda JSON dizisine verilerimizin değiştiğini göreceğiz.

C# ile JSON Verilerini Okumak

Öncelikle JSON formatındaki bir string veriyi Member tipinden oluşan bir listeye çevirelim. Kodlar aşağıdaki gibidir.  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System.Collections.Generic;
using System.Linq;
using DependencyInjection.Domain;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;

namespace DependencyInjection.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class OrnekJsonController : ControllerBase
    {
        // GET api/values
        [HttpGet("GetOlustur")]
        public ActionResult<IEnumerable<Member>> GetOlustur()
        {
            string json = @"[{""Name"":""John"",""LastName"":""Doe""},{""Name"":""Anna"",""LastName"":""Smith""},{""Name"":""Peter"",""LastName"":""Jones""}]"
            var liste = (List<Member>)JsonConvert.DeserializeObject(json, typeof(List<Member>));
            return liste.ToList();
        }
    }
}

 Örnek metoda istek attığımızda çıktımız aşağıdaki gibidir.


 Umarım faydalı olmuştur.

Entity Framework Transaction Kullanımı

 

Entity Framework Transaction Kullanımı

Entity Framework, .NET tabanlı bir ORM (Object-Relational Mapping) aracıdır ve bir veritabanına erişim sağlamak için kullanılır. Entity Framework ile birlikte, veritabanı işlemlerini gerçekleştirmek için transaction (işlem) başlatılır.

Transaction, bir ya da birden fazla veritabanı işleminin (örneğin, ekleme, silme, güncelleme) tek bir mantıksal işlem olarak çalıştırılmasına izin veren bir yapıdır. İşlem sırasında herhangi bir hata oluşursa, işlem geri alınarak başlangıç durumuna döndürülür. Bu, veritabanı bütünlüğünü korumak için oldukça önemlidir.

Entity Framework ile transaction kullanmak için, DbContext sınıfının Database.BeginTransaction() metodu kullanılır. Bu metot, veritabanı işlemlerini başlatır ve geri alınabilir bir transaction nesnesi döndürür. Ardından, işlemler gerçekleştirilir ve işlem başarılı bir şekilde tamamlandığında, transaction.Commit() metodu kullanılarak işlem onaylanır. Hata oluşması durumunda ise, transaction.Rollback() metodu kullanılarak işlem geri alınır.

Yoğun bir şekilde veritabanı ile işlem yapıyorsanız, verilerin tutarlılığı açısından transaction kullanımı olmazsa olmazdır. Çoğu zaman önemsenmez ama production ortamında verilerin tutarsız bir şekilde kaydedilmeye başlandığında başınız epeyce ağrıyacaktır.

Örnek:

Şimdi şöyle bir senaryo düşünelim. Veri tabanında 2 tane tablomuz olsun. Bu tablolardan biri Kullanici tablosu olsun, diğeri de Firma tablosu olsun. Yani her firmanın kullanıcıları bu Kullanici tablosunda tutulsun. Dolayısıyla Firma ve Kullanici tablosu arasında bire-çok ilişkisi var.

Bu senaryoda bir tane metodunuz olsun. Bu metod önce gidip firma ekliyor. Sonrada eklediği firmaya kullanıcı ekliyor. Ama firmayı ekledikten sonra kullanıcı eklerken hataya düştü diyelim. Sonuç itibarı ile firma var ama kullanıcılar eklenmedi.

İşte böyle senaryolarda bütün işlemler bitirilmeden kayıt işlemlerini kontrol edebileceğimiz yada geri çekebileceğimiz bir yapı mevcut. Bu yapıya SQL Transaction deniyor.

Transaction Nasıl Kullanılır?

Transection objesi System.Data.Entity namespace’in altında bulunuyor. Aşagıdaki metoda bakarsanız biraz fikriniz oluşabilir. 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
public JsonResult AxDepoHareket(int[] TABLEID, int BOLMEID)
{
    var trans = db.Database.BeginTransaction();
    try
    {
        foreach (int item in TABLEID)
        {
            var guncelle = db.TBLSTOKHAREKET.Find(item);
            guncelle.BOLMEID = BOLMEID;
            db.SaveChanges();
         }
         trans.Commit();
         return Json(new AjaxResult(true, 0, "Başarılı!", null));
     }
     catch (Exception ex)
     {
         trans.Rollback();
         Log.ExceptionLogla(ex, this.ControllerContext);
         return Json(new AjaxResult(true, 0, "Başarısız!", null));
      }
}

 Örnek koda bakıldığında metod BeginTransaction() ile başlayıp transaction açmış.

1
var trans = db.Database.BeginTransaction();

Veritabanı işlemleri bitince SaveChanges() çağırmasına rağmen Commit() çağrılmadan değişiklikler veritabanına yansımıyor taki trans.Commit() çağrılana kadar.

1
trans.Commit();

 Eğer hataya düşerse Rollback() ile yaptığı tüm işlemleri geri çekiyor.

1
trans.Rollback();

 Umarım faydalı olmuştur.

Yararlanılan kaynaklar:

Entity Framework Üzerinde TransactionScope Kullanımı 

Dependency Injection Nedir ?

 

Dependency Injection Nedir ?

Dependency injection (bağımlılık enjeksiyonu), SOLID prensiplerinden sonuncu olan Dependency Inversion prensibini uygulayan bir design pattern’dir. Bu pattern, bir bileşenin diğer bileşenlere olan bağımlılıklarını doğrudan tanımlamak yerine, dışarıdan gelen bir arayüzle bu bağımlılıkları enjekte etmek yoluyla sağlar.

Bu pattern, bir uygulamanın kodunun daha esnek, bakımı daha kolay ve test edilebilir olmasını sağlar. Bağımlılık enjeksiyonu sayesinde, bir bileşenin içinde kullanılan diğer bileşenlerin kodu değiştirilmeden, bileşenin davranışı ve işlevselliği değiştirilebilir veya farklı bir bileşenle değiştirilebilir.

Bağımlılık enjeksiyonu, birçok programlama dilinde ve framework’te kullanılabilir ve özellikle büyük ve karmaşık uygulamalar için önemlidir. Bu teknik, yazılımın kalitesini artırırken, uygulamanın tasarımını daha sade ve anlaşılır hale getirir.

Asp.Net Core’da Dependency Injection built-in olarak gelmektedir. Bununla ilgili basit bir örnek yaparak nasıl kullanıldığını göstermek istiyorum.

Örnek Proje:

Aşağıdaki gibi Asp.Net Core’da Web Api olarak yazılmış bir projemiz olsun ve projemiz bize Student nesnesi üstünde işlemler yapıp sonuç döndürsün. Proje içerisinde Repository ve Service katmanları için kullandığımız interface’leri container’a register edelim ve kullanalım. İlk olarak domain objemizi aşağıdaki gibi yaratalım.  

1
2
3
4
5
6
7
8
namespace DependencyInjection.Domain
 {
     public class Student
     {
         public Guid Id { get; set; }
         public string Name { get; set; }
     }
 } 

Sonrasında yukarıda oluşturduğumuz Student için IStudentRepository interface ve StudyRepository Class’ını oluşturalım.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
namespace DependencyInjection.Repository
 {
    public interface IStudentRepository
     {
         IEnumerable GetAll();
     }
     public class StudentRepository : IStudentRepository
     {
         public IEnumerable GetAll()
         {
             return new List
             {
                 new Student { Id = Guid.NewGuid(), Name = "Student-1" },
                 new Student {  Id = Guid.NewGuid(), Name = "Student-2" }
             };
         }
     }   
 }

Yukarıda oluşturduğumuz IStudentRepository.cs interface’i aşağıda tanımlayacağımız StudentService.cs sınıfına constructor-injected parametre olarak vereceğiz.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
namespace DependencyInjection.Services
{
  public  interface IStudentService
    {
        IEnumerable GetAllStudents();
    }    
    public class StudentService:IStudentService 
    { 
        private readonly IStudentRepository _studentRepository;         
        public StudentService(IStudentRepository studentRepository) 
        { 
            this._studentRepository = studentRepository; 
        } 
        public IEnumerable GetAllStudents() 
        { 
            return this._studentRepository.GetAll(); 
        } 
    } 
}

Yukarıda kullandığımız StudentRepository ve StudentService nesnelerini Container’a implementasyonlarını belirterek register etmemiz gerekiyor. Bunun için Startup.cs’de proje ilk run edildiğinde ilgili kullanılan bağımlılıkları register edeceğiz. Startup.cs de bulunan ConfigureServices adlı metot register işlemlerini yapmak için default gelen bir metottur. Aşağıdaki gibi tanımlamalarımızı yapiyoruz.

 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
namespace DependencyInjection
 {
     public class Startup
     {
         public Startup(IConfiguration configuration)
         {
             Configuration = configuration;
         }
         public IConfiguration Configuration { get; }
         public void ConfigureServices(IServiceCollection services)
         {
             services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
             services.AddScoped<IStudentRepository,StudentRepository>();
             services.AddScoped<IStudentService,StudentService>();
         }
         public void Configure(IApplicationBuilder app, IHostingEnvironment env)
         {
             if (env.IsDevelopment())
             {
                 app.UseDeveloperExceptionPage();
             }
             else
             {               
                 app.UseHsts();
             }
             app.UseHttpsRedirection();
             app.UseMvc();
         }
     }
 }

 

Container Register

Asp.Net Core’da default gelen DI container’a, class ve servisleri default gelen 3 farklı extension metod ile yapabiliriz.

Bunlar:

  • AddScoped()
  • AddTransient()
  • AddSingleton()

AddScoped(): metodu ile register edilen nesneler her request scop’unda sadece bir instance oluşturulur.

AddTransient(): metodu ile register edilen nesneler her çağrıldığında yeni bir instance oluşturulur.

AddSingleton(): metodu ile register edilen nesneler uygulama başlarken sadece bir tane instance oluşur.

Yukarıda görüldüğü üzere IStudentRepository ve IStudentService arayüzlerinin implementasyonlarını belirterek AddScoped() metodunu kullanarak register ettik. Buradaki AddScoped metodu bize Api ye gelen her bir istek için oluşturulacak nesneden sadece bir tane instance oluşturulacağının garantisini veriyor.

Controller Tarafında Kullanma

Aşağıdaki gibi StudentController içerisinde Container’da register edilen instance’ları kullanarak geriye StudentList geri dönderiyoruz.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
namespace DependencyInjection.Controllers
 {
     [Route("api/[controller]")]
     [ApiController]
     public class StudentController : ControllerBase
     {
         private readonly IStudentService _studentService;
         public StudentController(IStudentService cityService)
         {
             this._studentService = cityService;
         }
         [HttpGet]
         public IEnumerable GetStudentList()
         {
             return this._studentService.GetAllStudents();
         }
     }
 }

Asp.Net Core için Dependency Injection kullanım örneği bu kadardır. Burada constructor-injected olarak gerekli nesneleri üretmiş olduk. Yukarıdaki end-point’e istek atarak geriye “Student-1” ve “Student-2” öğrencilerinin bulunduğu diziyi dönüyor.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
[
    {
        "id": "8bf4a343-347c-4557-aa70-52691629f1a7",
        "name": "Student-1"
    },
    {
        "id": "e760844b-53a2-44c5-87a9-14dcbb59d0a4",
        "name": "Student-2"
    }
]

 Umarım faydalı olmuştur.

 Kaynak Kodu

Asp .Net Core Nedir?

ASP.NET Core, Microsoft tarafından geliştirilen, açık kaynaklı, ücretsiz, cross platformlu bir web uygulama framework’dür. Bu framework, Windows, macOS ve Linux dahil olmak üzere çeşitli işletim sistemlerinde çalışabilir.

ASP.NET Core, .NET Core Run-time kullanır ve modern web uygulamaları geliştirmek için bir dizi araç, kütüphane ve özellik sağlar. ASP.NET Core, web API’leri, dinamik web sayfaları, RESTful servisleri, gerçek zamanlı uygulamaları ve tek sayfalı uygulamaları gibi farklı web uygulama türlerini destekler.

ASP.NET Core, yüksek performans, ölçeklenebilirlik ve güvenlik sağlamak için tasarlanmıştır ve modüler bir yapıya sahiptir. Bu çerçeve, geliştiricilerin ihtiyaçlarına göre yapılandırılabilir ve özelleştirilebilir, böylece farklı proje gereksinimlerini karşılamak için uygun bir çözüm sunar.

ASP.NET Core, .NET Core’un bir parçası olarak geliştirilmiştir ve zaman içinde birçok kütüphane eklenmiştir. İşte ASP.NET Core’un kronolojik sıralaması:

  1. ASP.NET Core 1.0: Bu sürüm, 2016 yılında piyasaya sürüldü. Bu sürüm, web uygulamalarının çapraz platform desteği, performans iyileştirmeleri, açık kaynaklı kod yapısı ve hızlı geliştirme özellikleri ile birlikte gelir.

  2. ASP.NET Core 1.1: Bu sürüm, 2016 yılında piyasaya sürüldü ve önceki sürüme göre küçük bir güncelleme oldu. Bu sürüm, .NET Core 1.1 sürümünü destekledi ve bazı hata düzeltmeleri ve performans iyileştirmeleri içeriyordu.

  3. ASP.NET Core 2.0: Bu sürüm, 2017 yılında piyasaya sürüldü. Bu sürüm, daha fazla özellik ve iyileştirmelerle birlikte geldi. Örneğin, Razor Pages ve SignalR gibi yeni özellikler, Web API’lerinde geliştirme için yeni araçlar ve geliştirilmiş performans gibi iyileştirmeler içeriyordu.

  4. ASP.NET Core 2.1: Bu sürüm, 2018 yılında piyasaya sürüldü ve önceki sürüme göre daha fazla özellik içeriyordu. Bu sürümde geliştirme deneyimi, performans ve güvenilirlik gibi alanlarda iyileştirmeler yapılmıştı.

  5. ASP.NET Core 2.2: Bu sürüm, 2018 yılında piyasaya sürüldü ve daha fazla performans ve güvenlik iyileştirmeleri içeriyordu. Bu sürüm, daha hızlı geliştirme deneyimi için bazı araçlar da ekledi.

  6. ASP.NET Core 3.0: Bu sürüm, 2019 yılında piyasaya sürüldü. Bu sürümde, Blazor adında yeni bir web uygulama çerçevesi ve daha fazla performans iyileştirmesi yer aldı.

  7. ASP.NET Core 3.1: Bu sürüm, 2019 yılında piyasaya sürüldü ve önceki sürüme göre küçük bir güncelleme oldu. Bu sürüm, hata düzeltmeleri ve performans iyileştirmeleri içeriyordu.

  8. ASP.NET Core 5.0: Bu sürüm, 2020 yılında piyasaya sürüldü ve .NET 5.0 sürümüne dayanıyor. Bu sürüm, performans iyileştirmeleri, geliştirme deneyimi iyileştirmeleri ve bazı yeni özellikler içeriyordu.

  9. ASP.NET Core 6.0: Bu sürüm, 2021 yılında piyasaya sürüldü.

 

Temel özellileri

  1. Cross platform desteği: ASP.NET Core, Windows, Linux ve macOS dahil olmak üzere birçok işletim sistemi üzerinde çalışabilir.

  2. Yüksek performans: ASP.NET Core, performansı artırmak için birçok özellik içerir. Örneğin, hafif bir yapıya sahip olduğundan daha hızlı başlatılır ve daha az bellek tüketir.

  3. Modüler yapı: ASP.NET Core, uygulamanızda kullanmak istediğiniz özellikleri seçmenize olanak tanır. Bu modüler yapı, uygulama ölçeklendirme ve bakımını kolaylaştırır.

  4. Açık kaynak kodlu: ASP.NET Core, açık kaynak kodlu bir yapıya sahiptir. Bu, geliştiricilerin uygulamalarını özelleştirmelerini ve kaynak kodlarını incelemelerini kolaylaştırır. Microsoft tarafından Github üzerinde, kaynak kodları açık bir şekilde MIT ve Apache 2 lisanslarına sahip olarak yer almaktadır. Dileyen yazılımcılar kaynak kodlarını inceleyebilir, iyileştirme önerilerinde bulunabilirler.

  5. Geliştirme deneyimi: ASP.NET Core, geliştirme sürecini hızlandırmak için birçok araç ve özellik sunar. Örneğin, Visual Studio Code ve Visual Studio gibi geliştirme ortamlarına entegre edilebilir.

  6. Güvenlik: ASP.NET Core, uygulamanızın güvenliğini sağlamak için birçok özellik sunar. Örneğin, kimlik doğrulama ve yetkilendirme, veri koruması ve CORS (Kaynaklar Arası Kaynak Paylaşımı) gibi özellikler bu konuda yardımcı olur.

  7. Esneklik: ASP.NET Core, farklı protokoller ve veri depolama teknolojileri ile çalışabilir. Örneğin, SQL Server, MySQL, PostgreSQL ve MongoDB gibi veri tabanlarına bağlanabilir.

  8. Diğer frameworklerle uyumlu: .Net Framework, Mono veya Xamarin ile geliştirilmiş diğer kütüphaneleri kolayca kullanabilirsiniz.

  9. Desteklenen Diller: .NET yerel olarak Microsoft tarafından desteklenen 11( C#, F#, VB.Net, C++, Ada, IronPython, IronRuby, JScript, PHP, Perl, Visual COBOL) programlama dilini destekler; .NET ortamına açıkça tanıtıldığı anlamına gelir. Microsoft dışı diller olan ve diğer kuruluşlar tarafından desteklenen ek 50 programlama dili daha vardır.

  10. İndirme ve Kurulum: .Net Core’u kullandığınız işletim sistemine göre Microsoft'un sitesinden indirebilirsiniz.
Bu özellikler, ASP.NET Core’u modern web uygulamaları geliştirmek için popüler bir seçim haline getirmektedir.

.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ığı ...