İlk Uygulama - Kütüphane

Asp.Net Core

08.05.2025 .NET SDK 8.0.100

ASP.NET Core 8.0 MVC ile temel CRUD (Create, Read, Update, Delete) işlemlerini içeren bir Kütüphane Kitap Takip Sistemi projesi yapacağız.

Bu projede .NET SDK 8.0.100 sürümünü kullanacağız. Bu sürümü indirmek için tıklayın.
Projede IDE olarak Visual Studio Code kullanacağız.
Veri tabanı olarak MS SQL Server kullanacağız.

#1 Proje Ortamını Hazırlama

Boş bir klasör oluşturun (örneğin, KutuphaneProjesi).
VS Code'u bu klasörde açın.

Önce '.global.json' dosyasını oluşturalım, bu dosya .NET projelerinde kullanılacak SDK sürümünü belirleyerek, farklı sürümler arasındaki uyumsuzlukları engeller ve projenin belirli bir SDK sürümüyle derlenmesini sağlar.

Terminale:

            
dotnet new globaljson --sdk-version 8.0.100

Sonra projemizi oluşturalım. Terminale:

            
dotnet new mvc -n KutuphaneTakipSistemi -o KutuphaneTakipSistemi --framework net8.0

-n KutuphaneTakipSistemi: Proje adı.
-o KutuphaneTakipSistemi: Projenin oluşturulacağı klasör adı.
--framework net8.0: .NET 8.0 kullanılacağını belirtir.

Bu komut, "KutuphaneTakipSistemi" adında yeni bir ASP.NET Core MVC projesi oluşturur ve gerekli dosyaları bu klasöre yerleştirir.
Proje oluşturulduktan sonra, projenin kök dizinine gidin:

            
cd KutuphaneTakipSistemi

#2 Gerekli NuGet Paketlerini Ekleme

Gerekli NuGet paketlerini yüklemek için terminale:

            
dotnet add package Microsoft.EntityFrameworkCore.SqlServer --version 8.0.0

dotnet add package Microsoft.EntityFrameworkCore.Tools  --version 8.0.0

dotnet add package Microsoft.EntityFrameworkCore.Design  --version 8.0.0

Microsoft.EntityFrameworkCore.SqlServer: SQL Server veritabanı sağlayıcısı.

Microsoft.EntityFrameworkCore.Tools: EF Core komut satırı araçları (migrations vb. için).

Microsoft.EntityFrameworkCore.Design: Tasarım zamanı EF Core işlevselliği için.

#3 Model Oluşturma

Şimdi Kitap modelini oluşturalım.
Models klasörüne sağ tıklayıp New Class seçeneğini tıklayın.
Kitap.cs adında bir sınıf oluşturun.

            
public class Kitap
{
    public int Id { get; set; }

    [Required(ErrorMessage = "Kitap adı boş bırakılamaz.")]
    [StringLength(200, MinimumLength = 2, ErrorMessage = "Kitap adı en az 2, en fazla 200 karakter olmalıdır.")]
    [Display(Name = "Kitap Adı")]
    public string? KitapAdi { get; set; } // ? nullable yapar, Required ile zorunlu kılınır.

    [Required(ErrorMessage = "Yazar adı boş bırakılamaz.")]
    [StringLength(100, ErrorMessage = "Yazar adı en fazla 100 karakter olmalıdır.")]
    public string? Yazar { get; set; }

    [StringLength(100, ErrorMessage = "Yayınevi en fazla 100 karakter olmalıdır.")]
    public string? Yayinevi { get; set; }
}

Kitap sınıfı, kitapların temel özelliklerini temsil eder. Bu sınıfın özellikleri, kitapların veritabanında saklanacak bilgilerini temsil eder.

Id: Kitabın benzersiz kimliğini temsil eder. Bu özellik veritabanında otomatik olarak artan bir tamsayı olarak tanımlanır.
KitapAdi: Kitabın adını temsil eder. Bu özellik, kitap adı boş bırakılamaz ve en az 2, en fazla 200 karakter olmalıdır.
Yazar: Kitabın yazarını temsil eder. Bu özellik, yazar adı boş bırakılamaz ve en fazla 100 karakter olmalıdır.
Yayinevi: Kitabın yayınevini temsil eder. Bu özellik, en fazla 100 karakter olmalıdır.

#4 Veritabanı Bağlam Sınıfı (DbContext) Oluşturma

Şimdi AppDbContext sınıfını oluşturalım.
Proje klasörüne sağ tıklayıp New Folder seçeneğini tıklayın ve Data adında bir klasör oluşturun.
Data klasörüne sağ tıklayıp New Class seçeneğini tıklayın.
AppDbContext.cs adında bir sınıf oluşturun.
AppDbContext sınıfı, Entity Framework Core ile veritabanı bağlantısını ve kitapların yönetimini sağlar.

            
public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options)
        : base(options) { }

    public DbSet<Kitap> Kitaplar { get; set; }
}

#5 DbContext'i Servislere Kaydetme (Program.cs)

Projenin kök dizininde bulunan Program.cs dosyasını açın.
Add services to the container kısmına aşağıdaki kodu ekleyin:
DbContext sınıfını servislere kaydedelim:

            
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("LocalConnection")));

#6 Veritabanı Bağlantı Dizesi (Connection String) Ayarlama

Projenin kök dizininde bulunan appsettings.json dosyasını açın.
ConnectionStrings bölümüne aşağıdaki bağlantı dizesini ekleyin:

            
{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "LocalConnection": "Server=localhost; Database=Kutuphane; Trusted_Connection=True; TrustServerCertificate=True"
  }
}

Server=(localdb)\\MSSQLLocalDB: SQL Server LocalDB sunucusunu kullanır.
Database=Kutuphane: Veritabanı adı. Bu isimle yeni bir veritabanı oluşturulacak.
Trusted_Connection=True: Windows kimlik doğrulaması kullanılır.

#7 Migration Oluşturma ve Veritabanını Güncelleme

şimdi migration oluşturalım. Migration, veritabanı şemasındaki değişiklikleri temsil eden bir dosyadır. Bu dosya, veritabanı şemasını güncellemek için gerekli olan SQL komutlarını içerir.
Terminale:

            
 dotnet ef migrations add InitialCreate -o Data/Migrations

InitialCreate: Migration adı. Bu isimle yeni bir migration oluşturulacak.
-o Data/Migrations: Migration dosyalarının kaydedileceği klasör. Bu klasör Data klasörü içinde Migrations adında bir klasör oluşturur.

Eğer bu kodu çalıştırırken hata alırsanız dotnet ef yüklü değildir.

Eğer hata vermediyse, migration oluşturulmuştur.
Diğer adıma geçin.
dotnet ef yüklemek için:
Terminale:

            
dotnet tool install --global dotnet-ef

Migration oluşturulduktan sonra, veritabanını güncellemek için terminale:

            
dotnet ef database update

Bu komut, veritabanını günceller ve migration dosyasında tanımlanan değişiklikleri uygular.

MS SQL Server Management Studio (SSMS) ile veritabanını kontrol edin.

#8 Kitaplar için Controller Oluşturma

Şimdi Kitaplar için Controller oluşturalım.
Controllers klasörüne sağ tıklayıp New Class seçeneğini tıklayın.
KitapController.cs adında bir sınıf oluşturun.

KitapController sınıfı, kitapların yönetimi için gerekli olan işlemleri sağlar. Bu sınıf, Entity Framework Core kullanarak veritabanı ile etkileşimde bulunur.

Önce AppDbContext'i ekleyelim:

            
public class KitapController : Controller
{
    private readonly ILogger<KitapController> _logger;
    private readonly AppDbContext _context;

    public KitapController(ILogger<KitapController> logger, AppDbContext context)
    {
        _logger = logger;
        _context = context;
    }

    // burada diğer metotları ekleyeceğiz

Index() Metodu (GET)

HTTP İsteği: Genellikle GET isteği ile /Kitaplar veya /Kitaplar/Index adresine yapılan istekleri karşılar.

Amacı: Veritabanındaki tüm kitapları listelemek.

İşleyişi:
await _context.Kitaplar.ToListAsync(): Veritabanındaki Kitaplar tablosundan tüm kayıtları asenkron olarak çeker ve bir liste (List<Kitap>) haline getirir.
return View(...): Elde edilen kitap listesini Views/Kitap/Index.cshtml view'ına model olarak gönderir. Bu view, aldığı listeyi kullanarak kitapları tablo formatında kullanıcıya gösterir.

            
// GET: Kitaplar
public async Task<IActionResult> Index()
{
    // Veritabanındaki tüm kitapları al ve Index view'ına gönder.
    return View(await _context.Kitaplar.ToListAsync());
}

Details(int? id) Metodu (GET)

HTTP İsteği: GET isteği ile /Kitaplar/Details/5 (burada 5, kitabın ID'sidir) gibi bir adrese yapılan istekleri karşılar.

Amacı: Belirli bir ID'ye sahip kitabın detaylarını göstermek.

İşleyişi:
if (id == null): Eğer metoda bir id parametresi gönderilmemişse (URL'de ID yoksa), NotFound() (HTTP 404) sonucu döndürülür.
var kitap = await _context.Kitaplar.FirstOrDefaultAsync(m => m.Id == id): Veritabanından, gönderilen id ile eşleşen ilk kitabı asenkron olarak bulur.
if (kitap == null): Eğer belirtilen id ile bir kitap bulunamazsa, yine NotFound() döndürülür.
return View(kitap): Bulunan kitap nesnesini Views/Kitaplar/Details.cshtml view'ına model olarak gönderir. Bu view, kitabın özelliklerini kullanıcıya gösterir.

            
// GET: Kitaplar/Details/5
public async Task<IActionResult> Details(int? id)
{
    if (id == null)
    {
        return NotFound(); // ID yoksa 404 hatası ver.
    }

    var kitap = await _context.Kitaplar
        .FirstOrDefaultAsync(m => m.Id == id); // ID'ye göre kitabı bul.
    if (kitap == null)
    {
        return NotFound(); // Kitap bulunamazsa 404 hatası ver.
    }

    return View(kitap); // Bulunan kitabı Details view'ına gönder.
}

Create() Metodu (GET)

HTTP İsteği: GET isteği ile /Kitaplar/Create adresine yapılan istekleri karşılar.

Amacı: Yeni bir kitap eklemek için boş bir form göstermek.

İşleyişi:
return View(): Views/Kitaplar/Create.cshtml view'ını çağırır. Bu view, kullanıcıdan kitap bilgilerini (Kitap Adı, Yazar, Yayınevi) girmesini isteyen bir form içerir. Bu aşamada view'a herhangi bir model gönderilmez çünkü form boş olacaktır.

            
// GET: Kitaplar/Create
public IActionResult Create()
{
    // Yeni kitap oluşturma formunu göster (Create.cshtml).
    return View();
}

Create([Bind("Id,KitapAdi,Yazar,Yayinevi")] Kitap kitap) Metodu (POST)

HTTP İsteği: POST isteği ile /Kitaplar/Create adresine, form verileriyle birlikte yapılan istekleri karşılar.

Amacı: Kullanıcının Create formunda girdiği bilgilerle yeni bir kitap oluşturup veritabanına kaydetmek.

Öznitelikler:
[HttpPost]: Bu metodun sadece HTTP POST isteklerine yanıt vereceğini belirtir.
[ValidateAntiForgeryToken]: CSRF (Cross-Site Request Forgery) ataklarına karşı koruma sağlar. Formda gizli bir token oluşturulur ve sunucu bu token'ı doğrular.
[Bind("Id,KitapAdi,Yazar,Yayinevi")] Kitap kitap: ASP.NET Core'un model binding özelliğini kullanır. Formdan gelen verileri Kitap nesnesinin belirtilen özelliklerine (Id, KitapAdi, Yazar, Yayinevi) eşler. Bind attribute'u, gereksiz veya kötü niyetli veri gönderimini (overposting) engellemek için hangi özelliklerin bağlanacağını kısıtlar. Id burada belirtilmiş olsa da genellikle yeni kayıtlarda veritabanı tarafından otomatik atanır, bu yüzden formdan gelmesine gerek yoktur, ancak Bind listesinde olması bir zarara yol açmaz.

İşleyişi:
if (ModelState.IsValid): Kitap modelindeki doğrulama kuralları (örneğin [Required], [StringLength]) kontrol edilir. Eğer tüm kurallar sağlanıyorsa (form verileri geçerliyse):
_context.Add(kitap): Yeni kitap nesnesini Entity Framework Core context'ine ekler. Bu aşamada veritabanına henüz yazılmaz, sadece takip edilmeye başlanır.
await _context.SaveChangesAsync(): Context'teki değişiklikleri (bu durumda yeni kitap eklenmesi) asenkron olarak veritabanına kaydeder.
return RedirectToAction(nameof(Index)): İşlem başarılı olursa kullanıcıyı kitap listesinin olduğu Index action'ına yönlendirir. nameof(Index) kullanımı, "Index" string'ini doğrudan yazmak yerine tip güvenli bir yol sunar.
return View(kitap): Eğer ModelState geçerli değilse (formda hatalı veya eksik veri varsa), aynı Create.cshtml view'ı, kullanıcının girdiği kitap verileri ve doğrulama hataları ile birlikte tekrar gösterilir. Kullanıcı böylece hatalarını görüp düzeltebilir.

            
// POST: Kitaplar/Create
[HttpPost]
[ValidateAntiForgeryToken] // CSRF koruması
public async Task<IActionResult> Create([Bind("Id,KitapAdi,Yazar,Yayinevi")] Kitap kitap)
{
    if (ModelState.IsValid) // Model doğrulama kuralları geçerli mi?
    {
        _context.Add(kitap); // Kitabı context'e ekle.
        await _context.SaveChangesAsync(); // Değişiklikleri veritabanına kaydet.
        return RedirectToAction(nameof(Index)); // Kitap listesine yönlendir.
    }
    return View(kitap); // Model geçerli değilse, formu hatalarla birlikte tekrar göster.
}

Edit(int? id) Metodu (GET)

HTTP İsteği: GET isteği ile /Kitaplar/Edit/5 gibi bir adrese yapılan istekleri karşılar.

Amacı: Belirli bir ID'ye sahip kitabı düzenlemek için bilgileriyle dolu bir form göstermek.

İşleyişi:
id == null ve kitap == null kontrolleri Details metoduyla aynıdır.
var kitap = await _context.Kitaplar.FindAsync(id): Veritabanından, id'si verilen kitabı primary key üzerinden asenkron olarak bulur. FindAsync genellikle primary key aramalarında daha etkilidir.
return View(kitap): Bulunan kitap nesnesini Views/Kitaplar/Edit.cshtml view'ına model olarak gönderir. Bu view, kitabın mevcut bilgilerini form alanlarına doldurulmuş şekilde gösterir.

            
// GET: Kitaplar/Edit/5
public async Task<IActionResult> Edit(int? id)
{
    if (id == null)
    {
        return NotFound();
    }

    var kitap = await _context.Kitaplar.FindAsync(id); // ID'ye göre kitabı bul.
    if (kitap == null)
    {
        return NotFound();
    }
    return View(kitap); // Bulunan kitabı Edit view'ına gönder (formu doldurmak için).
}

Edit(int id, [Bind("Id,KitapAdi,Yazar,Yayinevi")] Kitap kitap) Metodu (POST)

HTTP İsteği: POST isteği ile /Kitaplar/Edit/5 adresine, form verileriyle birlikte yapılan istekleri karşılar.

Amacı: Kullanıcının Edit formunda değiştirdiği bilgilerle mevcut bir kitabı güncelleyip veritabanına kaydetmek.

Öznitelikler: [HttpPost], [ValidateAntiForgeryToken], [Bind(...)] aynı Create (POST) metodundaki gibidir.

İşleyişi:
if (id != kitap.Id): Eğer URL'deki id ile formdan gelen kitap nesnesinin id'si eşleşmiyorsa, NotFound() döndürülür. Bu, kullanıcı URL'yi değiştirmişse veya başka bir hata varsa kontrol eder.
if (ModelState.IsValid): Kitap modelindeki doğrulama kuralları kontrol edilir. Eğer tüm kurallar sağlanıyorsa:
_context.Update(kitap): Kitap nesnesini güncellenmek üzere context'e ekler. Bu aşamada veritabanına henüz yazılmaz, sadece takip edilmeye başlanır.
await _context.SaveChangesAsync(): Context'teki değişiklikleri (bu durumda kitabın güncellenmesi) asenkron olarak veritabanına kaydeder.
return RedirectToAction(nameof(Index)): İşlem başarılı olursa kullanıcıyı kitap listesinin olduğu Index action'ına yönlendirir.
catch (DbUpdateConcurrencyException): Eğer güncelleme sırasında bir eşzamanlılık hatası oluşursa (örneğin, başka bir yerde kitap silinmişse), bu hata yakalanır ve kitabın hala veritabanında olup olmadığını kontrol eder. Eğer kitap yoksa NotFound() döndürülür, aksi takdirde hata fırlatılır.
return View(kitap): Eğer ModelState geçerli değilse (formda hatalı veya eksik veri varsa), aynı Edit.cshtml view'ı, kullanıcının girdiği kitap verileri ve doğrulama hataları ile birlikte tekrar gösterilir. Kullanıcı böylece hatalarını görüp düzeltebilir.

            
// POST: Kitaplar/Edit/5
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Edit(
    int id,
    [Bind("Id,KitapAdi,Yazar,Yayinevi")] Kitap kitap
)
{
    if (id != kitap.Id)
    {
        return NotFound();
    }

    if (ModelState.IsValid)
    {
        try
        {
            _context.Update(kitap);
            await _context.SaveChangesAsync();
        }
        catch (DbUpdateConcurrencyException)
        {
            // Kitabın hala veritabanında olup olmadığını doğrudan burada kontrol ediyoruz
            if (!_context.Kitaplar.Any(e => e.Id == kitap.Id))
            {
                return NotFound();
            }
            else
            {
                throw;
            }
        }
        return RedirectToAction(nameof(Index));
    }
    return View(kitap);
}

Delete(int? id) Metodu (GET)

HTTP İsteği: GET isteği ile /Kitaplar/Delete/5 gibi bir adrese yapılan istekleri karşılar.

Amacı: Belirli bir ID'ye sahip kitabı silmeden önce kullanıcıya onay sayfasını göstermek.

İşleyişi:
id == null ve kitap == null kontrolleri Details ve Edit (GET) metotlarıyla aynıdır.
var kitap = await _context.Kitaplar.FirstOrDefaultAsync(m => m.Id == id): Silinecek kitabı bulur.
return View(kitap): Bulunan kitap nesnesini Views/Kitaplar/Delete.cshtml view'ına gönderir. Bu view, kitabın bilgilerini gösterir ve "Bu kitabı silmek istediğinizden emin misiniz?" gibi bir onay sorusu sorar.

            
// GET: Kitaplar/Delete/5
public async Task<IActionResult> Delete(int? id)
{
    if (id == null)
    {
        return NotFound();
    }

    var kitap = await _context.Kitaplar
        .FirstOrDefaultAsync(m => m.Id == id); // ID'ye göre kitabı bul.
    if (kitap == null)
    {
        return NotFound();
    }

    return View(kitap); // Bulunan kitabı Delete view'ına gönder (onay için).
}

DeleteConfirmed(int id) Metodu (POST)

HTTP İsteği: POST isteği ile /Kitaplar/Delete/5 adresine yapılan (genellikle Delete.cshtml'deki onay formundan gelen) istekleri karşılar.

Amacı: Kullanıcının onay vermesi durumunda belirli bir ID'ye sahip kitabı veritabanından silmek.

Öznitelikler:
[HttpPost, ActionName("Delete")]: Bu metodun HTTP POST isteklerine yanıt vereceğini belirtir. ActionName("Delete") özniteliği, metodun adının DeleteConfirmed olmasına rağmen URL'de /Kitaplar/Delete olarak çağrılabilmesini sağlar. Bu, GET ve POST için aynı URL'yi kullanırken metot adlarını farklılaştırmak için yaygın bir tekniktir.
[ValidateAntiForgeryToken]: CSRF koruması.

İşleyişi:
var kitap = await _context.Kitaplar.FindAsync(id): Silinecek kitabı id ile bulur.
if (kitap != null): Eğer kitap bulunursa:
_context.Kitaplar.Remove(kitap): Kitabı context'ten silinmek üzere işaretler.
await _context.SaveChangesAsync(): Değişiklikleri (kitabın silinmesi) veritabanına kaydeder. Kitap bulunamazsa bile SaveChanges çağrılır, bu durumda bir işlem yapılmaz.
return RedirectToAction(nameof(Index)): İşlem sonrası kullanıcıyı kitap listesine yönlendirir.

            
// POST: Kitaplar/Delete/5
[HttpPost, ActionName("Delete")] // Form POST edildiğinde bu metod çalışır (URL hala /Delete/5).
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
    var kitap = await _context.Kitaplar.FindAsync(id); // Silinecek kitabı bul.
    if (kitap != null)
    {
        _context.Kitaplar.Remove(kitap); // Kitabı context'ten silinmek üzere işaretle.
    }
    
    await _context.SaveChangesAsync(); // Değişiklikleri veritabanına kaydet.
    return RedirectToAction(nameof(Index)); // Kitap listesine yönlendir.
}

#8 Navigasyon Menüsüne Bağlantı Ekleme

Projenizin kök dizininde bulunan Views/Shared/_Layout.cshtml dosyasını açın.
_Layout.cshtml dosyası, uygulamanızın genel yapısını ve menü yapısını tanımlar.
Şimdi menüye yeni bir bağlantı ekleyelim.
_Layout.cshtml dosyasının içinde, <ul class="navbar-nav"> etiketinin içinde, <li class="nav-item"> etiketi ile yeni bir bağlantı oluşturun.

            
<li class="nav-item">
    <a class="nav-link text-dark" asp-area="" asp-controller="Kitap" asp-action="Index">Kitaplar</a>
</li>

Bu kod, üst menüye "Kitaplar" adında yeni bir bağlantı ekler ve tıklandığında Kitaplar/Index action'ına yönlendirir.

#9 View Oluşturma (Index, Details, Create, Edit, Delete)

Şimdi kitaplar için gerekli olan view'ları oluşturalım.

Views/Kitap/Index.cshtml

Views/Kitaplar klasörüne sağ tıklayıp Add > New File seçeneğini tıklayın.
Index.cshtml adında bir view oluşturun.

Index.cshtml view'ı, kitapların listesini gösterir. Bu view, KitapController'daki Index() metodundan gelen kitap listesini alır ve tablo formatında gösterir.

Index.cshtml view'ının içeriği:

            
@model IEnumerable<KutuphaneTakipSistemi.Models.Kitap>

@{
    ViewData["Title"] = "Kitap Listesi";
}

<h1>Kitap Listesi</h1>

<p>
    <a asp-action="Create" class="btn btn-primary">Yeni Kitap Ekle</a>
</p>
<table class="table table-striped table-hover">
    <thead>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.KitapAdi)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Yazar)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.Yayinevi)
            </th>
            <th>İşlemler</th>
        </tr>
    </thead>
    <tbody>
@foreach (var item in Model) {
        <tr>
            <td>
                @Html.DisplayFor(modelItem => item.KitapAdi)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Yazar)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.Yayinevi)
            </td>
            <td>
                <a asp-action="Edit" asp-route-id="@item.Id" class="btn btn-sm btn-warning">Düzenle</a> |
                <a asp-action="Details" asp-route-id="@item.Id" class="btn btn-sm btn-info">Detaylar</a> |
                <a asp-action="Delete" asp-route-id="@item.Id" class="btn btn-sm btn-danger">Sil</a>
            </td>
        </tr>
}
    </tbody>
</table>

Bu view, kitapların listesini tablo formatında gösterir. Her kitap için "Düzenle", "Detaylar" ve "Sil" butonları vardır.

Views/Kitaplar/Create.cshtml

Views/Kitaplar klasörüne sağ tıklayıp Add > New File seçeneğini tıklayın.
Create.cshtml adında bir view oluşturun.

            
@model KutuphaneTakipSistemi.Models.Kitap

@{
    ViewData["Title"] = "Yeni Kitap Ekle";
}

<h1>Yeni Kitap Ekle</h1>

<h4>Kitap Bilgileri</h4>
<hr />
<div class="row">
    <div class="col-md-4">
        <form asp-action="Create">
            <div asp-validation-summary="ModelOnly" class="text-danger"></div>
            <div class="form-group mb-3">
                <label asp-for="KitapAdi" class="control-label"></label>
                <input asp-for="KitapAdi" class="form-control" />
                <span asp-validation-for="KitapAdi" class="text-danger"></span>
            </div>
            <div class="form-group mb-3">
                <label asp-for="Yazar" class="control-label"></label>
                <input asp-for="Yazar" class="form-control" />
                <span asp-validation-for="Yazar" class="text-danger"></span>
            </div>
            <div class="form-group mb-3">
                <label asp-for="Yayinevi" class="control-label"></label>
                <input asp-for="Yayinevi" class="form-control" />
                <span asp-validation-for="Yayinevi" class="text-danger"></span>
            </div>
            <div class="form-group">
                <input type="submit" value="Oluştur" class="btn btn-primary" />
                <a asp-action="Index" class="btn btn-secondary">Listeye Geri Dön</a>
            </div>
        </form>
    </div>
</div>

@section Scripts {
    @{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}

Bu view, yeni bir kitap eklemek için bir form içerir. Kullanıcıdan kitap adı, yazar ve yayınevi bilgilerini alır.

Form gönderildiğinde, Create() metoduna yönlendirilir ve kitap bilgileri veritabanına kaydedilir.

Views/Kitaplar/Edit.cshtml

Views/Kitaplar klasörüne sağ tıklayıp Add > New File seçeneğini tıklayın.
Edit.cshtml adında bir view oluşturun.

            
@model KutuphaneTakipSistemi.Models.Kitap

@{
    ViewData["Title"] = "Kitap Düzenle";
}

<h1>Kitap Düzenle</h1>

<h4>Kitap Bilgileri</h4>
<hr />
<div class="row">
    <div class="col-md-4">
        <form asp-action="Edit">
            <div asp-validation-summary="ModelOnly" class="text-danger"></div>
            <input type="hidden" asp-for="Id" />
            <div class="form-group mb-3">
                <label asp-for="KitapAdi" class="control-label"></label>
                <input asp-for="KitapAdi" class="form-control" />
                <span asp-validation-for="KitapAdi" class="text-danger"></span>
            </div>
            <div class="form-group mb-3">
                <label asp-for="Yazar" class="control-label"></label>
                <input asp-for="Yazar" class="form-control" />
                <span asp-validation-for="Yazar" class="text-danger"></span>
            </div>
            <div class="form-group mb-3">
                <label asp-for="Yayinevi" class="control-label"></label>
                <input asp-for="Yayinevi" class="form-control" />
                <span asp-validation-for="Yayinevi" class="text-danger"></span>
            </div>
            <div class="form-group">
                <input type="submit" value="Kaydet" class="btn btn-primary" />
                  <a asp-action="Index" class="btn btn-secondary">Listeye Geri Dön</a>
            </div>
        </form>
    </div>
</div>

@section Scripts {
    @{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}

Bu view, mevcut bir kitabı düzenlemek için bir form içerir. Kullanıcıdan kitap adı, yazar ve yayınevi bilgilerini alır.

Form gönderildiğinde, Edit() metoduna yönlendirilir ve kitap bilgileri güncellenir.

Views/Kitaplar/Details.cshtml

Views/Kitaplar klasörüne sağ tıklayıp Add > New File seçeneğini tıklayın.
Details.cshtml adında bir view oluşturun.

            
@model KutuphaneTakipSistemi.Models.Kitap

@{
    ViewData["Title"] = "Kitap Detayları";
}

<h1>Kitap Detayları</h1>

<div>
    <h4>Kitap</h4>
    <hr />
    <dl class="row">
        <dt class = "col-sm-2">
            @Html.DisplayNameFor(model => model.KitapAdi)
        </dt>
        <dd class = "col-sm-10">
            @Html.DisplayFor(model => model.KitapAdi)
        </dd>
        <dt class = "col-sm-2">
            @Html.DisplayNameFor(model => model.Yazar)
        </dt>
        <dd class = "col-sm-10">
            @Html.DisplayFor(model => model.Yazar)
        </dd>
        <dt class = "col-sm-2">
            @Html.DisplayNameFor(model => model.Yayinevi)
        </dt>
        <dd class = "col-sm-10">
            @Html.DisplayFor(model => model.Yayinevi)
        </dd>
    </dl>
</div>
<div>
    <a asp-action="Edit" asp-route-id="@Model?.Id" class="btn btn-warning">Düzenle</a> |
    <a asp-action="Index" class="btn btn-secondary">Listeye Geri Dön</a>
</div>

Bu view, belirli bir kitabın detaylarını gösterir. Kitap adı, yazar ve yayınevi bilgilerini gösterir.

"Düzenle" butonuna tıklandığında Edit() metoduna yönlendirilir.
"Listeye Geri Dön" butonuna tıklandığında Index() metoduna yönlendirilir.

Views/Kitaplar/Delete.cshtml

Views/Kitaplar klasörüne sağ tıklayıp Add > New File seçeneğini tıklayın.
Delete.cshtml adında bir view oluşturun.

            
@model KutuphaneTakipSistemi.Models.Kitap

@{
    ViewData["Title"] = "Kitap Sil";
}

<h1>Kitap Sil</h1>

<h3>Bu kitabı silmek istediğinizden emin misiniz?</h3>
<div>
    <h4>Kitap Bilgileri</h4>
    <hr />
    <dl class="row">
        <dt class = "col-sm-2">
            @Html.DisplayNameFor(model => model.KitapAdi)
        </dt>
        <dd class = "col-sm-10">
            @Html.DisplayFor(model => model.KitapAdi)
        </dd>
        <dt class = "col-sm-2">
            @Html.DisplayNameFor(model => model.Yazar)
        </dt>
        <dd class = "col-sm-10">
            @Html.DisplayFor(model => model.Yazar)
        </dd>
        <dt class = "col-sm-2">
            @Html.DisplayNameFor(model => model.Yayinevi)
        </dt>
        <dd class = "col-sm-10">
            @Html.DisplayFor(model => model.Yayinevi)
        </dd>
    </dl>
    
    <form asp-action="Delete">
        <input type="hidden" asp-for="Id" />
        <input type="submit" value="Sil" class="btn btn-danger" /> |
        <a asp-action="Index" class="btn btn-secondary">Listeye Geri Dön</a>
    </form>
</div>

#10 Projeyi Çalıştırma ve Test Etme

Projeyi çalıştırmak için terminale gidin ve aşağıdaki komutu çalıştırın:

            
dotnet run

Proje çalıştığınızda,
Kitaplar menüsüne tıklayın ve kitapların listesini görüntüleyin.
Yeni bir kitap ekleyin, düzenleyin ve silin. Herhangi bir hata alırsanız, kodu kontrol edin.

Aşağıda örnek kitap bilgileri verilmiştir. Bu bilgileri kullanarak kitapları ekleyebilirsiniz:

Kitap Adı	Yazar	Yayınevi
Suç ve Ceza	Fyodor Dostoyevski	Can Yayınları
Kürk Mantolu Madonna	Sabahattin Ali	Yapı Kredi Yayınları
1984	George Orwell	İthaki Yayınları
Simyacı	Paulo Coelho	Can Yayınları
Tutunamayanlar	Oğuz Atay	İletişim Yayınları