Physical Address
304 North Cardinal St.
Dorchester Center, MA 02124
What is ASP.NET Razor Pages?
ASP.NET Razor Pages, ASP.NET Core framework’ünde sunulan bir özelliktir ve web uygulamaları oluşturmak için kullanılır. Razor Pages, basit, temiz ve sade bir yapıya sahip olup, sunucu tarafı web uygulamalarının hızlı bir şekilde geliştirilmesini sağlar. Bu özellik, model, görünüm ve işlem kodlarını tek bir dosyada birleştirerek geliştirme sürecini kolaylaştırır.
1. ASP.NET Razor Pages Nedir?
2. Razor Pages Avantajları:
3. Örnek Bir Razor Sayfası:
@page
@model IndexModel
<!DOCTYPE html>
<html>
<head>
<title>Razor Pages Example</title>
</head>
<body>
<h1>Welcome to Razor Pages</h1>
<p>Current Time: @DateTime.Now</p>
<p>Total Users: @Model.TotalUsers</p>
</body>
</html>
@code {
public class IndexModel
{
public int TotalUsers { get; set; }
public void OnGet()
{
// Sayfa yüklendiğinde çalışacak kod
TotalUsers = 100; // Örnek bir kullanıcı sayısı
}
}
Yukarıdaki örnekte, bir Razor Pages sayfası görülmektedir. Sayfanın başında @page direktifi, bu sayfanın bir Razor Page olduğunu belirtir. @model direktifi, sayfanın model sınıfını belirtir. Görünüm kısmı HTML etiketleri ile yazılmıştır. Sayfanın alt kısmında @code bloğu içinde, sayfanın işlem kodları ve model sınıfı yer alır. OnGet() metodu, sayfanın yüklendiğinde çalışacak kodları içerir.
4. Özet:
ASP.NET Razor Pages, basit ve odaklanmış bir yapıya sahip olduğu için web uygulamalarının hızlı bir şekilde geliştirilmesini sağlar. Her bir sayfa, kendi modelini, görünümünü ve işlem kodunu içerir, bu da kodun daha organize ve bakımının daha kolay olmasını sağlar. Razor Pages, ASP.NET Core framework’ünün güçlü bir özelliği olup, web uygulamalarının geliştirilmesini büyük ölçüde kolaylaştırır.
ASP.NET Razor Pages vs. ASP.NET MVC
ASP.NET Razor Pages ve ASP.NET MVC, ASP.NET Core framework’ünde sunulan iki farklı web uygulama geliştirme modelidir. Her iki yaklaşım da sunucu tarafı web uygulamaları oluşturmak için kullanılır, ancak farklı yapılar ve tasarımlar sunarlar.
1. ASP.NET Razor Pages vs. ASP.NET MVC Nedir?
2. Razor Pages ve MVC Arasındaki Farklar:
3. Kod Örneği:
Örnek bir Razor Page:
@page
@model IndexModel
<!DOCTYPE html>
<html>
<head>
<title>Razor Pages Example</title>
</head>
<body>
<h1>Welcome to Razor Pages</h1>
<p>Current Time: @DateTime.Now</p>
<p>Total Users: @Model.TotalUsers</p>
</body>
</html>
@code {
public class IndexModel
{
public int TotalUsers { get; set; }
public void OnGet()
{
// Sayfa yüklendiğinde çalışacak kod
TotalUsers = 100; // Örnek bir kullanıcı sayısı
}
}
Örnek bir MVC Controller ve View:
Controller:
using Microsoft.AspNetCore.Mvc;
public class HomeController : Controller
{
public IActionResult Index()
{
int totalUsers = 100; // Örnek bir kullanıcı sayısı
return View(totalUsers);
}
}
View (Index.cshtml):
<!DOCTYPE html>
<html>
<head>
<title>MVC Example</title>
</head>
<body>
<h1>Welcome to MVC</h1>
<p>Current Time: @DateTime.Now</p>
<p>Total Users: @Model</p>
</body>
</html>
4. Özet:
ASP.NET Razor Pages ve ASP.NET MVC, farklı yaklaşımlar sunarlar ve uygulamanın gereksinimlerine bağlı olarak tercih edilebilirler. Razor Pages, basit ve sade bir yapıya sahipken, MVC daha esnek ve büyük ölçekli projeler için daha uygundur. Hangi yapının seçileceği, projenin gereksinimlerine, boyutuna ve karmaşıklığına bağlı olarak değişir.
Creating an empty ASP.NET Razor Pages project
ASP.NET Core ile boş bir ASP.NET Razor Pages projesi oluşturmak oldukça basittir. Bu adımları takip ederek bir boş ASP.NET Razor Pages projesi oluşturabilirsiniz:
1. Visual Studio kullanarak:
2. .NET Core CLI kullanarak:
dotnet new webapp -o MyRazorPagesProject
Bu komut, “MyRazorPagesProject” adında bir klasör oluşturacak ve içine boş bir ASP.NET Razor Pages projesi oluşturacaktır.
3. Bir metin düzenleyici kullanarak:
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
</PropertyGroup>
</Project>
Ardından, aynı dizine bir Startup.cs dosyası oluşturun ve içine aşağıdaki kodu yapıştırın:
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddRazorPages();
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapRazorPages();
});
}
}
Bu adımları takip ettikten sonra, bir boş ASP.NET Razor Pages projesi oluşturmuş olacaksınız. Artık Razor Pages’lerinizi bu projeye ekleyebilir ve uygulamanızı geliştirmeye başlayabilirsiniz.
Key ASP.NET Razor Pages concepts
ASP.NET Razor Pages’e başlamadan önce, bazı temel kavramları anlamak önemlidir. Bu kavramlar, Razor Pages’in temel işleyişini ve nasıl kullanılacağını anlamanıza yardımcı olacaktır.
1. Razor Pages: Razor Pages, sunucu tarafında çalışan ve model, görünüm ve işlem kodlarını tek bir dosyada birleştiren bir web uygulama modelidir. Bu yaklaşım, web sayfalarının geliştirilmesini daha basit ve doğrudan hale getirir.
2. Page Model: Her Razor Page, bir Page Model sınıfına sahiptir. Bu sınıf, sayfanın işlem kodlarını (örneğin, HTTP isteklerini işleme) içerir. Page Model sınıfı, @page direktifiyle ilişkilendirilmiştir ve sayfa yüklendiğinde çalışan işlem kodlarını içerir.
3. Razor Syntax: Razor Pages, Razor sözdizimini kullanır. Bu sözdizimi, C# kodunu HTML veya başka bir işaretleme dili ile birlikte kullanmanıza olanak tanır. Bu, dinamik içerik oluşturmak ve model verilerini görünüme bağlamak için kullanılır.
4. Page Lifecycle: Her Razor Page’in bir yaşam döngüsü vardır. Sayfa yüklendiğinde ve işlem kodları çalıştırıldığında, belirli olaylar tetiklenir. Örneğin, bir sayfa yüklendiğinde, OnGet() yöntemi çalıştırılır ve sayfa görüntülenmeden önce bir dizi ön hazırlık işlemi yapılabilir.
5. Razor Pages Dosya Yapısı: Razor Pages, Pages adlı bir klasörde bulunur. Her Razor Page, .cshtml uzantılı bir dosyaya sahiptir. Ayrıca, Razor Pages’in aynı adı taşıyan bir Page Model sınıfına sahip olması gerekir.
6. Dependency Injection: ASP.NET Core, bağımlılık enjeksiyonunu (Dependency Injection) destekler. Bu, bir Razor Page’in ihtiyaç duyduğu hizmetleri (örneğin, veritabanı erişimi) enjekte etmenizi sağlar. Bu sayede, kodunuzun daha modüler ve test edilebilir olmasını sağlar.
Kod Örneği:
Örnek bir Razor Page:
@page
@model IndexModel
<!DOCTYPE html>
<html>
<head>
<title>Razor Pages Example</title>
</head>
<body>
<h1>Welcome to Razor Pages</h1>
<p>Current Time: @DateTime.Now</p>
<p>Total Users: @Model.TotalUsers</p>
</body>
</html>
@code {
public class IndexModel : PageModel
{
public int TotalUsers { get; set; }
public void OnGet()
{
// Sayfa yüklendiğinde çalışacak kod
TotalUsers = 100; // Örnek bir kullanıcı sayısı
}
}
}
Yukarıdaki örnekte, bir Razor Page ve ona bağlı bir Page Model sınıfı görülmektedir. Razor Pages’in temel kavramlarını anlamak için bu tür bir örneği incelemek faydalı olacaktır. Bu temel kavramları anladıktan sonra, Razor Pages kullanarak daha karmaşık uygulamalar geliştirebilirsiniz.
Working with forms in Razor Pages
Data binding in ASP.NET Razor Pages
ASP.NET Razor Pages’de formlarla çalışırken, veri bağlama (data binding) önemli bir konudur. Veri bağlama, kullanıcıların bir web formundaki giriş alanlarına veri girdiğinde, bu verinin doğrudan bir model nesnesine bağlanmasıdır. Bu, kullanıcı girişlerini almak, doğrulamak ve işlemek için kolay ve güçlü bir yol sağlar.
1. Data Binding Nedir?
2. Veri Bağlama Adımları:
3. Kod Örneği:
Örnek bir Razor Page:
@page
@model RegisterModel
@{
ViewData["Title"] = "User Registration";
}
<h1>User Registration</h1>
<form method="post">
<div>
<label asp-for="Username"></label>
<input asp-for="Username" />
</div>
<div>
<label asp-for="Email"></label>
<input asp-for="Email" />
</div>
<button type="submit">Register</button>
</form>
Örnek bir Page Model sınıfı:
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
public class RegisterModel : PageModel
{
[BindProperty]
public string Username { get; set; }
[BindProperty]
public string Email { get; set; }
public IActionResult OnPost()
{
// Form verilerini işleme kodları
if (ModelState.IsValid)
{
// Form verileri geçerli ise
// Kullanıcıyı kaydet veya başka bir işlem yap
return RedirectToPage("/Success");
}
else
{
// Form verileri geçersiz ise
// Kullanıcıyı aynı sayfaya yönlendir ve hata mesajlarını göster
return Page();
}
}
}
Yukarıdaki örnekte, bir kullanıcı kayıt formu görülmektedir. BindProperty niteliği kullanılarak Username ve Email özellikleri model sınıfına bağlanmıştır. Form gönderildiğinde, OnPost yöntemi çalışır ve form verileri işlenir. ModelState.IsValid ile verilerin doğruluğu kontrol edilir ve işlem yapılır.
ASP.NET Razor Pages application overview
ASP.NET Razor Pages uygulamaları, sunucu tarafında çalışan web uygulamaları oluşturmak için kullanılan bir teknolojidir. Bu model, bir MVC (Model-View-Controller) yaklaşımına benzer ancak daha basit ve sayfa odaklıdır.
1. Razor Pages Nedir?
2. Uygulama Yapısı:
3. Razor Syntax:
4. Page Lifecycle:
5. Kod Örneği:
Örnek bir Razor Page:
@page
@model IndexModel
<!DOCTYPE html>
<html>
<head>
<title>Razor Pages Example</title>
</head>
<body>
<h1>Welcome to Razor Pages</h1>
<p>Current Time: @DateTime.Now</p>
<p>Total Users: @Model.TotalUsers</p>
</body>
</html>
@code {
public class IndexModel : PageModel
{
public int TotalUsers { get; set; }
public void OnGet()
{
// Sayfa yüklendiğinde çalışacak kod
TotalUsers = 100; // Örnek bir kullanıcı sayısı
}
}
}
Yukarıdaki örnekte, bir Razor Page ve ona bağlı bir Page Model sınıfı görülmektedir. Razor Pages’in temel kavramlarını anlamak için bu tür bir örneği incelemek faydalı olacaktır. Bu temel kavramları anladıktan sonra, Razor Pages kullanarak daha karmaşık uygulamalar geliştirebilirsiniz.
One-way data binding in ASP.NET Razor Pages
ASP.NET Razor Pages’de bir form ile çalışırken, tek yönlü veri bağlama (one-way data binding) önemli bir kavramdır. Tek yönlü veri bağlama, bir modelin değerini görünüme bağlamak için kullanılır ve bu değerler, kullanıcıların bir formdaki giriş alanlarını doldurmasıyla değişebilir. Bu kavramı daha derinlemesine anlamak için aşağıdaki adımları inceleyebiliriz:
1. Tek Yönlü Veri Bağlama Nedir?
2. Veri Bağlama Adımları:
3. Örnek Kod:
Örnek bir Razor Page ve ilgili Page Model sınıfı:
@page
@model RegisterModel
@{
ViewData["Title"] = "User Registration";
}
<h1>User Registration</h1>
<form method="post">
<div>
<label asp-for="Username"></label>
<input asp-for="Username" />
</div>
<div>
<label asp-for="Email"></label>
<input asp-for="Email" />
</div>
<button type="submit">Register</button>
</form>
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
public class RegisterModel : PageModel
{
[BindProperty]
public string Username { get; set; }
[BindProperty]
public string Email { get; set; }
public IActionResult OnPost()
{
// Form verilerini işleme kodları
if (ModelState.IsValid)
{
// Form verileri geçerli ise
// Kullanıcıyı kaydet veya başka bir işlem yap
return RedirectToPage("/Success");
}
else
{
// Form verileri geçersiz ise
// Kullanıcıyı aynı sayfaya yönlendir ve hata mesajlarını göster
return Page();
}
}
}
Yukarıdaki örnekte, asp-for özelliği kullanılarak model sınıfındaki Username ve Email özellikleri ile formdaki input alanları bağlanmıştır. Bu sayede, kullanıcı bir form gönderdiğinde, formdaki değerler otomatik olarak ilgili model özelliklerine atanır ve OnPost yöntemi tarafından işlenir. Bu, tek yönlü veri bağlamanın nasıl uygulandığını gösterir.
Two-way data binding in ASP.NET Razor Pages
Two-way data binding, bir modelin değerini görünüme bağlamakla kalmaz, aynı zamanda kullanıcının bir formdaki giriş alanlarına veri girmesi durumunda bu değeri otomatik olarak günceller. Bu, kullanıcının formu doldurduğunda modeldeki değerlerin otomatik olarak güncellenmesini sağlar.
1. İki Yönlü Veri Bağlama Nedir?
2. Veri Bağlama Adımları:
3. Örnek Kod:
Örnek bir Razor Page ve ilgili Page Model sınıfı:
@page
@model TwoWayBindingModel
@{
ViewData["Title"] = "Two-way Data Binding Example";
}
<h1>Two-way Data Binding Example</h1>
<form method="post">
<div>
<label asp-for="Message"></label>
<input asp-for="Message" />
</div>
<button type="submit">Submit</button>
</form>
<p>You entered: @Model.Message</p>
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
public class TwoWayBindingModel : PageModel
{
[BindProperty]
public string Message { get; set; }
public IActionResult OnPost()
{
// Form gönderildiğinde yapılacak işlemler
// Model.Message kullanılarak giriş alanından gelen veriye erişilebilir
return Page();
}
}
Yukarıdaki örnekte, asp-for özelliği kullanılarak Message özelliği model sınıfındaki bir giriş alanına bağlanmıştır. Aynı zamanda, @Model.Message kullanılarak bu özellik görünümde de gösterilir. Kullanıcı bir form gönderdiğinde, Message özelliği otomatik olarak güncellenir ve formun altındaki paragraf etiketinde görüntülenir. Bu, iki yönlü veri bağlamanın nasıl uygulandığını gösterir.
Event binding in ASP.NET Razor Pages
ASP.NET Razor Pages’de, bir form veya diğer HTML öğeleri üzerindeki etkinliklere (events) bağlanma işlemine “event binding” denir. Bu, bir kullanıcının bir HTML öğesi üzerinde bir etkinlik gerçekleştirdiğinde, bu etkinliğe yanıt olarak belirli bir işlemi gerçekleştirmenizi sağlar. Event binding, Razor Pages uygulamalarında kullanıcı etkileşimlerini işlemek için önemli bir kavramdır.
1. Event Binding Nedir?
2. Event Binding Adımları:
3. Örnek Kod:
Örnek bir Razor Page ve ilişkili Page Model sınıfı:
@page
@model EventBindingModel
@{
ViewData["Title"] = "Event Binding Example";
}
<h1>Event Binding Example</h1>
<button @onclick="ButtonClick">Click me</button>
<p>Button clicked: @Model.ButtonClicked</p>
using Microsoft.AspNetCore.Mvc.RazorPages;
public class EventBindingModel : PageModel
{
public bool ButtonClicked { get; set; }
public void ButtonClick()
{
// Butona tıklandığında yapılacak işlemler
ButtonClicked = true;
}
}
Yukarıdaki örnekte, @onclick ile ButtonClick methodu butona event binding yapılır. ButtonClick methodu butona tıklandığında çağrılır ve ButtonClicked özelliği true değerine atanır. Bu, butona tıklama etkinliğini işlemek için event binding kullanmanın bir örneğidir.
Model binding ASP.NET Razor Pages
ASP.NET Razor Pages’de model binding, bir HTML formundan gelen verileri bir Razor Page’in Page Model sınıfına otomatik olarak bağlama sürecidir. Bu, bir formun post edilmesi durumunda, formdaki giriş alanlarındaki verilerin doğrudan bir Page Model sınıfının özelliklerine bağlanması anlamına gelir. Bu sayede, gelen verileri kolayca işleyebilir ve kullanabilirsiniz.
1. Model Binding Nedir?
2. Model Binding Adımları:
3. Örnek Kod:
Örnek bir Razor Page ve ilişkili Page Model sınıfı:
@page
@model RegisterModel
@{
ViewData["Title"] = "User Registration";
}
<h1>User Registration</h1>
<form method="post">
<div>
<label asp-for="Username"></label>
<input asp-for="Username" />
</div>
<div>
<label asp-for="Email"></label>
<input asp-for="Email" />
</div>
<button type="submit">Register</button>
</form>
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
public class RegisterModel : PageModel
{
[BindProperty]
public string Username { get; set; }
[BindProperty]
public string Email { get; set; }
public IActionResult OnPost()
{
// Form verilerini işleme kodları
if (ModelState.IsValid)
{
// Form verileri geçerli ise
// Kullanıcıyı kaydet veya başka bir işlem yap
return RedirectToPage("/Success");
}
else
{
// Form verileri geçersiz ise
// Kullanıcıyı aynı sayfaya yönlendir ve hata mesajlarını göster
return Page();
}
}
}
Yukarıdaki örnekte, BindProperty niteliği kullanılarak Username ve Email özellikleri Page Model sınıfına bağlanmıştır. OnPost yöntemi, form gönderildiğinde çalışır ve formdaki giriş alanlarından gelen verileri işler. Bu, model binding’in nasıl uygulandığını gösterir.
Form data validation in ASP.NET Razor Pages
Form veri doğrulaması (form data validation), kullanıcının bir form gönderdiğinde gönderilen verilerin doğruluğunu kontrol etmek için yapılan işlemdir. ASP.NET Razor Pages’de form veri doğrulaması, ModelState mekanizması kullanılarak gerçekleştirilir. Bu mekanizma, gelen form verilerini doğrulamak ve doğrulama sonuçlarını işlemek için kullanılır.
1. Form Veri Doğrulaması Nedir?
2. Form Veri Doğrulaması Adımları:
3. Örnek Kod:
Örnek bir Razor Page ve ilişkili Page Model sınıfı:
@page
@model RegisterModel
@{
ViewData["Title"] = "User Registration";
}
<h1>User Registration</h1>
<form method="post">
<div>
<label asp-for="Username"></label>
<input asp-for="Username" />
<span asp-validation-for="Username"></span>
</div>
<div>
<label asp-for="Email"></label>
<input asp-for="Email" />
<span asp-validation-for="Email"></span>
</div>
<button type="submit">Register</button>
</form>
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
public class RegisterModel : PageModel
{
[BindProperty]
public string Username { get; set; }
[BindProperty]
public string Email { get; set; }
public IActionResult OnPost()
{
// Form veri doğrulaması
if (!ModelState.IsValid)
{
// Doğrulama başarısız ise, hataları işle
return Page();
}
// Doğrulama başarılı ise, kullanıcıyı yönlendir
return RedirectToPage("/Success");
}
}
Yukarıdaki örnekte, asp-validation-for özelliği kullanılarak her bir giriş alanı için doğrulama hataları görüntülenir. OnPost yönteminde, ModelState.IsValid özelliği kullanılarak form verilerinin doğruluğu kontrol edilir. ModelState.IsValid false olduğunda, formdaki hatalar işlenir ve kullanıcıya uygun geri bildirimler gösterilir. Bu, form veri doğrulamasının nasıl uygulandığını gösterir.
Working with Data in Razor Page
Setting up Entity Framework Core in ASP.NET Razor Pages
Entity Framework Core, birçok ASP.NET Core uygulamasında veritabanı işlemlerini kolaylaştırmak için kullanılan bir ORM (Object-Relational Mapping) aracıdır. Entity Framework Core’u kullanarak veritabanı işlemleri gerçekleştirmek, ASP.NET Razor Pages uygulamalarında oldukça yaygın bir uygulamadır.
1. Entity Framework Core Kurulumu:
Entity Framework Core’u ASP.NET Razor Pages projesine eklemek için öncelikle NuGet paketlerini yüklemeniz gerekir. Bunun için aşağıdaki adımları izleyebilirsiniz:
2. DbContext Sınıfı Oluşturma:
Entity Framework Core’u kullanmak için bir DbContext sınıfı oluşturmanız gerekir. Bu sınıf, veritabanı tablolarını ve ilişkilerini temsil eder. DbContext sınıfınızı oluşturmak için şu adımları izleyebilirsiniz:
using Microsoft.EntityFrameworkCore;
public class ApplicationDbContext : DbContext
{
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
: base(options)
{
}
// DbSet'ler buraya eklenir (örneğin, public DbSet<User> Users { get; set; })
}
3. ConfigureServices Metodu Güncelleme:
Startup.cs dosyasında ConfigureServices metodunu güncellemeniz gerekir. Bu adımda, DbContext sınıfınızı servis olarak kaydetmelisiniz. Ayrıca, DbContextOptions’ı yapılandırmalısınız:
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
}
Burada “DefaultConnection” adlı bir bağlantı dizesi kullanıldı, ancak siz projenize uygun olan bir bağlantı dizesi sağlamalısınız.
4. Veritabanı Migrations’ları Oluşturma ve Uygulama:
Artık DbContext sınıfınızı ve ConfigureServices metodunu yapılandırdınız. Şimdi, veritabanı migrations’larını oluşturmak ve uygulamak için aşağıdaki EF Core CLI komutlarını kullanabilirsiniz:
dotnet ef migrations add InitialCreate
dotnet ef database update
Bu komutlar, DbContext sınıfınızda tanımladığınız modeli temel alarak bir veritabanı migrations’ı oluşturacak ve bu migrations’ı veritabanına uygulayacaktır.
5. Entity Framework Core Kullanımı:
Artık Entity Framework Core’u projenizde yapılandırdınız ve veritabanı migrations’larını uyguladınız. Şimdi, DbContext sınıfınızı kullanarak veritabanı işlemlerini gerçekleştirebilirsiniz. Örneğin, veri eklemek için aşağıdaki gibi bir kod kullanabilirsiniz:
using (var context = new ApplicationDbContext())
{
var newUser = new User { Name = "John", Email = "john@example.com" };
context.Users.Add(newUser);
context.SaveChanges();
}
Bu kod, “User” adlı bir model sınıfı oluşturmanızı ve ApplicationDbContext sınıfını kullanarak veri ekleme işlemlerini gerçekleştirmenizi sağlar.
Adding and storing data in a database
Veritabanına veri eklemek ve saklamak, ASP.NET Razor Pages uygulamalarında yaygın bir gerekliliktir. Bu işlem genellikle Entity Framework Core gibi bir ORM (Object-Relational Mapping) aracılığıyla gerçekleştirilir.
1. Model Sınıfını Oluşturma:
İlk adım, veritabanında saklayacağınız verinin modelini temsil eden bir sınıf oluşturmaktır. Örneğin, bir “Product” sınıfı oluşturalım:
public class Product
{
public int Id { get; set; }
public string Name { get; set; }
public decimal Price { get; set; }
}
2. DbContext Sınıfını Oluşturma:
Daha sonra, veritabanı işlemleri için bir DbContext sınıfı oluşturmanız gerekir. Bu sınıf, Entity Framework Core tarafından veritabanıyla etkileşim için kullanılır.
public class ApplicationDbContext : DbContext
{
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
: base(options)
{
}
public DbSet<Product> Products { get; set; }
}
3. ConfigureServices Metodunu Güncelleme:
Startup.cs dosyasında, ConfigureServices metodunda DbContext sınıfını servis olarak kaydetmeniz gerekir.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
}
4. Veritabanı Migrations’larını Oluşturma ve Uygulama:
Komut satırında aşağıdaki EF Core CLI komutlarını kullanarak veritabanı migrations’larını oluşturabilir ve uygulayabilirsiniz:
dotnet ef migrations add InitialCreate
dotnet ef database update
5. Razor Page’lerde Veri Eklemek:
Veritabanına veri eklemek için Razor Page’lerde bir HTTP Post isteği ele almanız gerekir. Örneğin, bir “Create.cshtml” sayfasında bir ürün ekleyelim:
<form method="post">
<input type="text" asp-for="Product.Name" />
<input type="number" asp-for="Product.Price" />
<button type="submit">Add Product</button>
</form>
6. Page Model Sınıfında HTTP Post Metodunu Oluşturma:
Page Model sınıfında, HTTP Post isteğini ele alacak bir yöntem oluşturun:
public class CreateModel : PageModel
{
private readonly ApplicationDbContext _context;
[BindProperty]
public Product Product { get; set; }
public CreateModel(ApplicationDbContext context)
{
_context = context;
}
public IActionResult OnPost()
{
if (!ModelState.IsValid)
{
return Page();
}
_context.Products.Add(Product);
_context.SaveChanges();
return RedirectToPage("/Index");
}
}
Yukarıdaki kod, gelen veriyi Product nesnesine bağlar, ModelState’i kontrol eder, veritabanına ürün ekler ve sonra Index sayfasına yönlendirir.
Getting data from a database
Veritabanından veri almak, ASP.NET Razor Pages uygulamalarında yaygın bir ihtiyaçtır. Bu işlem genellikle Entity Framework Core gibi bir ORM (Object-Relational Mapping) aracılığıyla gerçekleştirilir.
1. DbContext Sınıfını Oluşturma:
İlk adım, veritabanından veri almak için bir DbContext sınıfı oluşturmaktır. Bu sınıf, veritabanı tablolarını ve ilişkilerini temsil eder. DbContext sınıfınızı oluşturmak için aşağıdaki gibi bir sınıf oluşturabilirsiniz:
public class ApplicationDbContext : DbContext
{
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
: base(options)
{
}
public DbSet<Product> Products { get; set; }
}
2. ConfigureServices Metodunu Güncelleme:
Startup.cs dosyasında, ConfigureServices metodunda DbContext sınıfını servis olarak kaydetmeniz gerekir.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
}
3. Razor Page’lerde Veri Almak:
Veritabanından veri almak için Razor Page’lerde bir HTTP Get isteği ele almanız gerekir. Örneğin, bir “Index.cshtml” sayfasında tüm ürünleri listelemek istiyorsak:
@page
@model IndexModel
@{
ViewData["Title"] = "Product List";
}
<h1>Product List</h1>
<ul>
@foreach (var product in Model.Products)
{
<li>@product.Name - @product.Price</li>
}
</ul>
4. Page Model Sınıfında HTTP Get Metodunu Oluşturma:
Page Model sınıfında, HTTP Get isteğini ele alacak bir yöntem oluşturun:
public class IndexModel : PageModel
{
private readonly ApplicationDbContext _context;
public IndexModel(ApplicationDbContext context)
{
_context = context;
}
public IList<Product> Products { get; set; }
public void OnGet()
{
Products = _context.Products.ToList();
}
}
Yukarıdaki kod, veritabanından tüm ürünleri alır ve bunları Razor Page’e aktarır. Daha sonra, Razor Page üzerinde bu ürünleri listeleyebiliriz.
Getting data by ID from a database
Veritabanından belirli bir ID’ye sahip bir öğeyi almak, ASP.NET Razor Pages uygulamalarında sıkça kullanılan bir senaryodur. Bu işlem genellikle Entity Framework Core gibi bir ORM (Object-Relational Mapping) aracılığıyla gerçekleştirilir.
1. DbContext Sınıfınızı Oluşturma:
İlk adım, veritabanından veri almak için bir DbContext sınıfı oluşturmaktır. Bu sınıf, veritabanı tablolarını ve ilişkilerini temsil eder. Örneğin, bir “Product” sınıfı için bir DbContext sınıfı oluşturalım:
public class ApplicationDbContext : DbContext
{
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
: base(options)
{
}
public DbSet<Product> Products { get; set; }
}
2. ConfigureServices Metodunu Güncelleme:
Startup.cs dosyasında, ConfigureServices metodunda DbContext sınıfını servis olarak kaydetmeniz gerekir.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
}
3. Razor Page’lerde Belirli Bir ID’ye Sahip Veriyi Almak:
Belirli bir ID’ye sahip bir öğeyi almak için Razor Page’lerde bir HTTP Get isteği ele almanız gerekir. Örneğin, bir “Details.cshtml” sayfasında bir ürünün detaylarını görüntülemek istiyorsak:
@page "{id:int}"
@model DetailsModel
@{
ViewData["Title"] = "Product Details";
}
<h1>Product Details</h1>
<div>
<h4>Product Name: @Model.Product.Name</h4>
<h4>Product Price: @Model.Product.Price</h4>
</div>
4. Page Model Sınıfında HTTP Get Metodunu Oluşturma:
Page Model sınıfında, HTTP Get isteğini ele alacak bir yöntem oluşturun:
public class DetailsModel : PageModel
{
private readonly ApplicationDbContext _context;
public DetailsModel(ApplicationDbContext context)
{
_context = context;
}
public Product Product { get; set; }
public IActionResult OnGet(int id)
{
Product = _context.Products.FirstOrDefault(p => p.Id == id);
if (Product == null)
{
return NotFound();
}
return Page();
}
}
Yukarıdaki kod, belirli bir ID’ye sahip ürünü veritabanından alır ve sonra Details.cshtml sayfasına aktarır. Eğer belirli bir ID’ye sahip ürün bulunamazsa NotFound() yöntemi çağrılarak 404 hatası döndürülür. Bu şekilde belirli bir ID’ye sahip veriyi almak ve görüntülemek için gerekli adımları gerçekleştirmiş olursunuz.
Service configuration in ASP.NET Razor Pages
Servis yapılandırması (Service configuration), ASP.NET Razor Pages uygulamalarında dış hizmetlerin (services) kaydedilmesi ve yapılandırılması işlemidir. Bu hizmetler genellikle bağımlılıkları yönetmek, veri erişimi sağlamak, kimlik doğrulaması, oturum yönetimi gibi işlevleri gerçekleştirir. Bu adımlar genellikle ConfigureServices metodunda gerçekleştirilir.
1. ConfigureServices Metodunu Güncelleme:
Startup.cs dosyasında ConfigureServices metodunda hizmetleri yapılandırır ve kaydederiz. Bu metod, uygulama başlatıldığında çağrılır ve hizmetlerin yapılandırılması için kullanılır. Örneğin, Entity Framework Core’un DbContext hizmetini yapılandıralım:
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
// Diğer servislerin kaydedilmesi
}
Yukarıdaki kodda, AddDbContext metodu ile ApplicationDbContext tipinde bir DbContext hizmeti ekledik. Bu hizmet, Entity Framework Core kullanarak veritabanı işlemleri gerçekleştirmemizi sağlar.
2. Scoped, Transient ve Singleton Servisleri Kullanma:
AddScoped, AddTransient, AddSingleton gibi metotlar aracılığıyla belirli bir yaşam döngüsüne sahip hizmetleri tanımlayabiliriz:
Örneğin, bir repository hizmetini scoped olarak kaydedelim:
services.AddScoped<IProductRepository, ProductRepository>();
3. Uygulama Bağımlılıklarını Enjekte Etme:
Servis yapılandırması ayrıca, hizmetlerin Razor Page’ler ve Page Model sınıflarına enjekte edilmesini sağlar. Bunun için constructor enjeksiyonunu kullanabiliriz:
public class IndexModel : PageModel
{
private readonly IProductRepository _productRepository;
public IndexModel(IProductRepository productRepository)
{
_productRepository = productRepository;
}
// Sayfa Modeli işlemleri burada devam eder...
}
Yukarıdaki kodda, IProductRepository türünde bir hizmetin constructor enjeksiyonu gerçekleştirilmiştir. Bu, IndexModel sınıfının IProductRepository bağımlılığına erişim sağlar.
Servis yapılandırması, uygulamanın genel yapılandırması ve bağımlılıkların yönetilmesi açısından önemli bir adımdır ve ASP.NET Razor Pages uygulamalarında yaygın olarak kullanılır.
Securing Razor Pages Applications
Authentication vs. authorization
Authentication ve authorization, ASP.NET Razor Pages uygulamalarında güvenlik açısından önemli iki kavramdır. Her ikisi de kullanıcıların uygulamaya erişimini kontrol etmeye yardımcı olur, ancak farklı amaçlara hizmet ederler.
1. Authentication (Kimlik Doğrulama):
Authentication, kullanıcıların kimliklerini doğrulamanın ve tanımlamanın bir sürecidir. Bir kullanıcının kimlik doğrulaması, kullanıcı adı ve şifre gibi kimlik bilgilerini sağlayarak veya sosyal medya hesapları gibi harici kaynaklardan doğrulama yaparak gerçekleşebilir. Temel amaç, kullanıcıyı tanımlamak ve kimlik bilgileriyle sağlanan erişim haklarını belirlemektir.
ASP.NET Core’da, kimlik doğrulaması için çeşitli yöntemler bulunmaktadır. Örneğin, kullanıcıların kimlik doğrulaması için yerleşik bir kimlik doğrulama sistemi kullanılabilir veya OpenID Connect, OAuth 2.0 gibi harici kimlik doğrulama sağlayıcılarına güvenilebilir.
2. Authorization (Yetkilendirme):
Authorization, kimlik doğrulamasından sonra, kullanıcıların belirli kaynaklara veya işlevlere erişimine izin verme veya reddetme sürecidir. Yani, bir kullanıcının kimlik doğrulaması yapıldıktan sonra belirli kaynaklara erişip erişemeyeceğini kontrol eder. Örneğin, belirli bir kullanıcının yalnızca belirli bir sayfaya veya belirli bir işleme erişimine izin verilip verilmeyeceğini belirler.
ASP.NET Core’da authorization, genellikle roller ve politikalar üzerinden sağlanır. Roller, belirli bir kullanıcı grubunun sahip olabileceği izinleri gruplar ve politikalar ise belirli bir kullanıcının erişimini belirler.
Kod Örnekleri:
// Yetkilendirme örneği - PageModel sınıfı
public class AdminModel : PageModel
{
private readonly UserManager<ApplicationUser> _userManager;
public AdminModel(UserManager<ApplicationUser> userManager)
{
_userManager = userManager;
}
public async Task<IActionResult> OnGetAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user != null && User.IsInRole("Admin"))
{
// Admin sayfasına erişim izni verildi
return Page();
}
// Yetkilendirme reddedildi
return RedirectToPage("/AccessDenied");
}
}
Yukarıdaki kod örneğinde, AdminModel sayfasında OnGetAsync metodu üzerinde yetkilendirme işlemi gerçekleştirilmiştir. User.IsInRole metodu ile kullanıcının “Admin” rolüne sahip olup olmadığı kontrol edilir ve buna göre erişim izni verilir veya reddedilir.
Bu şekilde, authentication ve authorization, ASP.NET Razor Pages uygulamalarında güvenliği sağlamak için birlikte kullanılır ve kullanıcıların uygulama içinde hangi kaynaklara erişebileceğini belirlerler.
Simple authorization in ASP.NET Razor Pages
Basit yetkilendirme (authorization), ASP.NET Razor Pages uygulamalarında kullanıcıların belirli sayfalara veya işlemlere erişimini kontrol etmek için kullanılan bir tekniktir. Bu yetkilendirme genellikle roller veya kullanıcı rolleri aracılığıyla gerçekleştirilir.
1. Rollerin Tanımlanması:
İlk adım, uygulamanızdaki farklı kullanıcı rollerini tanımlamaktır. Örneğin, “Admin” ve “User” gibi roller oluşturabiliriz.
2. Kullanıcıların Rollere Atanması:
Her kullanıcıya bir veya birden fazla rol atanmalıdır. Bu işlem genellikle kullanıcı kaydı veya yetkilendirme işlemi sırasında gerçekleştirilir.
3. Yetkilendirme Politikalarının Tanımlanması:
Yetkilendirme politikaları, hangi rollerin hangi sayfalara veya işlemlere erişebileceğini belirler. Örneğin, yalnızca “Admin” rolüne sahip kullanıcıların “Admin” sayfasına erişmesine izin verebiliriz.
4. Yetkilendirme Kontrollerinin Yapılması:
ASP.NET Razor Pages’te, her sayfa veya işlem özel olarak yetkilendirilebilir. PageModel sınıfında yetkilendirme kontrollerini gerçekleştirerek, erişimi kontrol edebiliriz.
public class AdminModel : PageModel
{
public IActionResult OnGet()
{
if (!User.Identity.IsAuthenticated)
{
return RedirectToPage("/Login");
}
if (!User.IsInRole("Admin"))
{
return RedirectToPage("/AccessDenied");
}
// Admin sayfasına erişim izni verildi
return Page();
}
}
Yukarıdaki kod, “Admin” sayfasına erişim izni vermek için basit bir yetkilendirme kontrolü yapar. İlk olarak, kullanıcının kimlik doğrulamasının yapılıp yapılmadığı kontrol edilir. Ardından, kullanıcının “Admin” rolüne sahip olup olmadığı kontrol edilir. Eğer kullanıcı kimlik doğrulaması yapılmış ve “Admin” rolüne sahipse, Admin sayfasına erişim izni verilir. Aksi takdirde, kullanıcı giriş yapmamışsa “Login” sayfasına yönlendirilir veya “Admin” rolüne sahip olmadığı için “AccessDenied” sayfasına yönlendirilir.
Bu basit yetkilendirme kontrolü, kullanıcıların erişebileceği sayfaları ve işlemleri kontrol etmek için kullanılabilir. Daha karmaşık senaryolarda, yetkilendirme politikaları ve rollerin daha ayrıntılı bir şekilde kullanılması gerekebilir.
Role-based authorization in ASP.NET Razor Pages
Role-based authorization, ASP.NET Razor Pages uygulamalarında belirli sayfalara veya işlemlere erişimi, kullanıcı rolleri üzerinden kontrol etmek için kullanılan bir yetkilendirme tekniğidir. Bu teknik, uygulamaya erişimi belirli rollerle sınırlayarak güvenlik sağlar.
1. Rollerin Tanımlanması:
İlk adım, uygulamanızda kullanılacak rolleri tanımlamaktır. Örneğin, “Admin”, “User” gibi roller oluşturabiliriz.
2. Rollerin Kullanıcılara Atanması:
Her kullanıcıya bir veya birden fazla rol atanır. Bu işlem genellikle kullanıcı kaydı veya yetkilendirme sırasında gerçekleştirilir.
3. Yetkilendirme Politikalarının Tanımlanması:
Yetkilendirme politikaları, hangi rollerin hangi sayfalara veya işlemlere erişebileceğini belirler. Örneğin, yalnızca “Admin” rolüne sahip kullanıcıların “Admin” sayfasına erişmesine izin vermek gibi.
4. Yetkilendirme Kontrollerinin Yapılması:
ASP.NET Razor Pages’te, her sayfa veya işlem özel olarak yetkilendirilebilir. PageModel sınıfında yetkilendirme kontrollerini gerçekleştirerek, erişimi kontrol edebiliriz.
public class AdminModel : PageModel
{
public IActionResult OnGet()
{
if (!User.Identity.IsAuthenticated)
{
return RedirectToPage("/Login");
}
if (!User.IsInRole("Admin"))
{
return RedirectToPage("/AccessDenied");
}
// Admin sayfasına erişim izni verildi
return Page();
}
}
Yukarıdaki kod, “Admin” sayfasına erişim izni vermek için basit bir role-based authorization kontrolü yapar. İlk olarak, kullanıcının kimlik doğrulamasının yapıldığı kontrol edilir. Ardından, kullanıcının “Admin” rolüne sahip olup olmadığı kontrol edilir. Eğer kullanıcı kimlik doğrulaması yapılmış ve “Admin” rolüne sahipse, Admin sayfasına erişim izni verilir. Aksi takdirde, kullanıcı giriş yapmamışsa “Login” sayfasına yönlendirilir veya “Admin” rolüne sahip olmadığı için “AccessDenied” sayfasına yönlendirilir.
Role-based authorization, kullanıcıların uygulamadaki rollerine bağlı olarak erişim izinlerini kontrol etmek için yaygın olarak kullanılan bir yaklaşımdır. Bu şekilde, uygulamanızı güvenli hale getirebilir ve hassas işlemleri yalnızca belirli kullanıcı rollerine sahip olanlara sağlayabilirsiniz.
Claims-based authorization in ASP.NET Razor Pages
Claims-based authorization, ASP.NET Razor Pages uygulamalarında yetkilendirme için kullanılan bir yaklaşımdır. Bu yaklaşım, kullanıcıların erişim yetkilerini belirlemek için iddiaların (claims) kullanılmasını temel alır. Bir iddia, kullanıcının belirli bir özelliğine veya iznine ilişkin bilgileri temsil eder. Örneğin, bir kullanıcının “Admin” veya “User” gibi bir rolü olabilir, ya da bir kullanıcının belirli bir kaynağa erişim izni olabilir.
1. Claims’lerin Tanımlanması:
İlk adım, uygulamanızdaki farklı claims’leri tanımlamaktır. Bu, rollerden daha geniş bir yetkilendirme sağlar çünkü kullanıcıların rol dışında belirli yetkilere veya özelliklere sahip olmalarını sağlar.
2. Claims’lerin Kullanıcılara Atanması:
Her kullanıcıya bir veya birden fazla claim atanabilir. Bu işlem genellikle kullanıcı kaydı veya girişi sırasında gerçekleştirilir.
3. Yetkilendirme Politikalarının Tanımlanması:
Claims-based authorization’da, yetkilendirme politikaları, hangi claims’lere sahip kullanıcıların hangi sayfalara veya işlemlere erişebileceğini belirler.
4. Yetkilendirme Kontrollerinin Yapılması:
ASP.NET Razor Pages’te, her sayfa veya işlem özel olarak yetkilendirilebilir. PageModel sınıfında yetkilendirme kontrollerini gerçekleştirerek, erişimi kontrol edebiliriz.
public class AdminModel : PageModel
{
public IActionResult OnGet()
{
if (!User.Identity.IsAuthenticated)
{
return RedirectToPage("/Login");
}
if (!User.HasClaim(c => c.Type == "role" && c.Value == "Admin"))
{
return RedirectToPage("/AccessDenied");
}
// Admin sayfasına erişim izni verildi
return Page();
}
}
Yukarıdaki kod, “Admin” sayfasına erişim izni vermek için basit bir claims-based authorization kontrolü yapar. İlk olarak, kullanıcının kimlik doğrulamasının yapıldığı kontrol edilir. Ardından, kullanıcının “role” tipinde ve “Admin” değerine sahip bir claim’e sahip olup olmadığı kontrol edilir. Eğer kullanıcı kimlik doğrulaması yapılmış ve gerekli claim’e sahipse, Admin sayfasına erişim izni verilir. Aksi takdirde, kullanıcı giriş yapmamışsa “Login” sayfasına yönlendirilir veya gerekli claim’e sahip olmadığı için “AccessDenied” sayfasına yönlendirilir.
Claims-based authorization, rollerin dışında daha geniş bir yetkilendirme sağlar ve kullanıcıların belirli özelliklere veya izinlere dayalı olarak erişim izinlerini kontrol etmek için kullanılabilir. Bu şekilde, uygulamanızı daha esnek ve güvenli hale getirebilirsiniz.
Hiç kimse geriye gidip yeni bir başlangıç yapamaz ama bugün yeni bir son yapıp yeniden başlayabilir.
Frank M. Robinson
Bir sonraki yazıda görüşmek dileğiyle!”
