TSQ Başlangıç1

T-SQL Komutları

 

Normal şartlarda veritabanı işlemede ANSI SQL dediğimiz standart dil kullanılmaktadır. Lakin bu dil karmaşık işlemler gerçekleştirmeyi, örneğin bir if...else yapısı, while döngüsü gibi fonksiyonları ve değişken tanımalamayı desteklememektedir. Bu durumda yapılması gereken farklı bir programlama dili öğrenmek ve bu vasıtayla bu işlevleri yerine getiren ara programlar yazmaktır. T-SQL dil yapısı tüm bu fonksiyon ve karmaşık işlemleri SQL Server uzayında yapabilmek adına geliştirilmiş standart dışı bir dildir.

TSQL DEYİMLERİ

SQL deyimleri veritabanları üzerinde çeşitli işlemleri yerine getirirler. Veritabanından sorgulama yapmak için SELECT, ekleme yapmak için INSERT güncelleme  yapmak için UPDATE, silme yapmak için DELETE, yeni tablo oluşturmak için CREATE TABLE gibi komutlara sahiptir. Bu komutlar işlevlerine göre şu şekilde kategorilendirilir:

DDL (Data Definition Language): Veri tanımlama deyimleri.

  • Create  - Nesne oluşturma
  • Alter     - Nesne düzenle
  • Drop     - Nesne Sil

DML (Data Manuplation Language) : Veri düzenleme dili.

  1. Select - Veri seçme
  2. Insert  - Veri  ekleme
  3. Update  -Veri güncelleme
  4. Delete   -Veri silme dir.
    Kısaca bu işlemleri CRUD işlemleri de denilmektedir.

DCL (Data Control Language): Veri kontrol dili.

  • Grand (yetki verme)
  • Revoke(yetkiyi kaldırma)

 

 

TSQL Create, Drop, Alter Deyimi

CREATE (NESNE OLUŞTURMAK)

Create deyimini biz server nesnesi eklemek için kullanırız. Bu nesne bir user,veritabanı, kullanıcı adı, rule, sp(stroed procedure gibi nesnesler olabilir.

Yazımı

 FileName   : Oluşturulacak veritabanı dosyasının kaydedileceği yer ve yolu. 

Size         : Veritabanı dosyasının boyutu.                

MaxSize    : Dosyanın maksimum alacağı değer.                

FileGrowth : Dosyasnın artma boyutu .

CREATE DATABASE Veritabanı_Adi 

[ ON  

    <FILENAME> ,

    <SIZE>,                 

    <MAXSIZE>,                     

    <FILEGROWTH>]

[ LOG  

    <FILENAME>,

    <SIZE>,                 

    <MAXSIZE>,                     

    <FILEGROWTH > ]   

Şeklindedir. 

Kısa Bir örnek verisek 

create database erkan2013
go

Create Table : Veritabanı üzerinde tablo oluşturma  ve tablo ile ilgili özelliklerinin tanımlanması için kullanılır.  

 

CREATE TABLE  Tablo_Adi (

        Alan_Isimleri    Veri_Tipleri  [Default ifade]    [Alan Kısıtlaması]

       [Tablo_Kısıtlamalar ]

)     Alan Ismi : Oluşturulacak kolona verilecek isim . Veri_Tipler  : Oluşturduğumuz alanın veri tipi char, varchar, nvarchar, integer, decimal, double, datetime, text , vb. Bazı veri tipleri veritabanından veritabanına değişmektedir. Eğer veri karakter ise   char , varchar(karakter uzunluğu) vb,  çok uzun karakterler için text , sayı ise int , küsuratlı sayı ise decimal yada  double , tarih alanı için datetime gibi tipler kullanabilirsiniz.

Alan Kısıtlaması : İlgili alanın boş geçilip geçilemeyeceği durumu. NULL boş geçilebilir, NOT NULL boş geçilemez ilgili alana kayıt girmek zorundasınız.

Tablo_Kısıtlamaları : Tabloda yapacağımız kısıtlamalardır.  Primary Key, Foreing Key, Check lerdir.

 

create table kategori
(KategoriNo int not null identity(1,1),
ustkategori int not null, 
ad varchar(30)not null,
aciklama text,

CONSTRAINT [PK_KategoriNo] PRIMARY KEY CLUSTERED 
(
  KategoriNo
) 
)

Örnek 2)

CREATE TABLE Personel (
PersonelId int NOT NULL ,
TCKimlikNo char (11) NOT NULL ,
Adi varchar (30) NOT NULL ,
Soyadi varchar (50) NOT NULL ,
Maas decimal(18, 2) NOT NULL DEFAULT (0), // Bu alana değer atanmaması durumunda ilk değer verme ile 0 değerini atanmış oldu
PDepartmanId int NOT NULL ,
Cinsiyet char (1) NULL ,  
CONSTRAINT PK_Personel PRIMARY KEY CLUSTERED(PersonelId), //Primary Key tanımı
CONSTRAINT IX_Personel UNIQUE CLUSTERED ( TCKimlikNo ) , //TC Kimlik numarasını istemiyoruz.
CONSTRAINT FK_Personel_Departman FOREIGN KEY (PDepartmanId) REFERENCES Departman (DepartmanID), //Başka bir tablodaki bir alanı referans vererek ikincil anahtar (foreing key) tanımlama
CONSTRAINT CK_Personel CHECK (Cinsiyet = ’K’ or Cinsiyet = ’E’)  //Cinsiyet alanına ’E’ ve ’K’ değerleri dışında değer atanmaması
 )

Aynı şekilde View, Index gibi nesnelerde oluşturablirsiniz.

Örnek : Personel tablosundaki bir personele ait mal bilgilerinin tutulacağı bir tablo oluşturalım. 

Bu örnekte dikkat edilecek kısımlar : Personel tablosunda bir personelin silinmesi durumunda PersonelMal tablosunda o personele ait bilgilerin silinmesi için uygun ikincil anahtar (foreing key) tanımlayalım. Bunlar

ON DELETE CASCADE : Referans edilen tablodaki kayıt yada kayıtların silinmesi durumunda referans alan tabloda ilişkili kayıtların da silinmesi .

ON UPDATE CASCADE : Referans edilen tablodaki kayıt yada kayıtların guncellenmesi durumunda referans alan tabloda ilişkili kayıtların da güncellenmesi.

Bunun için gerekli kodları yazalım..

CREATE TABLE PersonelMal (
MalId int NOT NULL ,
PPersonelId int NOT NULL ,
Adi nvarchar (50) NOT NULL ,
Bedeli decimal(18, 2) NOT NULL ,
CONSTRAINT PK_PersonelMal PRIMARY KEY CLUSTERED (MalIdMalId, PPersonelId ), // Birincil anahtarı (Primaty key) tanımlarken sadece tek alan olması gerekmez.Bu iki veya daha fazla alanda olabilir.
CONSTRAINT FK_PersonelMal_Personel FOREIGN KEY(PPersonelId) REFERENCES Personel (PersonelId) ON DELETE CASCADE    //Personel tablosundaki ilgili kayıt silinmesi durumunda ona ait kayıtıların  da silinmesi için gerekli tanımlama.
)

 Create deyimi ile aynı zaman login veya user, veya her ikisini aynı satırda oluşturabilir. Bir user Doman User, Domin Group veya etki alanındaki başka rollerle login olabilir. Bu login ile birde fazla user olabilmektedir. Mesala Bir web sitesinin veritabanı login olabilmek iiçin genel bir misafir tanımlanabilir.

use master
go
CREATE LOGIN weblogin WITH PASSWORD='1234'
go

--weblogin için için bir user oluşturalım..
Use deneme
Create USER webUSER FOR LOGIN weblogin
go

Eğer kullanıcı adı ve login aynı ise for login deyimine gerek kalmaz.

--erkan2014 tabanı için bir dene isimli login ve user oluşturalım..
Use erkan2013
go Create USER dene go

 ALTER (Nesnelerde Değişiklik Yapmak)

Daha önceden oluşturulmuş bir nesne özelliğinin değiştirilmesini sağlar.

Genel Yazımı

ALTER nesne nesne_adi değişim_cümlesi

Örnek:

ALTER TABLE PERSONEL

ADD BABA_AD varchar(20) NOT NULL

Bu şekildeki bir yazımla PERSONEL tablosuna BABA_AD sütunu eklenmiştir. NOT

NULL ile de bu sütuna veri girişi zorunlu hâle getirilmiştir.

Örnek

ALTER TABLE PERSONEL 
ALTER COLUMN AD varchar(15) NOT NULL

Bu yazım ile de varolan AD sütununun alabileceği karakter sayısı 15 olarak

değiştirilmiş ve veri girişi zorunlu hâle getirilmiştir.

 

DROP (Nesne Silmek)

Bir nesnenin silinmesini sağlayan komuttur. DROP komutu tüm nesneler için

kullanılır.

Genel Yazımı

DROP nesne nesne_adi

Örnek:

DROP TABLE PERSONEL

Bu şekilde bir yazımla PERSONEL tablosu silinmiş olur.

Örnek 2

DROP DATABASE ERKAN2013

erkan2013 isimli veritabını siler

Bir sonraki yazımızda görüşmek üzere.

 

 

 

TSQL, Go komutu

GO
Sql Server birden fazla işlemi aynı talep içinde cevaplayabilir. GO komutu Sql Servera gönderilen komut dizisinin sonunu belirtmek için kullanılır. Aslında T-SQLin bir parçası olmayan kod Sql Server Query Analizer tarafından da algılanır.

Dikkat edilmesi gerekenler :
- GO komutu diğer T-SQL komutları ile aynı satırda kullanılamaz
- GO komutundan önce tanımlanan bir değişken GO komutundan sonra kullanılamaz. Zira daha önceki kod yığınının sona erdiğini belirtmektedir.
- Kodun sonunda GO kullanılmadığı sürece komutlar sunucuya gönderilmez.

Arabirimler-2 (interface)

Ben bazı arabirim özelliklerini yine tekrar etmek istiyorum.

1) Arabirimler bir classa standart getirirler.

2) Arabirimlerde sadece üyeler tanımlanır, açıklayıcı kod yazılmaz.

3) Arabirimler üyeleri(method, özellik, indexleyici, ve olay) doğası gereği publictirler.

4) Bir sınıf birde fazla arabirimden kalıtım alabilir..

5) açık ve kapalı şekilde implement edilebilir.

 

Senaryomuza göre canli sınıfı yapalım, bu sınıfı güncelhayatdan bir örnek vereceğimiz için, tıpkı melekler gibi soyut(absract) sınıf olsun ve new deyimi ile nesnesini oluşturma imkanı olmasın.. Yas özelliği yazalım ve yasamayaDevamEt() yöntemi yapalım.. ve canli sınıfı yaşamaya devam etsin..:)

abstract class Canli
    {
        public int yas { get; set; }
        void yasamayaDevamEt()
        {
            Console.WriteLine("Dünya çok güzel");
        }
    }

Daha sonra IUcar ve IGazer isimli iki tane arabirim yazalım. Burada dikkat edeceğimiz konu Uc() yöntemi her iki arabirimde tanımlanmış. Sizler daha önceki yazımda belirtiğim gibi açık ve kapalı olarak interface implement edebilirisiniz.

    interface IUcar
    {
        void Uc();
        int kanatSayisi { get; set; }
    }

    interface IGezer
    {
        void Uc();
        void Gez();
        int Hiz { get; set; }
    }

c# yorumlayıcısına(compiler) yazacağımız ve kullanacağımız Uc yonteminin hangi Arabirimin yöntemi olduğunu anlatmamız gerekir. Bizler boyle bir durumda kaplaı şekilde belirtmek yerine ;

public void Uc()
        {
            Console.WriteLine("kanatla ucuyorum");
        }

Bu arabirimin(explicitly) yontemini açık bir şekilde belirtmemiz gerekir.

void IUcar.Uc()
        {
            Console.WriteLine("kanatla ucuyorum");
        }

diğer arabirim için

void IGezerr.Uc()
        {
            Console.WriteLine("Jet motorla ucuyorum");
        }

artık  Insan sınıfımızın kalıtım aldığı arabirimin üyelerinin zorunlu olarak implement edelim ve gerekli kodları yazalım.

class Insan : Canli, IUcar,IGezer 
    {
        void IUcar.Uc()
        {
            Console.WriteLine("kanatla ucuyorum");
        }

        void IGezer.Uc()
        {
            Console.WriteLine("Jet motorla ucuyorum");
        }
        int _kanatsayisi;
        public int kanatSayisi
        {
            get
            {
                return _kanatsayisi;
            }
            set
            {
                _kanatsayisi=value; 
            }
        }


        public void Gez()
        {
            Console.WriteLine("Dünya da ne yerler varmış ve gezmekle bitmiyor");
        }

        int _hiz;
        public int Hiz
        {
            get
            {
                return _hiz;
            }
            set
            {
               _hiz=value;
            }
        }
    }

Burada _hiz ve _kanatsayisi diye iki özel bir alan kullandım.

Şimdi gelelim bunları kullanacak kod yazmaya. burada Insan sınıfının bir örneği(nesnesi) olan ercepin kanatsayisi özelliği hem okunur hemde yazılabilir bir özelliktir. ercep. yazarak ben bu üyeleri erişebilirim. Fakat Uc() yöntemi için derleyiciye ben hangi Uc() yöntemini kullanacağımı anlatmam gerekir. Burada cast işlemi(kesme) imdadımıza yetişiyor. Ben sizin öğrenmeniz için  Uc() yontemini iki farklı yazım metoduyla yazdım.

class Program
    {
        static void Main(string[] args)
        {
            Insan ercep = new Insan();
           // ercep.Uc(); //bu şekilde kullanamayız.
            ercep.kanatSayisi = 2;//property set yapılıyor.
            IUcar iucar = (IUcar)ercep; // cast-kesme işlemi
            Console.WriteLine(iucar.kanatSayisi + " kanat ile ucarım");
            iucar.Uc();
            ((IGezer)ercep).Uc();//jet motor
            ercep.Hiz = 30;
            ercep.yas = 5;
	}
    }

Bir yazımızda görüşmek üzere, sevgili öğrecilerim..

Sizin seçtiğiniz maskot resminizi koyuyorumm..

 

arabirimler1.rar (23,05 kb)

Code First ile Fluent Api kullanma

Öncelikle modelimizi ve Modelimize saracak DbContext classlarımızı oluşturalım..

public class SchoolEntities : DbContext
{
  #region Properties
 
  public DbSet<Course> Courses { get; set; }
  public DbSet<Department> Departments { get; set; }
 
  #endregion
 
  #region Methods
 
  protected override void OnModelCreating(
    System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
  {
    base.OnModelCreating(modelBuilder);
 
    // put here the fluent code
  }
 
  #endregion
}
 
public partial class Course
{
  #region Properties
 
  public int CourseID { get; set; }
  public string Title { get; set; }
  public string Days { get; set; }
  public DateTime Time { get; set; }
  public string Location { get; set; }
  public int Credits { get; set; }
  public int DepartmentID { get; set; }
 
  public virtual Department Department { get; set; }
 
  #endregion
}
 
public class Department
{
  #region Properties
 
  public int DepartmentID { get; set; }
  public string Name { get; set; }
  public decimal Budget { get; set; }
  public DateTime StartDate { get; set; }
  public int Administrator { get; set; }
 
  public virtual ICollection<Course> Courses { get; set; }
 
  #endregion
}

 

 

 

Daha sonra Fluent Api kullanarak modelimizde düzenlemeler yapalım. Fluen Api kullanmadan Data annotions kullaran tabii bazı düzenlemerler yapabilrisiniz, fakat herşeyi değil.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
  base.OnModelCreating(modelBuilder);
 
  modelBuilder.Entity<Department>().
    Property(d => d.Name).
    IsRequired().
    HasMaxLength(50);
 
  modelBuilder.Entity<Department>().
    Property(d => d.DepartmentID).
    HasDatabaseGenerationOption(DatabaseGenerationOption.None);
 
  modelBuilder.Entity<Department>().
    HasMany(d => d.Courses).
    WithRequired(c => c.Department).
    HasForeignKey(c => c.DepartmentID).
    WillCascadeOnDelete();
 
  modelBuilder.Entity<Department>().
    Ignore(d => d.Administrator);
 
  modelBuilder.Entity<Course>().
    Property(c => c.Title).
    IsRequired().
    HasColumnName("Name");      
}

 

Daha sonra modelimize bilgi ekleyelim ve sonucu görelim...

class Program
{
  static void Main(string[] args)
  {
    using (SchoolEntities context = new SchoolEntities())
    {
      var department = new Department
      {
        DepartmentID = 1,
        Administrator = 2,
        Budget = 100000,
        Name = "Data Access",
        StartDate = DateTime.Now
      };
      var course = new Course
      {
        Credits = 2,
        Days = "MF",
        Location = "Class 1",
        Time = DateTime.Now,
        Title = "Entity Framework",
        Department = department,
      };
      context.Departments.Add(department);
      context.SaveChanges();
    }
  }
}


Eğer veri tabanımızın ismini değiştirmek sitoyrsak DbContext ile sardığımız sınıfımızın temel kurucu yönteminde (base constructor) belirtebilriiz.

public SchoolEntities() :
      base("MySchool")
    {
 
    }

Veri tabanımız aşağıdaki gibi bir görüntü alacaktır.


Ayrıntılı bilgi içinburdan takip edebilrisiniz.
Buradan
ve buradan


 

Fluent Api bir yazim seklidir. Method tarzinda LinQ ifadesi yazmak gibi. Bunu yazim tarzinin mucidi Martin Fowler dir.  Buradan ayrintili bir bilgi alabilirsin. Burada Fluent Api LinQ to Entity veya LinqQ to SQL de kod yazarken kullanilan bir yontem dir.burada da ayrintili bir bilgi var.

(Code First ile kalıtım, Hiyerarşik tablolar) Inheritance with Code First TPH-Table per Hierarchy

Neden, nasıl , niçin sorularına sonra uzun bir makale yazağım. şimdilik senaryoya göre ornek bir proje yapacağım..Bilgi vereceğimm Öncelikle modelimize göre POCO classlarımızı hazırlayalım..

 

 
public abstract class User
{
        public int UserId { get; set; }
        public string Ad { get; set; }
        public string Soyad { get; set; }
        public Guid rowGuid { get; set; }
    }

    public class Calisan : User
    {
public int  SSKNo { get; set; }
    }

    public class Ogrenci : User
    {
        public int OkulNo { get; set; }

    }
 
public class OkulumContext : DbContext { public DbSet<User> Users { get; set; } }

Daha Sonra  Bilgi eklemek ve listeleme işlerimini gerçekleştirmek için  aşağıdaki kodlarımızı yazalım..

        static void Ekle()
        {
            Calisan calisan = new Calisan()
            {
                Ad = "erkan", Soyad = "bal", SSKNo = 987878
            };
            Ogrenci ogrenci = new Ogrenci { Ad = "Ayten", Soyad = "Akan", OkulNo = 8978 };
            Ogrenci ogrenci2 = new Ogrenci { Ad = "nisa", Soyad = "Ak", OkulNo = 989 };
            using (OkulumContext db = new OkulumContext())
            {
                db.Users.Add(calisan);
                db.Users.Add(ogrenci);
                db.Users.Add(ogrenci2);
                db.SaveChanges();
            }
        }
    }

 Daha sonra bir foreach dongusu içinde bilgimizi yazdıralım..

static void Main(string[] args)
        {
            Ekle();
            using (OkulumContext db = new OkulumContext())
            {
                Console.WriteLine("Tümünü yazdırıyoruz");
                foreach (var item in db.Users)
                {
                    Console.WriteLine("{0} \t{1}",item.UserId ,item.Ad );
                }
            }
        }

Sql profiller ile  sorgusunu çıktısı inceyelim. 

SELECT 
[Extent1].[Discriminator] AS [Discriminator], 
[Extent1].[UserId] AS [UserId], 
[Extent1].[Ad] AS [Ad], 
[Extent1].[Soyad] AS [Soyad], 
[Extent1].[rowGuid] AS [rowGuid], 
[Extent1].[SSKNo] AS [SSKNo], 
[Extent1].[OkulNo] AS [OkulNo]
FROM [dbo].[Users] AS [Extent1]
WHERE [Extent1].[Discriminator] IN (N'Calisan',N'Ogrenci')



Daha sonra sorgumuzu ben biraz çeşitlendirmek istiyorum. Önceliklle TPH kullanımızın asıl kullanım amacımızı, bizi faydalarını göreceğimiz sorgu türlerinden bahsedelim.

Polymorphic Sorgular

Linq To Entity sorgusuyla veriyi çekelim..

IQueryable<User> linqQuery = from b in db.Users  select b;
                List<User> users2 = linqQuery.ToList();

Aynı işlemi EntitySQL sorgusu ile yazabiliriz. Her iki sogunun SQL çıktısı aynı olacaktır. Yani aşağıdaki sql çıktısı gibi olacaktır.

string eSqlQuery = @"SELECT VAlUE b FROM Users AS b";
ObjectContext objectContext = ((IObjectContextAdapter)db).ObjectContext;
ObjectQuery<User> objectQuery = objectContext.CreateQuery<User>(eSqlQuery);
List<User> users = objectQuery.ToList();

SELECT 
[Extent1].[Discriminator] AS [Discriminator], 
[Extent1].[UserId] AS [UserId], 
[Extent1].[Ad] AS [Ad], 
[Extent1].[Soyad] AS [Soyad], 
[Extent1].[rowGuid] AS [rowGuid], 
[Extent1].[SSKNo] AS [SSKNo], 
[Extent1].[OkulNo] AS [OkulNo]
FROM [dbo].[Users] AS [Extent1]
WHERE [Extent1].[Discriminator] IN (N'Calisan',N'Ogrenci')

Non-polymorphic

Ben burada OfType deyimiyle ornekler vereceğim.

                IQueryable<Calisan> linqQuery = from b in db.Users.OfType<Calisan>()  select b;

                List<Calisan> users2 = linqQuery.ToList();

                foreach (var item in users2)

                {

                    Console.WriteLine("{0} \t{1}", item.Ad, item.SSKNo);

                }

SQl çıktısı aşağıdaki gibi olacaktır.

SELECT 

'0X0X' AS [C1], 

[Extent1].[UserId] AS [UserId], 

[Extent1].[Ad] AS [Ad], 

[Extent1].[Soyad] AS [Soyad], 

[Extent1].[rowGuid] AS [rowGuid], 

[Extent1].[SSKNo] AS [SSKNo]

FROM [dbo].[Users] AS [Extent1]

WHERE [Extent1].[Discriminator] = N'Calisan'

EntitySql ile oftype deyimini kullanmak istersek aşağıdaki gibi bir kod yazmak gerekir. Daha sonrada Tread deyimiyle ibrlikte kullanabiliriz.

                string eSqlQuery = @"SELECT VAlUE b FROM  OFTYPE(Users, TPHSystem.Calisan) AS b";

                ObjectContext objectContext = ((IObjectContextAdapter)db).ObjectContext;

                ObjectQuery<Calisan> objectQuery = objectContext.CreateQuery<Calisan>(eSqlQuery);

                List<Calisan> users2 = objectQuery.ToList(); 

                foreach (var item in users2)

                {

                    Console.WriteLine("{0} \t{1}", item.Ad, item.SSKNo);

                }

SQl Çıktısı

SELECT 

'0X0X' AS [C1], 

[Extent1].[UserId] AS [UserId], 

[Extent1].[Ad] AS [Ad], 

[Extent1].[Soyad] AS [Soyad], 

[Extent1].[rowGuid] AS [rowGuid], 

[Extent1].[SSKNo] AS [SSKNo]

FROM [dbo].[Users] AS [Extent1]

WHERE [Extent1].[Discriminator] = N'Calisan'

 

Sorgumuzu TREAT deyimini kullanarak yapalım..

string sorgum = @"Select value TREAT(b as TPHSystem.Calisan)
                                    FROM Users AS b
                                    WHERE b IS OF(TPHSystem.Calisan)";

SELECT 

'0X0X' AS [C1], 

[Extent1].[UserId] AS [UserId], 

[Extent1].[Ad] AS [Ad], 

[Extent1].[Soyad] AS [Soyad], 

[Extent1].[rowGuid] AS [rowGuid], 

[Extent1].[SSKNo] AS [SSKNo]

FROM [dbo].[Users] AS [Extent1]

WHERE [Extent1].[Discriminator] = N'Calisan'

 

Şimdide fluent api kullanarak tablonun bazı alanlarına ilk değer ataması yapabilriiz. Ayrıca user clasımıza Public bool DegerVarmi gibi bir özellik yazılabilir. Bunu daha onceki çalışmamda yapmıştım..  Şimdi Requires ve HasValue deyimiyle düzenleme yapabilriiz. Boylese o tablodaki kaydın bir çalışanamı yoksa bir ogrenciyemi ait olduğunu anlayabiliriz. Buradan da bu konuyla ilgili geniş bir anlatım bulabilirsiniz.

 

modelBuilder.Entity<User>()
                .Map<Calisan>(t => t.Requires("UserTipi").HasValue(1))
                .Map<Ogrenci>(t => t.Requires("UserTipi").HasValue(2));

 

 Final bölümündeki şunları soylemek yerinde olcaktır. Az kayıti içeren bir kayıtda TPH sistemi kullanılablir. Fakat veri tabanınızda veri miktarı buyukse normalizasyon kuralları geriği TPT(table ğer Type) sisteminin kullanmanız doğru olcaktır. 

 

 

TPHSystem.rar (2,33 mb)

Diziler ve Foreach

Diziler, Çok Boyutlu Diziler, Düzenli ve Düzensiz Çok Boyutlu Diziler Nasıl Kullanılır. foreach Döngüsünün Kullanımı

Diziler için aynı tipteki verilerin tutulduğu bir koleksiyon diyebiliriz. Örneğin integer verinin bir yığın şeklinde tutulması için dizileri kullanırız. C# da diziler referans tipinde değişkenlerdendir. C# da tanımlanan tüm diziler System.Array sınıfından türemiş bir nesnedir. C# da diziler aşağıdaki gibi tanımlanır.

<veri tipi>[] <değişken ismi> = new <veri tipi>[<dizinin boyutu>];

 

10 adet integer veri tutan bir dizinin tanım ise

int[] integerDizi = new int[10];


Bir dizinin boyutları sabittir ve kullanılmadan önce belirlenmelidir. Dizi boyutunu belirlemek için başka bir değişkende kullanabilirsiniz.

int boyut = 10;int[] integerDizi = new int[boyut];


Diziyi tanımlama ve başlangıç değerlerini atama işlemini ayrı satırlardada yapabilirsiniz
.

int[] integerDizi;integerDizi = new int[10];


Ayrıca dizileri tanımlarken, dizi içine atmak istediğiniz verileride belirterek dizi tanımlayabilirsiniz. Bunun için kullanacağınız veri tipine uygun olacak şekilde, süslü parantez içinde her biri virgülle ayrılmış dizi elemanlarını yazmanız yeterli
.

int[] integerDizi = {1,2,3,4,5,6,7,8,9};


Yukarıda 10 adet elemanı olan ve değerleri de verilmiş, integer tipinde verileri tutan bir dizi tanımladık. Eğer dizimiz string değerler tutacak olsaydı, süslü parantez içine yazdığımız elemanların her birini çift tırnaklar arasına almamız gerekirdi.

string[] strDizi = { "Sabri", "Metin", "Osman", "Ali" };


Dizi Elemanlara Ulaşmak

Dizi elemanlarına ulaşmak için [indeks] indeks operatörünü kullanırız. Dikkat edilmesi gereken nokta C# da dizilerin elemanları 0. İndeksten başlar, yani eğer 5 elemanlı bir dizimiz varsa bu dizinin birinci elemanı 0. indekste son elemanı ise 4. indekstedir. 5 elemanlı bir dizinin 3. elemanına aşağıdaki gibi erişiriz.

int[] integerDizi = { 1, 2, 3, 4, 5};int ucuncuEleman = integerDizi[2];


Bir dizi içindeki elemanlara ulaşmak için basit bir örnek:

int[] integerDizi = { 4, 8, 23, 64, 35 };for (int i = 0; i < 5; i++){Console.WriteLine("Dizinin {0}. Elemanının Değeri = {1} ", i, integerDizi[i]);}

Yukarıdaki örnekte bir dizi oluşturduk ve bu dizinin eleman sayısı kadar bir for döngüsü kurduk. Döngü içinde diziye ait elemanların değerlerine tek tek ulaştık.

Peki kullandığımız dizinin eleman sayısını bilmeseydik nasıl döngüye girebilirdik. Bütün diziler System.Array sınıfından türemiş nesnelerdir demiştik. System.Array sınıfının Length diye bir özelliği vardır, doğal olarakda tüm dizilerinde bir Length özelliği olur. Dizimizin eleman sayısını dizininAdi.Length diyerek alabiliriz. Yukarıdaki örneği bu yöntemle yeniden yazacak olursak.

int[] integerDizi = { 4, 8, 23, 64, 35 };for (int i = 0; i < integerDizi.Length; i++){Console.WriteLine("Dizinin {0}. Elemanının Değeri = {1} ", i, integerDizi[i]);}


Yukarıdaki kodu çalıştırdığınızda bir önceki örneğimizle aynı sonucu üretir.

Dizilerle ilgili dersimize devam etmeden önce diziler için kullandığımız foreach döngüsüne bakalım.

foreach Döngüsü

Diziler ve koleksiyonların elemanlarına erişmek için basit ve kullanışlı bir döngü çeşidi. Döngüler dersinde bahsetmedik çünkü dizileri anlatmadan foreach döngüsünü anlamaya çalışmak boşuna olacaktı. foreach döngüsünün yapısı aşağıdaki gibidir.

foreach(<dizi içindeki elemaların veri tipi> <değişken ismi> in <diziveyaKoleksiyonadi>){<Kod blogumu>}


Yukarıda for döngüsü ile yaptığımız örneğimiz foreach döngüsü ile yapalım.

foreach (int diziElemanı in integerDizi){Console.WriteLine("Elemanın Değeri = {0} ", diziElemanı);}


Çok daha basit ve kullanışlı olduğunu görebilirsiniz.

·Foreach döngüsü kullanırken ulaştığımız dizi elemanları readonly dir. Yani yukarıdaki örnek üzerinde anlatacak olursak foreach döngüsü içinde diziElemanı adlı integer değişkenin içerdiği değeri değiştiremezsiniz. Eğer değiştirmeye kalkarsanız Cannot assign to 'diziElemanı' because it is a 'foreach iteration variable' hatası alırsınız. Eğer yazdığınız uygulamada dizi elemanlarını döngü içinde değiştirmek istiyorsanız for döngüsü kullanmanızı tavsiye ederim.

·String tipindeki bir değişkende char tipindeki verilerin birleşmesinden oluşmuş bir dizidir. Öyleyse foreach döngüsü kullanarak aşağıdaki gibi bir stringin elemanlarını erişebilirsiniz.

string metin = "C# Diziler Örneği";foreach (char harf in metin){Console.WriteLine("Harf = {0} ", harf);}


Çok Boyutlu Diziler (Multidimensional Array)

Çok boyutlu bir dizi ‘dizinin dizisi’ şeklinde tabir edilebilir. Her elemanı başka bir dizi olan diziler çok boyutlu bir dizidir. Çok boyutlu bir dizi veritabanında her satırında birden fazla kolon bulunan bir tabloya benzetilebilir. Eğer her satırda bulunan her kolon kendi içinde başka bir dizi barındırmıyorsa bu tür dizilere 2 boyutlu diğer bir değişle çok boyutlu diziler denir. Eğer her kolonda kendi içinde başka bir dizi barındırıyorsa bu tür dizilere n boyutlu diziler denir. Burda n ifadesi dizinin derinliğini ifade eder.

Çok boyutlu diziler iki çeşittir;

·Düzenli Diziler: Her satırı aynı sayıda kolon barındıran diziler.

·Düzensiz Diziler (Jagged Array) : Her satırı farklı sayıda kolon barındıran diziler.

Çok boyutlu dizileri şekillerle anlatmaya çalışalım.

Not: Dizilerin ilk elemanının indeks numarasının 0 olduğunu unutmayın.

 

Dizilerin Tanımlanması ve Değer Atamaları

Tek boyutlu bir dizinin nasıl tanımlandığını ve nasıl değer atayacağımızı yukarda anlatmıştık. Şimdi Tek boyutlu dizi dahil tüm dizi tiplerini nasıl tanımlayacağımıza bakalım.

Tek Boyutlu Diziler:

//Dizinin Oluşturulmasıint[] intDizi = new int[5];//Dizi elemanlarına değer atamasıintDizi[0] = 36; //dizinin ilk elemanına 36 değeri atandıintDizi[2] = 26; //dizinin ikinci elemanına 26 değeri atandıintDizi[4] = 32; //dizinin son elemanına 32 değeri atandı

 

Çok Boyutlu Diziler:

//Dizinin Oluşturulmasıint[,] intCokBDizi = new int[2, 3];//Dizi elemanlarına değer atamasıintCokBDizi[0, 0] = 23;intCokBDizi[0, 1] = 25;intCokBDizi[0, 2] = 33;intCokBDizi[1, 0] = 41;intCokBDizi[1, 1] = 29;intCokBDizi[1, 2] = 93;

Çok Boyutlu Dizilerin Elemanlarına Döngü İle Ulaşmak

for döngüsü:

//Dizi elemanlarını for döngüsü ile bulmak.for (int row = 0; row < intCokBDizi.GetLength(0); row++){for (int col = 0; col < intCokBDizi.GetLength(1); col++){Console.WriteLine("Dizinin {0},{1} indeksindeki değeri : {2}",row,col,intCokBDizi[row,col]);}}

 Örnek :  Sayısal loto için tahminde bulunan program örneği diziler için… 

static void Main(string[] args)
        {
            Console.WriteLine("Bu haftaki şanslı sayılar");
            Console.WriteLine("**************************");
            Console.WriteLine("--------------------------");
            Console.WriteLine("**************************");
            Console.WriteLine();
            Random rnd = new Random();
            int[] rastgelesayi = new int[6];
            for (int i = 0; i < 6; i++)
            {
                rastgelesayi[i] = rnd.Next(2, 49);
            }
            Array.Sort(rastgelesayi);
            for (int i = 0; i < 6; i++)
            {
                Console.Write(rastgelesayi[i] + " ");
            }
            Console.ReadLine();
        }


static void Main(string[] args)
        {
            int[] integerDizi = { 4, 8, 23, 64, 35,56,78,45 };
            for (int i = 0; i < integerDizi.Length ; i++)
            {
                Console.WriteLine("İntegerDizi[{0}]= {1} ", i, integerDizi[i]);
            }
            
            foreach (int i  in integerDizi )
            {
                Console.WriteLine(i);
            }

            object[] nesne = { 4, "kemal", "murat", 5, 3.6M ,7.3};
            foreach (object  i in nesne)
            {
                Console.WriteLine(i);
            }
        }

Code First TPH, TPH, TPC

Mixing inheritance strategies in Entity Framework models 

The Microsoft Entity Framework v4 runtime supports three entity inheritance models: TPT, TPH, and TPC. When using the built-in EF designer and tools in Microsoft Visual Studio 2010, the default inheritance strategy in model-first scenarios is TPT. TPH inheritance can be manually mapped in the designer, and TPC requires editing the mapping (MSL) in the EDMX file manually or using third party tools.

TPT, TPH, and TPC explained

TPT is short for Table Per Type. In TPT inheritance, there is one central table containing all the base class members and then one table per subclass containing the key and the members that are immediate (non-inherited) members of the subclass. In database terms this can be described as a normalized model, with additional tables for members that are not always present.


tptIllustration

TPH is short for Table Per Hierarchy. In TPH inheritance there is only one table representing the base class and all subclasses. Members must be nullable to avoid errors when a subclass don't contain members of another subclass. In database terms TPH can be described as a denormalized model, since one wide table is used to represent all of the types in the hierarchy with columns that are left with a null value if they are not members of the entity type.tphIllustration

TPC is short for Table Per Concrete type. In TPC inheritance, every class in a inheritance hierarchy will have their own table.

The inheritance hierarchy masks the fact that there are several independent underlying tables, representing each subtype.


tpcIllustration

 

http://huagati.blogspot.com/2010/10/mixing-inheritance-strategies-in-entity.html

EntityFramwork Code First 1

Açıklama kısmını sora yazacağım...

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CodeFirst
{
    class Program
    {
        static void Main(string[] args)
        {
            UrunEkle();
            using (ShopVeriTabani db = new ShopVeriTabani())
            {
                //category bilgisiniide yazdırmak istiyorsa Include deyimini kullanmalıyız.
                foreach (var item in db.Products.Include("Category"))
                {
                    Console.WriteLine("{0}  {1}  {2} ", item.Name,item.Price,item.Category.Name );
                }
            }
            
        }

        static void UrunEkle()
        {
            using (ShopVeriTabani db = new ShopVeriTabani())
            {
                var myCategory = new Category { Name = "computer" };
                var urun = new Product
                {
                    Name = "Biber",
                    Price = 12.65m,
                    Category = myCategory
                };
                db.Products.Add(urun);
                db.SaveChanges();
            }
        }
    }


    public class Category
    {
        public int CategoryId { get; set; }
        public string Name {get;set;}

        public List<Product> Products { get; set; }
    }

    public class Product
    {
        public int ProductId { get; set; }
        public string Name { get; set; }
        public decimal Price { get; set; }

        public Category Category { get; set; }

    }

    public class ShopVeriTabani : DbContext
    {
        public DbSet<Category> Categories { get; set; }
        public DbSet<Product> Products { get; set; }
    }
}

Entity Framework, Code First Complex Type (Komplesk, karışık tipler)

Merhaba arkadaşlar ben hemen makalenin konusu olan EntityFramework  Comple Type'' ları anlatıyor olcağım. Aslından bu makaleyi TPC,TPS,TPC tipleril birleştirerek anlatmak istiyordum.Konu basit fakat geniş olduğu için tek makelede anlatmaya çalışacağım.. Makeleyi anlamınız için EntityFramwork ve c#, birazda code first hakkında bilgi sahibi olmanız gerekmekte. Aslında bize bu tipi kullanmanın en buyuk faydalarından biri yazım kolaylığı olması veri tabamızın düzgün, kodların  clean code olması açısından önemli.  

Senaryomuza göre basit bir  POCO(Plain Old CLR Objects)  classı yazalım.. Porje hazırlerken consoleaplication uyglaması yaratıyorum.. Nuget Console uygulması yüklenmiş vir studyo 2010 veya studio 2012 programı ile EntityFramworkü projenin üzerinda sağ tuşa basarak veya nuget cosolle den aşağıdaki kodu yazarak yükleyebilirim.

 PM> Install-Package EntityFramework -Version 5.0.0 

 

 

public class Personel
    {
        public int PersonelId { get; set; }
        public int SGKNo { get; set; }
        public string Ad{get;set;}
        public string Soyad { get; set; }
        public string Cadde { get; set; }
        public string  Mahalle { get; set; }
        public string PostaKodu { get; set; }
    }



Bole bir tanımlamada göreceğiniz gibi gereksiz tanımlamalar mevcuttur.. Bunu daha düzgün hale getirelim.. Asıl amaç Null(Boş) değer içerebilecek alanları kök tablodan ayırmaktır.

public class Personel
    {
        public int PersonelId { get; set; }
        public int SGKNo { get; set; }
        public string Ad{get;set;}
        public string Soyad { get; set; }
    }

    public class Adres 
    {
        public int AdresId { get; set; }
        public string Cadde { get; set; }
        public string Mahalle { get; set; }
        public string KapiNo { get; set; }
        public string PostaKodu { get; set; }
    }

Halinde yazalım. Burada unutmamaız gereken bir kural var. complex Tipler Key içermezler. O yüzden AdresId satırını açıklama sat��rına dönüştürelim..

//public int AdresId { get; set; }

Complex Tip tanımlama Kuralları(convention Rule)
Şimdi Code first yaklaşımında convention kuralları denen bir kurallar bütünü bulunmakta. Mesala Adres sınıfında public int Id{get;set;} veya public int AdresId{get;set;} yapmam, convention kurallarına göre o alanın key olması sağlamakta.

Commplex Type Convention Kuralları
1. Key anahtarına sahip olan bir özellik içermemeli
2. Basit tipler olmalı
3. Başka bir clasın içnede kullanırken Collection haline dönüştürmemiz gerekir. Mesala List<Adres>

Ayrıca personel tanımlarken adress nesnesi balatılmalı veya
public class Personel
    {
        public Personel()
        {
            Fatura = new Adres();
        }
modelin oluştuğu yerde fatura bilgileri girilmelidir. Ben Aşağıdaki gibi her iki yöntemide seçtim..

using (DataBaseContext  db=new DataBaseContext() ) {
            new List<Personel> { 
                new Personel{ Ad="kemal", Soyad="Yürek",  SGKNo=897897897, 
                    Fatura= new Adres{Cadde="Yeni Cadde.", KapiNo="54", PostaKodu="13212"}}
               ,new Personel{Ad="Tarkan", Soyad="Ay",  SGKNo=980989089,
               Fatura= new Adres{Cadde="Yeni Cadde.", PostaKodu="13212"}}
            }.ForEach(t=>db.Personeller.Add(t));   //değişiklik olsun diye fluent api kullanarak ekledim..

            db.SaveChanges();
            }
          
        }

Görüldüğü gibi Aşağıdaki veritabanı oluşmaktadır.
 

 

 

İllaki adres poco clasında AdresId isimli bir Key özellikli bir alan olması gerekiyorsa poco clasından başında ComplexType attribütünü(nitelik) kullanabilirsiiniz. Aşağıdaki gibi kullanılabilir.

   [ComplexType]
    public class Adres 
    {
        public int AdresId { get; set; }
        public string Cadde { get; set; }
        public string Mahalle { get; set; }
        public string KapiNo { get; set; }
        public string PostaKodu { get; set; }
    }

 

 

Görüldüğü gibi AdresId de veritabanızmızda görüncektir.

 

[ComplexType] abtiribute Data Annotions kullanmak için yerine projeye  aşağıdaki satırı eklemek zorundasınız. 

using System.ComponentModel.DataAnnotations.Schema; 
veya bu işlemi aşağıdaki gibi Fluent Api kullanarakda belitebilirsiniz.
public class DataBaseContext : DbContext
    {
        public DbSet<Personel> Personeller { get; set; }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.ComplexType<Adres>(); ///burada belirttim.
        }
    }

Projenin tamamını aşağıdaki gibi yapalım. Ayrıcı model üzerinde yaptığınız değişiklikler migrations işlemi yapacaksınız, veya veritabanınıda çalıştırmadan once silebilir. Üçüncü bir yöntem olarak Database.SetInitializer(new ProjeInit()); yöntemini kullanabilirsiniz.
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.ModelConfiguration.Conventions;

namespace ComplexType
{
    class Program
    {
        static void Main(string[] args)
        {
            Database.SetInitializer(new ProjeInit());
            using (DataBaseContext db = new DataBaseContext())
            {
                new List<Personel> { 
                new Personel{ Ad="kemal", Soyad="Yürek",  SGKNo=897897897, 
                    Fatura= new Adres{Cadde="Yeni Cadde.", KapiNo="54", PostaKodu="13212"}}
               ,new Personel{Ad="Tarkan", Soyad="Ay",  SGKNo=980989089,
               Fatura= new Adres{Cadde="Yeni Cadde.", PostaKodu="13212"}}
            }.ForEach(t => db.Personeller.Add(t));   //değişiklik olsun diye fluent api kullanarak ekledim..
                db.SaveChanges();

                Adres adres = new Adres { Cadde = "yeni cd", Mahalle = "Yeni mahalle", KapiNo = "87", PostaKodu = "8789" };
                Personel personlim = new Personel { Ad = "Mahmut", SGKNo = 89789, Soyad = "Bal",
                                                    Kargo = new Adres { Cadde = "Eski Cadde.", KapiNo = "54", PostaKodu = "13212" },
                                                    Fatura = new Adres { Cadde = "Orta Cadde.", KapiNo = "54", PostaKodu = "13212" }
                };
                db.Personeller.Add(personlim);
                db.SaveChanges();
                foreach (var item in db.Personeller)
                {
                    //verileri yazalımm.
                    Console.WriteLine("{0}\t{1}\t{2}\t{3}", item.PersonelId, item.Ad, item.Fatura.Cadde, item.Fatura.PostaKodu);
                }
            }
                
        }
    }

    public class Personel
    {
        public Personel()
        {
            Fatura = new Adres();
            Kargo= new Adres();
        }
        public int PersonelId { get; set; }
        public int SGKNo { get; set; }
        public string Ad{get;set;}
        public string Soyad { get; set; }
        public Adres Fatura { get; set; }
        public Adres Kargo { get; set; }
    }


    //[ComplexType]
    public class Adres 
    {
        public int AdresId { get; set; }
        public string Cadde { get; set; }
        public string Mahalle { get; set; }
        public string KapiNo { get; set; }
        public string PostaKodu { get; set; }
    }
    public class DataBaseContext : DbContext
    {
        public DbSet<Personel> Personeller { get; set; }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {

            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>(); //isimlerdirme kurallarını devre dışı bıraktım..
            modelBuilder.ComplexType<Adres>();
        }
    }


    class ProjeInit : DropCreateDatabaseAlways<DataBaseContext>
    {
        protected override void Seed(DataBaseContext context)
        {
            base.Seed(context);
        }
    }
}

Örneğimizi ben biraz daha karışık tipler kullanarak ukardaki gibi son aşamaya getirdim. ve çalıştırdım.. hale gitirdim.

Ayrıca Lİnq ile veri çekme kodları da yazdım. 

 

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.ModelConfiguration.Conventions;
using System.Linq;

namespace ComplexType
{
    class Program
    {
        static void Main(string[] args)
        {
            Database.SetInitializer(new ProjeInit());
            using (DataBaseContext db = new DataBaseContext())
            {
                new List<Personel> { 
                new Personel{ Ad="kemal", Soyad="Yürek",  SGKNo=897897897, 
                    Fatura= new Adres{Cadde="Yeni Cadde.", KapiNo="54", PostaKodu="13212"}}
               ,new Personel{Ad="Tarkan", Soyad="Ay",  SGKNo=980989089,
               Fatura= new Adres{Cadde="Yeni Cadde.", PostaKodu="4444"}}
            }.ForEach(t => db.Personeller.Add(t));   //değişiklik olsun diye fluent api kullanarak ekledim..
                db.SaveChanges();

                Adres adres = new Adres { Cadde = "yeni cd", Mahalle = "Yeni mahalle", KapiNo = "87", PostaKodu = "8789" };
                Personel personlim = new Personel { Ad = "Mahmut", SGKNo = 89789, Soyad = "Bal",
                                                    Kargo = new Adres { Cadde = "Eski Cadde.", KapiNo = "54", PostaKodu = "13212" },
                                                    Fatura = new Adres { Cadde = "Orta Cadde.", KapiNo = "54", PostaKodu = "13212" }
                };
                db.Personeller.Add(personlim);
                db.SaveChanges();
                foreach (var item in db.Personeller)
                {
                    //verileri yazalımm.
                    Console.WriteLine("{0}\t{1}\t{2}\t{3}", item.PersonelId, item.Ad, item.Fatura.Cadde, item.Fatura.PostaKodu);
                }

                //LinQ kullanarak Veri çekme örneği
                var personel = from b in db.Personeller
                               where b.Fatura.PostaKodu=="4444"
                               select b;


                foreach (var item in personel )
                {
                    //verileri yazalımm.
                    Console.WriteLine("\r\n{0}\t{1}\t{2}\t{3}", item.PersonelId, item.Ad, item.Fatura.Cadde, item.Fatura.PostaKodu);
                }

            }
                
        }
    }

    public class Personel
    {
        public Personel()
        {
            Fatura = new Adres();
            Kargo= new Adres();
            Bilgi = new PersonelBilgileri
            {
                Boy = new Olculer(),
                Kilo = new Olculer()
            }; 
        }
        public int PersonelId { get; set; }
        public int SGKNo { get; set; }
        public string Ad{get;set;}
        public string Soyad { get; set; }
        public Adres Fatura { get; set; }
        public Adres Kargo { get; set; }
        public PersonelBilgileri  Bilgi { get; set; }
    }

    public class Olculer
    {
        public decimal deger { get; set; }
        public string birim { get; set; }
    }



    public class PersonelBilgileri
    {

        //PersonelBilgileri burada complex tiptir.
        //PersonelBilgileri has no ke, yani key tanımlanmamış hatası alabilriiz.
        //[ComplexType] Data Annations burada devreye girmeyeceğin için veb 
        //Fluent Api kullanarak bu tablonun complext tip olduğunu belirttim 
        //ve çalıştı. Compxlex tipler muhahkak başlatılmalıdır. 
        //Hasvalue gibi bir okunur özellik yaratarak bunun bir değer içerip içermediğini kontro edebilriiz. 
        public Olculer  Boy { get; set; }
        public Olculer Kilo { get; set; }

        public bool HasValue
        {
            get
            {
                return ((Boy != null) || Kilo != null);
            }
        }
    }

    //[ComplexType]
    public class Adres 
    {
        public int AdresId { get; set; }
        public string Cadde { get; set; }
        public string Mahalle { get; set; }
        public string KapiNo { get; set; }
        public string PostaKodu { get; set; }
    }
    public class DataBaseContext : DbContext
    {
        public DbSet<Personel> Personeller { get; set; }
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {

            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>(); //isimlerdirme kurallarını devre dışı bıraktım..
            modelBuilder.ComplexType<Adres>();
            modelBuilder.ComplexType<PersonelBilgileri>();
        }
    }


    class ProjeInit : DropCreateDatabaseAlways<DataBaseContext>
    {
        protected override void Seed(DataBaseContext context)
        {
            base.Seed(context);
        }
    }
}

 

Bir sonraki makalede görüşmek üzere hoşçakalın..

The file '/Custom/Widgets/Calendar/widget.cshtml' does not exist.The file '/Custom/Widgets/Category list/widget.cshtml' does not exist.The file '/Custom/Widgets/Tag cloud/widget.cshtml' does not exist.The file '/Custom/Widgets/Page List/widget.cshtml' does not exist.The file '/Custom/Widgets/Month List/widget.cshtml' does not exist.