Physical Address
304 North Cardinal St.
Dorchester Center, MA 02124
Prerequisites and setup
ASP.NET Core ile Web API’ler oluşturmak için başlamadan önce bazı ön koşulların ve kurulum adımlarının bilinmesi gerekmektedir. İşte bu ön koşullar ve kurulum adımları:
Ön Koşullar:
.NET Core SDK: ASP.NET Core uygulamaları geliştirmek için .NET Core SDK’sını indirip yüklemelisiniz. .NET Core SDK’sı, .NET Core’un geliştirme ve çalıştırma için gereken tüm araçları içerir.
IDE (Integrated Development Environment): Geliştirme için bir IDE seçmelisiniz. Genellikle Visual Studio Code, Visual Studio gibi yaygın olarak kullanılan IDE’ler tercih edilir.
Temel Web Teknolojileri Bilgisi: Web API geliştirmek için HTML, CSS, HTTP ve temel HTTP yöntemleri (GET, POST, PUT, DELETE) gibi web teknolojileri hakkında temel bilgi sahibi olmanız faydalı olacaktır.
Kurulum Adımları:
.NET Core SDK’nın İndirilip Yüklenmesi: .NET Core SDK’sını Microsoft’un resmi sitesinden indirebilirsiniz. İndirme işlemi ve kurulum adımları oldukça basittir ve platformunuza uygun olanı seçerek kurulumu gerçekleştirebilirsiniz.
IDE Seçimi ve Kurulumu: Visual Studio Code gibi bir IDE kullanacaksanız, Visual Studio Code’u indirip yükleyebilirsiniz. Visual Studio gibi entegre bir geliştirme ortamını tercih ediyorsanız, Visual Studio 2019 veya sonraki sürümlerini kullanabilirsiniz.
Projeyi Oluşturma: Bir terminal veya komut istemcisinde şu komutu kullanarak yeni bir ASP.NET Core Web API projesi oluşturabilirsiniz:
dotnet new webapi -n MyWebApi
Bu komut, “MyWebApi” adında bir ASP.NET Core Web API projesi oluşturur.
Proje Yapısının Anlaşılması: Oluşturulan proje yapısını anlamak önemlidir. Bir ASP.NET Core Web API projesi genellikle Controllers, Models ve Startup gibi klasörleri içerir. Controllers klasörü, API kontrolcülerinin bulunduğu yerdir. Models klasörü, veri modellerini içerir. Startup.cs dosyası, uygulamanın başlangıç noktasıdır ve uygulamanın yapılandırmasını sağlar.
Projenin Başlatılması: Projenizi başlatmak için terminalde veya IDE’nin kendi terminalinde aşağıdaki komutu kullanabilirsiniz:
dotnet run
Bu komut, yerel sunucunuzda Web API’nizi başlatacaktır. Varsayılan olarak, Web API’niz https://localhost:5001 adresinde çalışacaktır.
Tarayıcıda Test Etme: Web API’nizi tarayıcıda veya bir API test aracıyla test edebilirsiniz. Varsayılan olarak, /WeatherForecast endpoint’ine bir HTTP GET isteği göndererek API’nizi test edebilirsiniz.
GET https://localhost:5001/WeatherForecast
Bu adımları takip ederek, ASP.NET Core kullanarak Web API geliştirmeye başlayabilirsiniz. Başlangıç seviyesinde bir Web API örneği için verilen adımlar size yardımcı olacaktır. Daha karmaşık senaryolar için ASP.NET Core dokümantasyonuna ve çevrimiçi kaynaklara başvurabilirsiniz.
“Hello World”, API style
“Hello World” uygulaması, bir programlama dilinde veya teknolojide yeni başlayanlar için tipik olarak kullanılan basit bir örnektir. ASP.NET Core Web API’de “Hello World” örneği oluşturmak oldukça basittir.
API Style
ASP.NET Core’da API’ler oluştururken, genellikle RESTful API tarzını benimseriz. RESTful API’ler, kaynakları temsil eden URL’ler ve HTTP yöntemlerini (GET, POST, PUT, DELETE) kullanarak bu kaynaklar üzerinde işlemler yapmayı sağlar. API’ler genellikle JSON veya XML gibi veri formatlarını kullanarak veri alışverişi yaparlar.
Örnek Uygulama Oluşturma
Aşağıda, “Hello World” API’sini oluşturmak için adım adım bir örnek verilmiştir:
Proje Oluşturma: Öncelikle, bir ASP.NET Core Web API projesi oluşturun. Bu adım için terminal veya komut istemcisinde şu komutu kullanabilirsiniz:
dotnet new webapi -n HelloWorldApi
API Controller’ın Oluşturulması: Oluşturulan projede Controllers klasörü altında yeni bir controller dosyası oluşturun. Örneğin, HelloController.cs adında bir dosya oluşturun ve aşağıdaki kodu içine ekleyin:
using Microsoft.AspNetCore.Mvc;
namespace HelloWorldApi.Controllers
{
[ApiController]
[Route("[controller]")]
public class HelloController : ControllerBase
{
[HttpGet]
public IActionResult Get()
{
return Ok("Hello World");
}
}
}
Bu controller, /hello endpoint’ine bir HTTP GET isteği geldiğinde “Hello World” mesajını dönecek şekilde yapılandırılmıştır.
Projenin Başlatılması: Terminalde veya IDE’nin terminalinde aşağıdaki komutu kullanarak projeyi başlatın:
dotnet run
API’yi Test Etme: Bir web tarayıcısı veya API test aracı kullanarak https://localhost:5001/hello adresine bir HTTP GET isteği göndererek API’yi test edebilirsiniz. JSON veya XML formatında “Hello World” mesajını almanız gerekir.
Bu örnekle, basit bir “Hello World” API’sini ASP.NET Core kullanarak nasıl oluşturabileceğinizi gösterildi. RESTful API tasarımı için standart HTTP yöntemlerini kullanarak kaynaklar üzerinde işlemler gerçekleştiren API’ler oluşturmak önemlidir. Bu şekilde, API’lerinizin genel kabul görmüş standartlara uygun ve kolayca anlaşılabilir olmasını sağlayabilirsiniz.
Minimal APIs
ASP.NET Core’da Minimal API, geleneksel kontrolcü tabanlı bir yapı yerine daha hafif, daha basit ve daha okunabilir bir API geliştirme yaklaşımı sunar. Bu yaklaşım, basit API’lerin hızlı bir şekilde oluşturulması ve yönetilmesi için idealdir.
Minimal API Nedir?
Minimal API’ler, ASP.NET Core 6.0’da tanıtılan yeni bir özelliktir. Bu özellik, küçük veya orta ölçekli API’ler oluştururken gereksiz karmaşıklıklardan kaçınmanıza olanak tanır. Geleneksel kontrolcü tabanlı yapı yerine, tek bir dosyada API’yi tanımlamanıza olanak tanır. Bu, kodun daha net ve anlaşılır olmasını sağlar.
Bir Minimal API Oluşturma
Öncelikle, ASP.NET Core uygulamanızı oluşturun. Bu işlemi Visual Studio veya .NET CLI kullanarak yapabilirsiniz. Ardından, Minimal API’yi kullanarak basit bir örnek oluşturalım.
Proje Oluşturma: İlk olarak, bir konsol uygulaması projesi oluşturun:
dotnet new console -n MinimalApiDemo
cd MinimalApiDemo
Gerekli Paketleri Yükleme: Minimal API’leri kullanmak için gerekli paketleri projeye ekleyin:
dotnet add package Microsoft.AspNetCore.App
Minimal API Tanımlama: Program.cs dosyasını açın ve Minimal API’yi tanımlayın:
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => "Hello, Minimal API!");
app.Run();
Yukarıdaki kodda, “/” yoluna gelen GET isteğine yanıt olarak “Hello, Minimal API!” metnini döndüren bir endpoint tanımladık.
Uygulamayı Çalıştırma: Projeyi çalıştırın ve tarayıcınızdan veya bir API test aracından http://localhost:5000 adresine giderek sonucu gözlemleyin:
dotnet run
Özet
Bu makalede, ASP.NET Core’da Minimal API’leri kullanarak basit bir API oluşturmayı öğrendiniz. Minimal API’ler, küçük veya orta ölçekli projeler için gereksiz karmaşıklıklardan kaçınmanıza olanak tanırken, kodun daha okunabilir ve yönetilebilir olmasını sağlar. Bu yaklaşım, hızlı prototipleme veya küçük ölçekli projeler için özellikle uygun olabilir.
HTTP in a nutshell
HTTP (Hypertext Transfer Protocol), web üzerinde bilgi alışverişi için kullanılan bir iletişim protokolüdür. ASP.NET Core gibi birçok web uygulama çerçevesi, HTTP üzerinde çalışır. Bu nedenle, ASP.NET Core API’leri geliştirirken HTTP’nin temel prensiplerini anlamak önemlidir.
HTTP Nedir?
HTTP, bir istemci ve bir sunucu arasında iletişim kurmak için kullanılan bir protokoldür. İstemci, bir istek (request) gönderir ve sunucu, bir yanıt (response) döner. İstek ve yanıt, başlık (header) ve gövde (body) olmak üzere iki ana bölümden oluşur.
HTTP İstekleri (Requests)
HTTP isteği, bir istemci tarafından sunucuya belirli bir eylem için gönderilen iletiyi ifade eder. Bir HTTP isteği genellikle şu bileşenlerden oluşur:
HTTP Yanıtları (Responses)
HTTP yanıtı, sunucunun bir isteğe nasıl yanıt verdiğini ifade eder. Bir HTTP yanıtı genellikle şu bileşenlerden oluşur:
ASP.NET Core ve HTTP
ASP.NET Core, HTTP isteklerini işlemek için güçlü bir altyapı sunar. Bir ASP.NET Core API’si oluştururken, genellikle HTTP metotlarına (GET, POST, PUT, DELETE vb.) karşılık gelen işlemleri yönlendiren işlevler (action) tanımlarsınız. Örneğin:
[HttpGet]
public IActionResult Get()
{
// Bir kaynağı getir
}
[HttpPost]
public IActionResult Post([FromBody] MyModel model)
{
// Yeni bir kaynak oluştur
}
[HttpPut("{id}")]
public IActionResult Put(int id, [FromBody] MyModel model)
{
// Varolan bir kaynağı güncelle
}
[HttpDelete("{id}")]
public IActionResult Delete(int id)
{
// Bir kaynağı sil
}
Bu işlevler, belirli bir HTTP isteği aldıklarında çalışır ve uygun yanıtları döndürürler. ASP.NET Core, bu işlemleri işlemek için geleneksel kontrolcüler veya Minimal API’ler gibi farklı yöntemler sunar.
Özet
Bu makalede, HTTP’nin temel kavramlarını ve ASP.NET Core ile nasıl ilişkilendirildiğini derinlemesine inceledik. HTTP istekleri ve yanıtları, web uygulamalarının temelini oluşturur ve ASP.NET Core gibi çerçeveler, bu iletişimi işlemek için güçlü bir altyapı sunar. Anlamak ve etkili bir şekilde kullanmak, güçlü ve sağlam web uygulamaları oluşturmanıza yardımcı olacaktır.
REST basics
REST (Representational State Transfer), dağıtılmış sistemler arasında kaynakların (resource) temsili durumunun (state) aktarımı için bir mimari stilidir. REST, web servislerinin tasarımında yaygın olarak kullanılan bir yaklaşımdır ve API’lerin oluşturulması için popüler bir tercihtir.
REST Temelleri
ASP.NET Core ve RESTful API’ler
ASP.NET Core, RESTful API’ler oluşturmak için güçlü bir altyapı sunar. Bir ASP.NET Core uygulamasında, HTTP metotlarına belirli işlevler (action) atanmış kontrolcüler veya Minimal API’ler aracılığıyla kaynaklar üzerinde işlem yapılır. Örneğin:
[Route("api/[controller]")]
[ApiController]
public class UsersController : ControllerBase
{
private readonly IUserService _userService;
public UsersController(IUserService userService)
{
_userService = userService;
}
[HttpGet]
public IActionResult GetAllUsers()
{
var users = _userService.GetAllUsers();
return Ok(users);
}
[HttpGet("{id}")]
public IActionResult GetUserById(int id)
{
var user = _userService.GetUserById(id);
if (user == null)
{
return NotFound();
}
return Ok(user);
}
[HttpPost]
public IActionResult CreateUser([FromBody] User user)
{
_userService.CreateUser(user);
return CreatedAtAction(nameof(GetUserById), new { id = user.Id }, user);
}
[HttpPut("{id}")]
public IActionResult UpdateUser(int id, [FromBody] User user)
{
_userService.UpdateUser(id, user);
return NoContent();
}
[HttpDelete("{id}")]
public IActionResult DeleteUser(int id)
{
_userService.DeleteUser(id);
return NoContent();
}
}
Yukarıdaki örnekte, UsersController adlı bir kontrolcü, kullanıcılarla ilgili işlemleri gerçekleştirir. HTTP GET, POST, PUT ve DELETE isteklerini işlemek için uygun action’lar tanımlanmıştır. Bu action’lar, belirli HTTP istekleri aldıklarında çalışır ve uygun HTTP yanıtlarını döndürürler.
Özet
Bu makalede, REST’in temellerini ve ASP.NET Core’da RESTful API’ler oluşturmanın nasıl yapıldığını derinlemesine inceledik. REST, kaynak odaklı bir mimari stili olduğu için API tasarımında önemli bir rol oynar. ASP.NET Core, RESTful API’lerin oluşturulması için güçlü bir altyapı sunar ve HTTP metotlarına atanmış action’lar aracılığıyla bu API’lerin işlevselliğini sağlar. Bu prensipleri anlamak, etkili ve sağlam API’lerin oluşturulmasına yardımcı olur.
API design basics
API tasarımı, bir uygulamanın dış dünyayla iletişim kurması için kullanılan arayüzün planlanması ve oluşturulmasıdır. Başarılı bir API tasarımı, kullanıcı dostu, tutarlı, güvenilir ve ölçeklenebilir olmalıdır.
API Tasarımı Temelleri
ASP.NET Core’da API Tasarımı
ASP.NET Core, etkili bir API tasarımı için bir dizi araç ve yöntem sunar. API tasarımında dikkate alınması gereken bazı önemli noktalar şunlardır:
Örnek Kod: Basit Bir ASP.NET Core API
Aşağıda, bir ASP.NET Core API’nin basit bir örneğini gösteren temel bir kod örneği bulunmaktadır:
[Route("api/[controller]")]
[ApiController]
public class ProductsController : ControllerBase
{
private readonly IProductService _productService;
public ProductsController(IProductService productService)
{
_productService = productService;
}
[HttpGet]
public IActionResult GetAllProducts()
{
var products = _productService.GetAllProducts();
return Ok(products);
}
[HttpGet("{id}")]
public IActionResult GetProductById(int id)
{
var product = _productService.GetProductById(id);
if (product == null)
{
return NotFound();
}
return Ok(product);
}
[HttpPost]
public IActionResult CreateProduct([FromBody] Product product)
{
_productService.CreateProduct(product);
return CreatedAtAction(nameof(GetProductById), new { id = product.Id }, product);
}
[HttpPut("{id}")]
public IActionResult UpdateProduct(int id, [FromBody] Product product)
{
_productService.UpdateProduct(id, product);
return NoContent();
}
[HttpDelete("{id}")]
public IActionResult DeleteProduct(int id)
{
_productService.DeleteProduct(id);
return NoContent();
}
}
Yukarıdaki örnek, “Products” adlı bir API kontrolcüsüdür. Bu kontrolcü, ürünlerle ilgili temel CRUD (Create, Read, Update, Delete) işlemlerini gerçekleştirir. Her action, belirli bir HTTP isteğine yanıt olarak çalışır ve uygun HTTP yanıtlarını döndürür.
Özet
Bu makalede, API tasarımının temellerini ve ASP.NET Core’da API tasarımının nasıl gerçekleştirileceğini derinlemesine inceledik. Başarılı bir API tasarımı, kullanıcı dostu, tutarlı, güvenilir ve ölçeklenebilir olmalıdır. ASP.NET Core, bu hedeflere ulaşmak için güçlü bir altyapı sağlar ve etkili bir API oluşturmanıza yardımcı olabilir.
Tools for API testing
API’lerin test edilmesi, geliştirme sürecinin önemli bir parçasıdır ve doğru sonuçların sağlanması için gereklidir. ASP.NET Core ile geliştirilen web API’lerin test edilmesi için bir dizi araç ve yaklaşım vardır.
1. Postman
Postman, API’lerin test edilmesi, belgelenmesi ve paylaşılması için popüler bir platformdur. Postman kullanarak API isteklerini kolayca oluşturabilir, gönderebilir ve yanıtları inceleyebilirsiniz. Ayrıca, test senaryolarını oluşturabilir ve otomatikleştirebilirsiniz.
2. Swagger/OpenAPI
Swagger/OpenAPI belgeleri, API’nin yapısal tanımını sağlar ve bu tanımı kullanarak API istekleri oluşturabilirsiniz. ASP.NET Core web API’leri genellikle Swagger/OpenAPI belgeleriyle birlikte gelir. Swagger UI, bu belgeleri görsel olarak sunar ve API isteklerini doğrudan denemenizi sağlar.
3. Visual Studio Test Explorer
Visual Studio’nun Test Explorer özelliği, birim testlerin ve entegrasyon testlerin çalıştırılması için kullanılabilir. ASP.NET Core API’lerini test etmek için xUnit, NUnit veya MSTest gibi birim test çerçeveleri kullanabilirsiniz. Bu testler, API’nin farklı işlevlerini ve senaryolarını doğrulamak için kullanılabilir.
public class ProductsControllerTests
{
[Fact]
public void GetAllProducts_ReturnsOkResult()
{
// Arrange
var controller = new ProductsController(new ProductService());
// Act
var result = controller.GetAllProducts();
// Assert
Assert.IsType<OkObjectResult>(result.Result);
}
[Fact]
public void GetProductById_ReturnsNotFoundResult_ForInvalidId()
{
// Arrange
var controller = new ProductsController(new ProductService());
var invalidId = 999;
// Act
var result = controller.GetProductById(invalidId);
// Assert
Assert.IsType<NotFoundResult>(result.Result);
}
}
4. Curl
Curl, bir komut satırı aracıdır ve HTTP isteklerini göndermek ve almak için kullanılır. API’leri test etmek için basit ve hızlı bir seçenektir, ancak daha az kullanıcı dostu bir arayüze sahiptir.
Curl ile bir GET isteği gönderme örneği:
curl -X GET "https://api.example.com/products" -H "accept: application/json"
Özet
Bu makalede, ASP.NET Core API’lerinin test edilmesi için kullanılabilecek bazı araçları ve yöntemleri derinlemesine inceledik. Postman gibi araçlarla interaktif olarak API’leri test etmek, Swagger/OpenAPI belgeleriyle API’leri keşfetmek, Visual Studio Test Explorer ile birim testlerini çalıştırmak veya basitçe Curl gibi komut satırı araçlarını kullanarak API’leri test etmek gibi çeşitli seçenekler vardır. Bu araçlar ve yöntemler, API’lerinizin doğru şekilde çalıştığından emin olmanıza ve hata ayıklama sürecini kolaylaştırmanıza yardımcı olabilir.
Retrieving Data
Controllers and actions
Controllers ve Actions, ASP.NET Core Web API’lerinde veri almanın anahtar bileşenleridir. Bir Controller, gelen HTTP isteklerini alır ve bu isteklere uygun yanıtları üretir. Actions, bu Controller sınıfındaki yöntemlerdir ve belirli bir HTTP isteği türüne (GET, POST, PUT, DELETE vb.) karşılık gelir.
Controllers
Controllers, ASP.NET Core Web API’lerinde iş mantığını içeren birimlerdir. Her Controller sınıfı, bir veya daha fazla Action yöntemi içerir. Bu Action yöntemleri, belirli bir HTTP isteği türünü işlemek için kullanılır. Bir Controller, genellikle bir veya daha fazla ilgili kaynağı temsil eder.
Örnek bir Controller sınıfı:
[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
private readonly IProductService _productService;
public ProductsController(IProductService productService)
{
_productService = productService;
}
[HttpGet]
public IActionResult GetAllProducts()
{
var products = _productService.GetAllProducts();
return Ok(products);
}
[HttpGet("{id}")]
public IActionResult GetProductById(int id)
{
var product = _productService.GetProductById(id);
if (product == null)
{
return NotFound();
}
return Ok(product);
}
[HttpPost]
public IActionResult CreateProduct([FromBody] Product product)
{
_productService.CreateProduct(product);
return CreatedAtAction(nameof(GetProductById), new { id = product.Id }, product);
}
[HttpPut("{id}")]
public IActionResult UpdateProduct(int id, [FromBody] Product product)
{
_productService.UpdateProduct(id, product);
return NoContent();
}
[HttpDelete("{id}")]
public IActionResult DeleteProduct(int id)
{
_productService.DeleteProduct(id);
return NoContent();
}
}
Yukarıdaki örnekte, ProductsController adlı bir Controller sınıfı tanımlanmıştır. Bu Controller, ürünlerle ilgili işlemleri gerçekleştirmek için kullanılır. Her Action yöntemi, belirli bir HTTP isteği türüne karşılık gelir (GET, POST, PUT, DELETE).
Actions
Actions, Controller sınıflarındaki yöntemlerdir ve belirli bir HTTP isteği türünü işlemek için kullanılır. Bir Action yöntemi, bir Controller sınıfında ilgili HTTP isteği türüne (HttpGet, HttpPost, HttpPut, HttpDelete vb.) karşılık gelen bir işlemi gerçekleştirir.
Örnek bir Action yöntemi:
[HttpGet]
public IActionResult GetAllProducts()
{
var products = _productService.GetAllProducts();
return Ok(products);
}
Yukarıdaki örnekte, GetAllProducts adlı bir Action yöntemi tanımlanmıştır. Bu yöntem, HTTP GET isteklerini işler ve tüm ürünleri döndürür.
Özet
Bu makalede, ASP.NET Core Web API’lerinde Controllers ve Actions kavramlarını derinlemesine açıkladık. Controllers, gelen HTTP isteklerini alır ve bu isteklere uygun Actions yöntemlerini çağırarak işlemleri gerçekleştirir. Actions, bir Controller sınıfındaki belirli bir HTTP isteği türünü işlemek için kullanılan yöntemlerdir. Bu kavramları anlamak, ASP.NET Core Web API’lerinin temelini oluşturur ve etkili bir API geliştirmenize yardımcı olur.
Routing basics
Routing, ASP.NET Core Web API’lerinde gelen HTTP isteklerini belirli Controller ve Action yöntemlerine yönlendiren bir mekanizmadır. Bu, istekleri belirli bir URL yapısına ve HTTP metotlarına göre işleyerek uygun iş mantığını çalıştırır.
Routing Temelleri
Rota Tanımlama: Routing, belirli bir URL yapısına karşılık gelen Controller ve Action yöntemlerini belirtmek için kullanılır. Örneğin, “/api/products” yoluna gelen bir HTTP GET isteği, ProductsController sınıfındaki bir Action yöntemine yönlendirilebilir.
Parametreler: Rotalar, değişkenlerle parametrize edilebilir. Örneğin, “/api/products/{id}” rotası, “id” adında bir parametreye sahip ve belirli bir ürünün kimliğini temsil eder.
HTTP Metotları: Routing, gelen HTTP isteğinin türüne (GET, POST, PUT, DELETE vb.) göre yönlendirme yapabilir. Her bir HTTP metodu, farklı bir Action yöntemine yönlendirilebilir.
Routing Örnekleri
Temel Rota Tanımlama:
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapGet("/api/products", async context =>
{
await context.Response.WriteAsync("GetAllProducts");
});
endpoints.MapGet("/api/products/{id}", async context =>
{
var id = context.Request.RouteValues["id"];
await context.Response.WriteAsync($"GetProductById - ProductId: {id}");
});
});
Yukarıdaki örnekte, “/api/products” ve “/api/products/{id}” rotaları için işlem tanımlanmıştır. İlk rota tüm ürünleri alırken, ikincisi belirli bir ürünü alır. “/api/products/{id}” rotası, “id” adında bir parametreye sahiptir.
Attribute Tabanlı Rota Tanımlama:
[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
[HttpGet]
public IActionResult GetAllProducts()
{
return Ok("GetAllProducts");
}
[HttpGet("{id}")]
public IActionResult GetProductById(int id)
{
return Ok($"GetProductById - ProductId: {id}");
}
}
Yukarıdaki örnekte, ProductsController sınıfı için rota tanımlamaları Attribute tabanlı olarak yapılır. [HttpGet] özniteliği, belirli bir HTTP GET isteğine karşılık gelen bir Action yöntemi belirtir. {id} placeholder’ı, bir parametreyi temsil eder.
Özet
Bu makalede, ASP.NET Core’da Routing’in temellerini derinlemesine açıkladık. Routing, gelen HTTP isteklerini belirli Controller ve Action yöntemlerine yönlendiren bir mekanizmadır. Routing, temel URL yapısı, parametreler ve HTTP metotlarına göre işleyerek uygun iş mantığını çalıştırır. Hem kod tabanlı hem de Attribute tabanlı rota tanımlama yöntemleri mevcuttur. Routing’i anlamak, ASP.NET Core Web API’lerinin temelini oluşturur ve etkili bir API geliştirmenize yardımcı olur.
Creating a data model
Veri modeli oluşturma, ASP.NET Core Web API’lerinde verileri temsil etmek için kullanılan sınıfların tasarlanmasıdır. Bu sınıflar, veritabanındaki tablolara karşılık gelir veya gelen isteklerdeki verileri taşır.
Veri Modeli Oluşturma Temelleri
Sınıf Tasarımı: Veri modeli, bir sınıf olarak tanımlanır. Bu sınıf, temsil etmek istediğiniz verilerin özelliklerini içerir. Her bir özellik, bir veritabanı sütunu veya gelen isteklerdeki bir alanı temsil eder.
Özellikler: Sınıfın özellikleri, verileri tanımlar. Özellikler genellikle sütunların veya alanların türlerini ve adlarını yansıtır.
Veri Doğrulama: Veri modeli genellikle veri doğrulama kurallarını içerir. Bu kurallar, gelen verilerin geçerliliğini sağlamak için kullanılır. Örneğin, bir alanın zorunlu olması veya belirli bir formatı takip etmesi gerekebilir.
Veri Modeli Oluşturma Örnekleri
Temel Bir Veri Modeli:
public class Product
{
public int Id { get; set; }
public string Name { get; set; }
public decimal Price { get; set; }
public DateTime CreatedAt { get; set; }
}
Yukarıdaki örnekte, Product adlı bir veri modeli tanımlanmıştır. Bu model, bir ürünün temel özelliklerini içerir: Id, Name, Price ve CreatedAt.
Veri Doğrulama ile Bir Veri Modeli:
public class User
{
public int Id { get; set; }
[Required]
[StringLength(50)]
public string Username { get; set; }
[Required]
[EmailAddress]
public string Email { get; set; }
[Phone]
public string PhoneNumber { get; set; }
}
Yukarıdaki örnekte, User adlı bir veri modeli tanımlanmıştır. Bu model, bir kullanıcının temel özelliklerini içerir: Id, Username, Email ve PhoneNumber. Username ve Email özellikleri, [Required] özniteliği ile zorunlu hale getirilmiş ve Email özelliği, EmailAddress özniteliği ile doğrulanmıştır.
İlişkisel Veri Modeli:
public class Order
{
public int Id { get; set; }
public string OrderNumber { get; set; }
public decimal TotalAmount { get; set; }
public DateTime OrderDate { get; set; }
public int UserId { get; set; }
public User User { get; set; }
}
Yukarıdaki örnekte, Order adlı bir veri modeli tanımlanmıştır. Bu model, bir siparişi temsil eder ve UserId özelliği aracılığıyla bir kullanıcıyla ilişkilendirilmiştir.
Özet
Bu makalede, ASP.NET Core Web API’lerinde veri modelleri oluşturmanın temellerini derinlemesine açıkladık. Veri modelleri, verileri temsil etmek ve taşımak için kullanılan sınıflardır. Bir veri modeli, temsil etmek istediğiniz verilerin özelliklerini içerir ve genellikle veri doğrulama kurallarını içerir. Veri modellerini oluşturmak, API’lerinizi etkili bir şekilde tasarlamanıza ve geliştirmenize yardımcı olur.
Using Entity Framework Core
Entity Framework Core (EF Core), ASP.NET Core Web API’lerinde veritabanı işlemlerini kolaylaştıran ve veritabanı etkileşimini soyutlayan bir ORM (Object-Relational Mapping) aracıdır.
Entity Framework Core Temelleri
Modelleme: Entity Framework Core ile veritabanı tablolarını C# sınıflarına eşleyebilirsiniz. Bu sınıflar, veritabanındaki tablolara karşılık gelir ve sınıfların özellikleri, tablolardaki sütunları temsil eder.
DbContext: DbContext sınıfı, EF Core’un temel bileşenidir. Bu sınıf, veritabanı bağlantısını yönetir, sorguları yürütür ve veri işlemlerini gerçekleştirir. Ayrıca, bu sınıf aracılığıyla veritabanı işlemlerini takip edebilir ve değişiklikleri yönetebilirsiniz.
LINQ Sorguları: EF Core, LINQ (Language Integrated Query) sorgularını destekler. Bu sayede, C# kodunuzda doğrudan sorguları yazabilir ve veritabanı üzerinde işlem yapabilirsiniz.
Entity Framework Core Kullanımı
DbContext Sınıfının Tanımlanması:
public class ApplicationDbContext : DbContext
{
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
: base(options)
{
}
public DbSet<Product> Products { get; set; }
public DbSet<Category> Categories { get; set; }
}
Yukarıdaki örnekte, ApplicationDbContext adlı bir DbContext sınıfı tanımlanmıştır. Bu sınıf, DbSet<Product> ve DbSet<Category> özelliklerine sahiptir ve bu özellikler, Products ve Categories tablolarına karşılık gelir.
Veritabanı Bağlantısının Yapılandırılması:
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
}
Yukarıdaki örnekte, ConfigureServices metodunda, EF Core DbContext’inin ve veritabanı bağlantısının yapılandırılması yapılmıştır. UseSqlServer metodu, SQL Server veritabanı sağlayıcısını kullanarak bağlantıyı yapılandırır.
LINQ Sorgularının Kullanımı:
public class ProductService
{
private readonly ApplicationDbContext _context;
public ProductService(ApplicationDbContext context)
{
_context = context;
}
public List<Product> GetAllProducts()
{
return _context.Products.ToList();
}
public Product GetProductById(int id)
{
return _context.Products.FirstOrDefault(p => p.Id == id);
}
// Diğer CRUD işlemleri buraya eklenebilir
}
Yukarıdaki örnekte, ProductService sınıfı, Entity Framework Core kullanarak veritabanından ürünleri almak için LINQ sorgularını kullanır.
Özet
Bu makalede, ASP.NET Core Web API’lerinde Entity Framework Core kullanımını derinlemesine açıkladık. Entity Framework Core, veritabanı işlemlerini soyutlayan bir ORM aracıdır ve veritabanı etkileşimini kolaylaştırır. DbContext sınıfı, DbSet özellikleri ve LINQ sorguları gibi temel kavramlar, EF Core’un temellerini oluşturur. EF Core kullanarak, veritabanı işlemlerini kolayca gerçekleştirebilir ve veri tabanınızla etkileşime geçebilirsiniz.
Returning a list of items
Veri almanın önemli bir parçası, API’nin istemcilere liste şeklinde veri döndürmesidir. Bu, genellikle bir veri tabanından veya başka bir kaynaktan birden çok öğeyi almak ve bunları bir liste şeklinde sunmak anlamına gelir.
Liste Öğelerinin Döndürülmesi
ASP.NET Core Web API’lerinde bir liste öğelerin döndürülmesi genellikle IEnumerable<T>, List<T> veya IQueryable<T> gibi koleksiyon türlerini kullanarak yapılır. Bu koleksiyonlar, birden çok öğeyi içeren veri kümesini temsil eder.
Örnek Kodlar
IEnumerable<T> Kullanarak Liste Döndürme:
[HttpGet]
public IEnumerable<Product> GetAllProducts()
{
var products = _productService.GetAllProducts();
return products;
}
Yukarıdaki örnekte, GetAllProducts adlı bir Action yöntemi tanımlanmıştır. Bu yöntem, tüm ürünleri içeren bir IEnumerable<Product> koleksiyonunu döndürür. _productService.GetAllProducts() metodunun, tüm ürünleri içeren bir IEnumerable<Product> döndürdüğü varsayılmıştır.
List<T> Kullanarak Liste Döndürme:
[HttpGet]
public List<Product> GetAllProducts()
{
var products = _productService.GetAllProducts();
return products.ToList();
}
Yukarıdaki örnekte, GetAllProducts adlı bir Action yöntemi tanımlanmıştır. Bu yöntem, tüm ürünleri içeren bir List<Product> koleksiyonunu döndürür. _productService.GetAllProducts() metodunun, tüm ürünleri içeren bir IEnumerable<Product> döndürdüğü varsayılmıştır.
IQueryable<T> Kullanarak Liste Döndürme:
[HttpGet]
public IQueryable<Product> GetAllProducts()
{
var products = _context.Products;
return products;
}
Yukarıdaki örnekte, GetAllProducts adlı bir Action yöntemi tanımlanmıştır. Bu yöntem, tüm ürünleri içeren bir IQueryable<Product> sorgusunu döndürür. _context.Products ifadesinin, bir veritabanı bağlamında tüm ürünleri temsil ettiği varsayılmıştır.
İpucu
Veri tabanından büyük bir veri kümesi alırken, IQueryable<T> kullanarak sorgunun veritabanında yürütülmesini ertelemek performansı artırabilir. Bu, LINQ sorgularının veri tabanında yürütülmeden önce değil, istemcinin talebine yanıt olarak yürütülmesini sağlar.
Özet
Bu makalede, ASP.NET Core Web API’lerinde bir liste öğelerin nasıl döndürüleceğini derinlemesine açıkladık. IEnumerable<T>, List<T> veya IQueryable<T> gibi koleksiyon türleri kullanılarak birden çok öğe içeren veri kümesi döndürülebilir. Bu koleksiyonlar, API istemcilerine verileri liste şeklinde sunmanın yaygın ve etkili bir yoludur.
Using ActionResult
ActionResult sınıfı, ASP.NET Core Web API’lerinde bir işlem sonucunu temsil etmek için kullanılır. Bu sınıf, çeşitli HTTP durum kodlarını (200, 404, 500 vb.) ve dönüş değerlerini (nesne, içerik, hata mesajı vb.) içerebilir. ActionResult, API’nin yanıtını esnek bir şekilde yapılandırmanıza olanak tanır ve hem başarılı hem de başarısız senaryolar için uygun yanıtlar döndürebilirsiniz.
ActionResult Kullanımı
Başarılı Yanıt Dönme:
[HttpGet("{id}")]
public ActionResult<Product> GetProductById(int id)
{
var product = _productService.GetProductById(id);
if (product == null)
{
return NotFound(); // 404 Not Found yanıtı döndürür
}
return product; // 200 OK yanıtı döndürür
}
Yukarıdaki örnekte, GetProductById adlı bir Action yöntemi tanımlanmıştır. Eğer ürün bulunamazsa NotFound() metoduyla 404 Not Found yanıtı döndürülür. Ürün bulunursa, product nesnesiyle birlikte 200 OK yanıtı döndürülür.
Başarısız Yanıt Dönme:
[HttpPost]
public ActionResult<Product> CreateProduct(Product product)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState); // 400 Bad Request yanıtı döndürür
}
_productService.CreateProduct(product);
return CreatedAtAction(nameof(GetProductById), new { id = product.Id }, product);
}
Yukarıdaki örnekte, CreateProduct adlı bir Action yöntemi tanımlanmıştır. İstek gövdesindeki model geçersizse, BadRequest(ModelState) metoduyla 400 Bad Request yanıtı döndürülür. Geçerliyse, yeni oluşturulan ürün bilgisi ve 201 Created yanıtı döndürülür.
HTTP Durum Kodları ile Dönme:
[HttpGet("{id}")]
public ActionResult<Product> GetProductById(int id)
{
var product = _productService.GetProductById(id);
if (product == null)
{
return NotFound(); // 404 Not Found yanıtı döndürür
}
return StatusCode(200, product); // Belirli bir HTTP durum koduyla yanıt döndürür
}
Yukarıdaki örnekte, StatusCode yöntemiyle belirli bir HTTP durum koduyla yanıt döndürülebilir. Bu, NotFound(), BadRequest() gibi önceden tanımlanmış metotları kullanmak yerine belirli bir durum kodu ve isteğe bağlı olarak içerik döndürmek için kullanılır.
ActionResult’ın Avantajları
Özet
Bu makalede, ASP.NET Core Web API’lerinde ActionResult’ın kullanımını derinlemesine açıkladık. ActionResult, API’nin yanıtlarını esnek bir şekilde yapılandırmanıza olanak tanır ve hem başarılı hem de başarısız senaryolar için uygun yanıtlar döndürebilirsiniz. Bu, API’lerinizi daha anlaşılır, ölçeklenebilir ve bakımı daha kolay hale getirir.
Returning an item
Bir öğe döndürme, ASP.NET Core Web API’lerinde belirli bir kimliğe sahip tek bir öğeyi almanın yaygın bir gerekliliğidir. Bu, genellikle bir veri tabanından veya başka bir veri kaynağından bir öğeyi belirli bir kimliğe göre almak ve istemcilere döndürmek anlamına gelir.
Öğe Döndürme Temelleri
Bir Öğe Almak: Bir öğe döndürme, genellikle bir kimlik veya benzersiz bir tanımlayıcı kullanılarak belirli bir öğenin alınmasını içerir. Bu kimlik, bir veritabanı tablosundaki birincil anahtar veya başka bir öğenin benzersiz tanımlayıcısı olabilir.
NotFound Durumu: Eğer istenen öğe bulunamazsa, genellikle 404 Not Found durum kodu ile birlikte uygun bir hata mesajı döndürülür. Bu, istemciye istenen öğenin mevcut olmadığını bildirir.
Başarılı Yanıt: Eğer istenen öğe başarıyla bulunursa, genellikle 200 OK durum kodu ile birlikte öğe kendisi veya uygun bir dönüştürülmüş nesne döndürülür.
Örnek Kodlar
Belirli Bir Öğeyi Döndürme:
[HttpGet("{id}")]
public IActionResult GetProductById(int id)
{
var product = _productService.GetProductById(id);
if (product == null)
{
return NotFound(); // 404 Not Found yanıtı döndürür
}
return Ok(product); // 200 OK yanıtı ile öğe döndürür
}
Yukarıdaki örnekte, GetProductById adlı bir Action yöntemi tanımlanmıştır. Bu yöntem, belirli bir ürünü almak için kullanılır. Eğer ürün bulunamazsa NotFound() metodu ile 404 Not Found yanıtı döndürülür. Ürün bulunursa, Ok(product) metodu ile 200 OK yanıtı ile birlikte öğe döndürülür.
Başka Bir Öğe Döndürme Örneği:
[HttpGet("{id}")]
public IActionResult GetCustomerById(int id)
{
var customer = _customerService.GetCustomerById(id);
if (customer == null)
{
return NotFound("Customer not found"); // 404 Not Found yanıtı ile belirli bir hata mesajı döndürür
}
return Ok(new { Id = customer.Id, Name = customer.Name }); // 200 OK yanıtı ile belirli bir özellikler içeren nesne döndürür
}
Yukarıdaki örnekte, GetCustomerById adlı bir Action yöntemi tanımlanmıştır. Bu yöntem, belirli bir müşteriyi almak için kullanılır. Eğer müşteri bulunamazsa, NotFound metodu ile 404 Not Found yanıtı ile birlikte belirli bir hata mesajı döndürülür. Müşteri bulunursa, Ok metodu ile 200 OK yanıtı ile birlikte müşteriye ait bazı özellikler içeren bir nesne döndürülür.
Özet
Bu makalede, ASP.NET Core Web API’lerinde bir öğenin nasıl döndürüleceğini derinlemesine açıkladık. Bir öğe döndürme, genellikle belirli bir kimlik veya benzersiz bir tanımlayıcı kullanılarak belirli bir öğenin alınmasını ve istemcilere döndürülmesini içerir. NotFound durumu, istenen öğenin bulunamaması durumunda uygun bir hata mesajı ile birlikte döndürülürken, başarılı bir yanıtta öğe kendisi veya uygun bir nesne döndürülür. Bu yöntemler, API’lerinizi daha etkili ve kullanıcı dostu hale getirmenize olanak tanır.
Handling errors
Hataları ele almak, ASP.NET Core Web API’lerinde önemli bir konudur. İstemcilerle olan iletişim sırasında, sunucuda hatalar meydana gelebilir ve bu hataların doğru bir şekilde ele alınması ve uygun şekilde yanıtlanması gerekir.
Hata İşleme Stratejileri
HTTP Durum Kodları: HTTP protokolü, çeşitli durum kodları aracılığıyla istemcilere bir işlemin sonucunu bildirir. Bu durum kodları, isteğin başarıyla tamamlandığını (200 OK), bir kaydın bulunamadığını (404 Not Found), sunucu hatası olduğunu (500 Internal Server Error) ve daha fazlasını belirtebilir.
Detaylı Hata Mesajları: Hataları ele alırken, mümkünse detaylı hata mesajları sunmak önemlidir. Bu, istemcilerin hatayı daha iyi anlamalarına ve sorunu çözmek için gerekli adımları atmalarına yardımcı olur.
Loglama: Hataları loglamak, uygulamanın hata durumlarını izlemesini ve sorunları tespit etmesini sağlar. Bu, hataların nedenlerini ve sıklığını belirlemek için önemlidir.
Hata İşleme Yöntemleri
Global Hata İşleyicisi (Global Exception Handler): ASP.NET Core, Startup.cs dosyasında Configure metodu aracılığıyla bir global hata işleyicisi eklemenize olanak tanır. Bu, tüm isteklerde oluşan hataları ele almanıza ve uygun yanıtları döndürmenize olanak tanır.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
Action Seviyesinde Hata İşleyicisi: Bazı durumlarda, belirli bir Action yöntemi içinde hataları ele almak daha uygun olabilir. Bu durumda, Action yönteminde try-catch blokları kullanarak hataları ele alabilir ve uygun yanıtları döndürebilirsiniz.
[HttpGet("{id}")]
public IActionResult GetProductById(int id)
{
try
{
var product = _productService.GetProductById(id);
if (product == null)
{
return NotFound("Product not found");
}
return Ok(product);
}
catch (Exception ex)
{
_logger.LogError($"An error occurred: {ex.Message}");
return StatusCode(500, "Internal server error");
}
}
Özet
Bu makalede, ASP.NET Core Web API’lerinde hataları ele almanın ve işlemenin temel stratejilerini ve yöntemlerini inceledik. HTTP durum kodları, detaylı hata mesajları ve loglama gibi stratejiler, hata işleme sürecinde önemli rol oynar. Global hata işleyicisi ve Action seviyesinde hata işleyicisi gibi farklı yöntemler, hataları ele almak için kullanılabilir ve uygulamanın hatasız ve güvenilir bir şekilde çalışmasını sağlar.
Making the API asynchronous
ASP.NET Core Web API’lerinde, API’nin performansını artırmak ve ölçeklenebilirliğini sağlamak için asenkron programlama büyük önem taşır. Asenkron programlama, Web API’lerinde uzun süren işlemleri etkili bir şekilde yönetmek ve istemcilere hızlı yanıtlar göndermek için kullanılır.
Asenkron Programlamanın Temelleri
Asenkron ve Senkron Programlama Farkı: Senkron programlama, bir işlemin tamamlanmasını beklerken diğer işlemleri engeller. Asenkron programlama ise, bir işlemin tamamlanmasını beklerken diğer işlemlerin devam etmesine izin verir.
async ve await Anahtar Kelimeleri: C# dilinde, asenkron programlama async ve await anahtar kelimeleriyle gerçekleştirilir. async anahtar kelimesi, bir metodu asenkron hale getirirken, await anahtar kelimesi ise asenkron bir işlemin tamamlanmasını bekler.
Asenkron Web API Metotları
Action Metodunu Asenkron Hale Getirme:
[HttpGet("{id}")]
public async Task<ActionResult<Product>> GetProductByIdAsync(int id)
{
var product = await _productService.GetProductByIdAsync(id);
if (product == null)
{
return NotFound();
}
return product;
}
Yukarıdaki örnekte, GetProductByIdAsync adlı bir Action yöntemi tanımlanmıştır. Bu yöntem, _productService.GetProductByIdAsync metodu asenkron olarak çağrılır ve beklenir. await anahtar kelimesi, işlemin tamamlanmasını beklerken diğer işlemlerin devam etmesine izin verir.
Asenkron Servis Metotları Kullanma:
public interface IProductService
{
Task<Product> GetProductByIdAsync(int id);
}
public class ProductService : IProductService
{
private readonly ApplicationDbContext _context;
public ProductService(ApplicationDbContext context)
{
_context = context;
}
public async Task<Product> GetProductByIdAsync(int id)
{
return await _context.Products.FindAsync(id);
}
}
Yukarıdaki örnekte, IProductService arayüzünde ve ProductService sınıfında GetProductByIdAsync metodu asenkron olarak tanımlanmıştır. Bu metod, veritabanından bir ürünü asenkron olarak alır.
Avantajları
Daha İyi Performans: Asenkron programlama, API’nin yanıtlarını daha hızlı bir şekilde döndürmesine ve daha az kaynak kullanmasına olanak tanır.
Ölçeklenebilirlik: Asenkron programlama, API’yi yüksek talep durumlarında daha iyi ölçeklendirilebilir hale getirir.
Daha İyi Kullanıcı Deneyimi: Asenkron programlama, istemcilere daha hızlı yanıtlar sağlar, bu da daha iyi bir kullanıcı deneyimine yol açar.
Özet
Bu makalede, ASP.NET Core Web API’lerinde API’yi asenkron hale getirmenin temellerini açıkladık. Asenkron programlama, API’nin performansını artırır, ölçeklenebilirliğini sağlar ve daha iyi bir kullanıcı deneyimi sunar. async ve await anahtar kelimeleri, asenkron programlamanın temelini oluşturur ve asenkron metotlar, uzun süren işlemleri etkili bir şekilde yönetmek için kullanılır.
Writing Data
HTTP methods
HTTP yöntemleri, bir HTTP isteğinin amacını belirten birer etiket gibidir ve bir API’ye istemci tarafından hangi işlemin yapılacağını bildirir. ASP.NET Core Web API’lerinde, HTTP yöntemleri genellikle Controller sınıflarındaki Action metodlarına eşlenir.
HTTP Yöntemleri ve Kullanımları
GET: GET isteği, bir kaynağın alınmasını istemek için kullanılır. Bu, bir kaynağın okunmasını talep eder ve mevcut veriyi geri döndürür.
[HttpGet]
public IActionResult GetProducts()
{
var products = _productService.GetAllProducts();
return Ok(products);
}
Yukarıdaki örnekte, GetProducts adlı bir Action metodu, HTTP GET yöntemiyle tüm ürünleri alır ve bunları istemciye döndürür.
POST: POST isteği, bir kaynağı oluşturmak için kullanılır. Bu, bir kaynağın sunucuya gönderilmesini ve sunucunun bu kaynağı kabul etmesini sağlar.
[HttpPost]
public IActionResult CreateProduct(Product product)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
_productService.CreateProduct(product);
return CreatedAtAction(nameof(GetProductById), new { id = product.Id }, product);
}
Yukarıdaki örnekte, CreateProduct adlı bir Action metodu, HTTP POST yöntemiyle bir ürün oluşturur ve oluşturulan ürünün detaylarını içeren yanıtı döndürür.
PUT: PUT isteği, bir kaynağın tamamen güncellenmesini sağlar. Bu, bir kaynağın varsa değiştirilmesi veya yoksa oluşturulması için kullanılabilir.
[HttpPut("{id}")]
public IActionResult UpdateProduct(int id, Product product)
{
if (id != product.Id)
{
return BadRequest("Product ID mismatch");
}
_productService.UpdateProduct(product);
return NoContent();
}
Yukarıdaki örnekte, UpdateProduct adlı bir Action metodu, belirli bir ürünü günceller ve bu güncellemenin başarılı olduğunu belirten bir yanıt döndürür.
DELETE: DELETE isteği, bir kaynağın silinmesini sağlar.
[HttpDelete("{id}")]
public IActionResult DeleteProduct(int id)
{
var product = _productService.GetProductById(id);
if (product == null)
{
return NotFound();
}
_productService.DeleteProduct(id);
return NoContent();
}
Yukarıdaki örnekte, DeleteProduct adlı bir Action metodu, belirli bir ürünü siler ve bu işlemin başarılı olduğunu belirten bir yanıt döndürür.
Özet
Bu makalede, ASP.NET Core Web API’lerinde kullanılan temel HTTP yöntemlerini derinlemesine açıkladık ve her biri için kod örnekleri sunduk. GET, POST, PUT ve DELETE gibi HTTP yöntemleri, API’lerde veri yazma işlemlerini gerçekleştirmek için kullanılır. Bu yöntemlerin her biri, belirli bir amaç için kullanılır ve API’lerin veri kaynağıyla etkileşimde bulunmasını sağlar.
Model binding
Model binding, ASP.NET Core Web API’lerinde gelen HTTP isteği verilerini, Controller Action metodlarının parametrelerine otomatik olarak bağlamak için kullanılan bir mekanizmadır. Bu, istemci tarafından gönderilen verilerin Controller tarafında işlenmesini ve kullanılmasını sağlar.
Model Binding’in Çalışma Mekanizması
HTTP İstekleri: İstemciler, genellikle JSON veya form verisi olarak HTTP isteklerini gönderirler. Bu istekler, bir kaynak oluşturmak, güncellemek, silmek veya sorgulamak için kullanılabilir.
Model Binding: ASP.NET Core, gelen HTTP isteğinin veri yapısını analiz eder ve uygun parametrelerdeki verileri bu yapıya bağlar. Bu işlem, Controller Action metodlarına gelen parametrelerin türlerine ve isimlerine göre otomatik olarak gerçekleştirilir.
Model Binding Kullanımı
FromRoute Attribute: Bu attribute, bir HTTP isteğinin URL’sindeki parametreleri belirtir.
[HttpGet("{id}")]
public IActionResult GetProductById([FromRoute] int id)
{
var product = _productService.GetProductById(id);
if (product == null)
{
return NotFound();
}
return Ok(product);
}
Yukarıdaki örnekte, GetProductById adlı bir Action metodu, HTTP GET isteğiyle birlikte gelen id parametresini alır ve bu id’ye sahip ürünü döndürür.
FromBody Attribute: Bu attribute, bir HTTP isteğinin gövdesindeki verileri belirtir.
[HttpPost]
public IActionResult CreateProduct([FromBody] Product product)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
_productService.CreateProduct(product);
return CreatedAtAction(nameof(GetProductById), new { id = product.Id }, product);
}
Yukarıdaki örnekte, CreateProduct adlı bir Action metodu, HTTP POST isteğiyle birlikte gelen JSON formatındaki ürün bilgisini alır ve yeni bir ürün oluşturur.
FromQuery Attribute: Bu attribute, bir HTTP isteğinin sorgu parametrelerini belirtir.
[HttpGet]
public IActionResult GetProducts([FromQuery] string category)
{
var products = _productService.GetProductsByCategory(category);
return Ok(products);
}
Yukarıdaki örnekte, GetProducts adlı bir Action metodu, HTTP GET isteğiyle birlikte gelen category sorgu parametresini alır ve bu kategoriye sahip ürünleri döndürür.
Model Binding’in Avantajları
Özet
Bu makalede, ASP.NET Core Web API’lerinde model binding’in nasıl çalıştığını ve nasıl kullanıldığını derinlemesine açıkladık. Model binding, gelen HTTP isteklerinin verilerini Controller Action metodlarına otomatik olarak bağlar, böylece verilerin işlenmesi ve kullanılması kolaylaşır. [FromRoute], [FromBody], [FromQuery] gibi attribute’lar, model binding’in farklı kullanım senaryolarını destekler ve istemciden gelen verilerin doğru parametrelere bağlanmasını sağlar.
Adding an item with POST
HTTP POST yöntemi, bir kaynağın oluşturulmasını istemek için kullanılır. ASP.NET Core Web API’lerinde, POST isteği genellikle bir kaynağın eklenmesi için kullanılır.
Öğe Ekleme Temelleri
Model Binding: Önce gelen HTTP isteğindeki verilerin doğru şekilde Controller Action metoduna bağlanması gerekir. Bu, genellikle [FromBody] attribute’ü kullanılarak yapılır.
Veri Doğrulama: Gelen verilerin doğruluğu ve geçerliliği kontrol edilmelidir. Bu, ModelState nesnesi üzerinden yapılabilir.
Veri Kaydetme: Gelen verilerin doğru olduğundan emin olduktan sonra, veritabanına veya başka bir veri kaynağına kaydedilmelidir.
Örnek Kodlar
[HttpPost]
public IActionResult AddItem([FromBody] Item item)
{
// Veri doğrulama
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
try
{
// Veriyi veritabanına kaydetme
_itemRepository.Add(item);
// Başarılı bir yanıt döndürme
return CreatedAtRoute("GetItemById", new { id = item.Id }, item);
}
catch (Exception ex)
{
// Hata durumunda uygun bir yanıt döndürme
return StatusCode(500, $"Internal server error: {ex.Message}");
}
}
Yukarıdaki örnekte, AddItem adlı bir Action metodu, HTTP POST isteğiyle birlikte gelen Item nesnesini alır ve ekler. ModelState nesnesi, gelen verilerin doğruluğunu kontrol eder ve varsa hataları içerir. Eğer gelen veriler geçerli değilse, BadRequest yanıtı döndürülür. Veri kaydetme işlemi başarılı olursa, CreatedAtRoute yöntemiyle 201 Created yanıtı döndürülür ve eklenen öğenin detayları içerir. Eğer bir hata meydana gelirse, StatusCode yöntemiyle 500 Internal Server Error yanıtı döndürülür ve hatanın ayrıntıları içerir.
Özet
Bu makalede, ASP.NET Core Web API’lerinde bir öğenin nasıl eklenmesi gerektiğini derinlemesine açıkladık. HTTP POST yöntemi, bir kaynağın oluşturulmasını istemek için kullanılır ve genellikle yeni verinin veri tabanına eklenmesi için kullanılır. Model binding ve veri doğrulama, gelen verilerin doğru şekilde işlenmesini ve kaydedilmesini sağlar. Uygun HTTP yanıtları, istemcilerin işlemin sonucunu doğru bir şekilde anlamasına yardımcı olur.
Model validation
Model doğrulama, ASP.NET Core Web API’lerinde gelen isteklerin, belirli bir model yapısına uygun olup olmadığını kontrol etmek için kullanılan bir mekanizmadır. Bu, gelen verilerin uygunluğunu doğrulamak ve hatalı verilerin istemciler tarafından işlenmesini sağlamak için kullanılır.
Model Doğrulama Temelleri
Data Annotations: C# sınıfları üzerinde [Required], [MaxLength], [MinLength], [Range] gibi Data Annotations attribute’leri kullanılarak model üzerinde doğrulama kuralları belirlenebilir.
ModelState: Controller Action metodları içinde ModelState nesnesi kullanılarak gelen verilerin doğruluğu kontrol edilir. Bu nesne, gelen verilerin uygunluğunu ve doğruluğunu sağlamak için kullanılır.
Örnek Kodlar
Model Sınıfı ve Data Annotations Kullanımı:
public class Product
{
public int Id { get; set; }
[Required(ErrorMessage = "Product name is required")]
public string Name { get; set; }
[Range(1, 1000, ErrorMessage = "Price must be between 1 and 1000")]
public decimal Price { get; set; }
}
Yukarıdaki örnekte, Product adlı bir model sınıfı tanımlanmıştır. Name özelliği [Required] attribute’ü ile işaretlenmiştir, bu da bu özelliğin boş olamayacağını belirtir. Price özelliği ise [Range] attribute’ü ile işaretlenmiştir, bu da bu özelliğin 1 ile 1000 arasında bir değere sahip olması gerektiğini belirtir.
Controller Action Metodunda Model Doğrulama:
[HttpPost]
public IActionResult AddProduct([FromBody] Product product)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
// Model doğrulama başarılı ise işlem devam eder
_productService.AddProduct(product);
return Ok("Product added successfully");
}
Yukarıdaki örnekte, AddProduct adlı bir Action metodu tanımlanmıştır. Bu metot, HTTP POST isteğiyle birlikte gelen Product nesnesini alır. ModelState.IsValid özelliği, gelen verilerin modelde belirtilen doğrulama kurallarına uyup uymadığını kontrol eder. Eğer gelen veriler doğrulama kurallarına uymuyorsa, BadRequest yanıtı ile birlikte ModelState nesnesi döndürülür ve istemciye hatalı veri hakkında bilgi verilir.
Özet
Bu makalede, ASP.NET Core Web API’lerinde model doğrulamanın nasıl yapıldığını derinlemesine açıkladık. Data Annotations kullanarak model üzerinde doğrulama kuralları belirlenir ve Controller Action metodları içinde ModelState nesnesi kullanılarak gelen verilerin uygunluğu kontrol edilir. Bu sayede hatalı verilerin istemci tarafından işlenmesi sağlanır ve API’nin güvenilirliği artar.
Updating an item with PUT
HTTP PUT yöntemi, bir kaynağın tamamen güncellenmesini istemek için kullanılır. ASP.NET Core Web API’lerinde, PUT isteği genellikle bir kaynağın güncellenmesi için kullanılır.
Öğe Güncelleme Temelleri
Kimlik Belirleme: Güncellenecek öğe, genellikle bir kimlik kullanılarak belirlenir. Bu, genellikle URL’de veya gövdede belirtilir.
Veri Doğrulama: Gelen verilerin doğruluğu ve geçerliliği kontrol edilmelidir. Bu, ModelState nesnesi üzerinden yapılabilir.
Veri Güncelleme: Eğer gelen veriler geçerli ise, ilgili öğe veritabanından bulunur ve güncellenir.
Örnek Kodlar
[HttpPut("{id}")]
public IActionResult UpdateItem(int id, [FromBody] Item updatedItem)
{
// Belirtilen ID'ye sahip öğe var mı kontrol edilir
var existingItem = _itemRepository.GetById(id);
if (existingItem == null)
{
return NotFound();
}
// Gelen verilerin doğruluğu kontrol edilir
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
// Güncelleme işlemi yapılır
existingItem.Name = updatedItem.Name;
existingItem.Description = updatedItem.Description;
existingItem.Price = updatedItem.Price;
// Veritabanına güncelleme işlemi yapılır
_itemRepository.Update(existingItem);
return NoContent();
}
Yukarıdaki örnekte, UpdateItem adlı bir Action metodu tanımlanmıştır. Bu metot, HTTP PUT isteğiyle birlikte gelen id parametresi ile güncellenecek öğenin kimliğini alır. Daha sonra, güncellenmiş öğe verisi [FromBody] attribute’ü ile alınır. İlk olarak, belirtilen ID’ye sahip öğenin var olup olmadığı kontrol edilir. Eğer öğe bulunamazsa NotFound yanıtı döndürülür. Daha sonra, gelen verilerin ModelState nesnesi ile doğruluğu kontrol edilir. Eğer veriler doğru değilse BadRequest yanıtı döndürülür. Eğer veriler doğru ise, öğe verisi güncellenir ve veritabanında güncelleme işlemi gerçekleştirilir. Son olarak, NoContent yanıtı döndürülür, çünkü güncelleme işlemi başarıyla tamamlandı ancak içeriği değişmedi.
Özet
Bu makalede, ASP.NET Core Web API’lerinde bir öğenin nasıl güncelleneceğini derinlemesine açıkladık. HTTP PUT yöntemi, bir kaynağın tamamen güncellenmesini sağlar. Action metodu içinde, güncellenen öğenin kimliği belirlenir, veri doğrulaması yapılır ve veritabanında güncelleme işlemi gerçekleştirilir. Uygun HTTP yanıtları, işlemin sonucunu istemcilere doğru bir şekilde bildirir.
Deleting an item with DELETE
HTTP DELETE yöntemi, bir kaynağın silinmesini istemek için kullanılır. ASP.NET Core Web API’lerinde, DELETE isteği genellikle bir kaynağın silinmesi için kullanılır.
Öğe Silme Temelleri
Kimlik Belirleme: Silinecek öğe, genellikle bir kimlik kullanılarak belirlenir. Bu kimlik genellikle URL’de belirtilir.
Varlık Kontrolü: Belirtilen kimliğe sahip öğenin var olup olmadığı kontrol edilmelidir. Eğer öğe bulunamazsa, istemciye uygun bir hata yanıtı döndürülür.
Veri Silme: Eğer öğe var ise, bu öğe veritabanından silinir.
Örnek Kodlar
[HttpDelete("{id}")]
public IActionResult DeleteItem(int id)
{
// Belirtilen ID'ye sahip öğe var mı kontrol edilir
var existingItem = _itemRepository.GetById(id);
if (existingItem == null)
{
return NotFound();
}
// Veritabanından öğe silinir
_itemRepository.Delete(id);
// NoContent yanıtı döndürülür, çünkü içerik silindi
return NoContent();
}
Yukarıdaki örnekte, DeleteItem adlı bir Action metodu tanımlanmıştır. Bu metot, HTTP DELETE isteğiyle birlikte gelen id parametresi ile silinecek öğenin kimliğini alır. İlk olarak, belirtilen ID’ye sahip öğenin var olup olmadığı kontrol edilir. Eğer öğe bulunamazsa NotFound yanıtı döndürülür. Eğer öğe varsa, öğe veritabanından silinir ve NoContent yanıtı döndürülür. NoContent yanıtı, istemcinin işlemin başarıyla tamamlandığını ve içeriğin artık mevcut olmadığını anlamasını sağlar.
Özet
Bu makalede, ASP.NET Core Web API’lerinde bir öğenin nasıl silineceğini derinlemesine açıkladık. HTTP DELETE yöntemi, bir kaynağın silinmesini sağlar. Action metodu içinde, silinecek öğenin kimliği belirlenir ve varlık kontrolü yapılır. Eğer öğe varsa, veritabanından silinir ve uygun bir HTTP yanıtı döndürülür. Bu sayede, istemcilerin işlem sonucunu doğru bir şekilde anlaması sağlanır.
Her gün kendini yeniliyorsun. Bazen başarılı olursun, bazen olamazsın, ama önemli olan ortalamadır.
— Satya Nadella
Bir sonraki yazıda görüşmek dileğiyle!”
