VS Code ile Entity Framework Core'a Başlarken

by Ismail Sirma


Posted on 31.3.2020 22:11:27


Microsoft’un ORM framework olarak oluşturduğu kütüphaneyi kurulumunu yapacak ve DB first ile Code first pratikleri inceleyeceğiz.

Persistence Framework’leri verinin sürekliliğini sağlamanın yanında veri ile nesneler arasındaki planlamanın sistematik bir biçimde ORM (Object Relational Mapping) ile yapılmasına yardımcı olur.

ADO .NET içerisinde yer alan SqlConnection, SqlCommand ve SqlDataReader nesnelerinden kendinize ait yeni bir persistance framework oluşturmanız çok maliyetli bir iş.

  • Bir sürü Stored Procedure yazmanız
  • Verilerin nesnelerle ilişkilendirilmesini manuel olarak yapmanız gerekmektedir.

Bu nokta da Entity Framework size bu zaman alıcı işleri hızlıca çözümlemede yardımcı olacak.

Entity Framework Workflow

EF size 3 farklı veritabanı oluşturma yaklaşımı sunuyor:

1.Database First

Tabloları oluştururuz, EF domain nesnelerini kendisi oluşturur (Eskiden beri kullanılan bir yaklaşım)

2.Code First

Önce domain nesnelerini oluştururuz, EF veritabanı nesnelerini oluşturur. (Yeni bir yaklaşım)

3.Model First

Visual Studio ile UML diagramı (nesneler ve arasındaki bağlantı diagramda işaretlenir) oluşturulur, EF bu diagram üzerinden nesne ve veritabanını oluşturur. (Pek kullanılmayan bir yöntem. Tavsiye edilmiyor)

Ön gereksinimler:

  1. Visual Studio Code / Visual Studio 2017 veya üzeri versiyonlar
  2. .NET Core SDK
  3. Microsoft Sql Server 2008 veya üzeri bir veritabanı bağlantısı (Tercihen farklı bir db de olabilir)

A. Database First Yaklaşımı

Bu yaklaşım için öncelikle veritabanında tablolarımızı oluşturuyoruz.

Sonrasında hazırlık için aşağıdaki adımları izliyoruz.

Örnek uygulamayı (Visual Studio Code için) komut satırıdan oluşturalım:

    Terminal’de şunu yazıyoruz : dotnet new console

  • Nuget Package Manager Açıyoruz Ctrl + Shift + P basıp yukarıda gelen aramaya nuget yazıp, Nuget .. Add Package seçiyoruz ve gelen yerde EntityFramework yazıyoruz

Core seçtikten sonra versiyon 3.1.3 seçip yüklüyoruz.

  • Nuget .. Add Package seçiyoruz ve gelen yerde Design yazıyoruz

seçtikten sonra versiyon 3.1.3 seçip yüklüyoruz.

  • terminalde şu komutları çalıştırıyoruz: dotnet tool install --global dotnet-ef
  • Nuget .. Add Package seçiyoruz ve gelen yerde SqlServer yazıyoruz

seçtikten sonra versiyon 3.1.3 seçip yüklüyoruz. Altta gelen uyarı ile Restore yapıyoruz.

Veya terminal’de şu komutu çalıştırıyoruz :

      dotnet add package Microsoft.EntityFrameworkCore.SqlServer

  • Terminal’de şu komutu çalıştırıyoruz :

      dotnet add package Microsoft.EntityFrameworkCore.Tools

      dotnet restore

Veritabanındaki Tabloları Nesnelere Dönüştürme (Visual Studio Code)

 

Veritabanı içinde var olan tabloları nesne olarak proje içerisine eklenmesi için aşağıdaki komutu çalıştırıyoruz. Bu komut verdiğimiz ConnectionString değeri ile veritabanına bağlanıp içerideki tabloları proje içerisinde Model isimli bir klasör altına nesne olarak ekleyecektir.

 

dotnet ef dbcontext scaffold "Server=.\;Database=VeritabaniAdi;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer -o Model

  • Oluşan dosyalar ve veritabanı yapısı:

Model klasörü altında veritabanı adı ile başlayıp Context ile biten nesne oluşur. Bu nesne DbContext nesnesinden türemektedir. DbContext veritabanı üzerinde bir soyutlamadır ve veritabanı üzerinden işlemler yapabileceğimiz fonksiyonları sağlamaktardır.

DbSet: Veritabanı içindeki bir tabloyu temsil eder.

 

Veritabanındaki tabloları Nesnelere Dönüştürme (Visual Studio 2017 ve sonrası)

  1. Solution Explorer’da projeye sağ tıklıyoruz,
  2. Add New Item’dan ADO.NET Entity Data Model seçiyoruz,
  3. EF Designer from Database seçiyoruz ve bağlantı ayarlarını giriyoruz,
  4. Tabloları seçiyoruz ve en son Finish seçerek dönüşümü tamamlıyoruz.

Visual Studio Code’dan farklı olarak Studio 2017’de GUI üzerinden kolaylıkla oluşturulabiliyor. Tablo isimleri çoğulsa tekil halde nesne isimleri oluşuyor.

 

Program.cs dosyasında DbContext i kullanarak veritabanı üzerinde işlem yapalım.

public class Program

    {

        public static void Main(string[] args)

        {

            var context = new SampleAppContext();

            var cities = new Cities(){

                CityId = 34,

                StateId = 34,

                Name = "Istanbul"

            };

 

            context.Cities.Add(cities);

            // changes in memory until you save them.

            context.SaveChanges();

        }

    }

 

B. Code First Yaklaşımı

İlk yaklaşımdaki kurulum hazırlıkları aynı şekildegerçekleştiriyoruz. Ek olarak projemize aşağıdaki paketleri de ekliyoruz (Net Core versiyonu ile aynı versiyon- 3.1.3) :

                    Microsoft.Extensions.Configuration.FileExtensions

                    Microsoft.Extensions.Configuration.Json                                                         

                    Microsoft.Extensions.Hosting        

                    Microsoft.AspNetCore.Hosting       

                    Microsoft.Extensions.DependencyInjection 

Ancak bu sefer veritabanına herhangi bir tablo oluşturmamız gerekmiyor.

Post tablosu için nesne oluşturalım :

using System;

 

    public class Post
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
        public DateTime Created { get; set; }
    }
 

Veritabanı işlemleri için DbContext ten türeyen nesnemizi oluşturalım.

 

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
 
    public class PublishDbContext : DbContext
    {
        public DbSet<Post> Posts {get; set;}
 
        public PublishDbContext()
        {
 
        }
 
        public PublishDbContext(DbContextOptions options) : base(options)
        {
        }
 
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            if (!optionsBuilder.IsConfigured)
            {
                IConfigurationRoot configuration = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json")
                .Build();
                var connectionString = configuration.GetConnectionString("DefaultConnection");
                optionsBuilder.UseSqlServer(connectionString);
            }
        }     
 
    }
 

Veritabanına bağlantı için App.config dosyasında Connection String oluşturalım. Proje ana klasörü içinde appsettings.json dosyası oluşturalım.

 

{

    "ConnectionStrings": {

      "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=SampleAppContext;Trusted_Connection=True;MultipleActiveResultSets=true"

    }

  }

 

Programımızın başlangıç nesnesini Transient yani her istek için yeni bir instance çalıştırılacak biçimde hazırlıyoruz:

 

using Microsoft.Extensions.DependencyInjection;

using Microsoft.Extensions.Hosting;

 

 public class Program

    {

        public static void Main(string[] args)

        {

            var serviceProvider = new ServiceCollection()

                .AddLogging()

                .AddTransient<IWorker, Worker>()

                .AddDbContext<PublishDbContext>()

                .BuildServiceProvider();     

 

            // Konsol loglaması eklenir.

            serviceProvider

                .GetService<ILoggerFactory>();

 

            var logger = serviceProvider.GetService<ILoggerFactory>()

                    .CreateLogger<Program>();

            logger.LogDebug("Uygulama başlatılıyor");

 

            var bar = serviceProvider.GetService<IWorker>();

            bar.doSomething();

 

            logger.LogDebug("Bitti!");           

        }

          

    }

 

Servisimizin çalıştığı nesne Worker.cs dosyası :

 

using System;

 

namespace net_core_ef_project

{

    public interface IWorker

    {

        void doSomething();

    }

    public class Worker : IWorker

    {

        public void doSomething()

        {

           using(var context = new PublishDbContext())

           {

               var post = new Post {

                    Id = 1,

                    Title = "Hamlet",

                    Content = "William Shakespeare Master Piece",

                    Created = DateTime.Now

               };

 

               context.Add(post);

               context.SaveChanges();

           }                

        }

    }

}

 

Code first migration özelliğini aktif hale getirmek için terminal de şu komutu çalıştırırız:

>dotnet-ef migrations add ‘CreatePost’

Model nesnelerimizde (tablolarımızda) değişiklik yaptığımızda migration oluşturmamız gerekir. Yukarıdaki komutla farklı isimlerde migration oluşturabiliriz. Migration oluşturulduktan sonra aşağıdaki gibi otomatik olarak nesneler oluşturulur. Bu nesnelere müdahale etmemeliyiz.

İçini açıp incelediğimizde veritabanında oluşturulacak olan öğeler için hazırlanmış kodları görebilirsiniz.

 

 

Blog Search

Message

Welcome to Blog of Ismail Sirma.

Back to List