Entity Framework

public class MyDbEntities : DbContext
{
   public IDbSet<Person> Persons { get; set; }

   // Fluent Configurations
   protected override void OnModelCreating(DbModelBuilder modelBuilder)
   {
      modelBuilder.Entity<Person>().ToTable("People");
      modelBuilder.Entity<Person>().Property(p => p.FirstName).IsRequired();
      // ...
   }
}

[Table("People")]
public class Person
{
   [Key]
   [Column("PersonId")]
   public int Id { get; set; }

   [Required]
   [MaxLength(255)]
   public string FirstName { get; set; }

   [Required]
   [MaxLength(255)]
   public string LastName { get; set; }

   // ...
}

// setze Initialisierer
Database.SetInitializer(new DropCreateDatabaseAlways<MyDbEntities>());

using (var context = new MyDbEntities())
{
    var person = new Person() {
        FirstName = "William",
        LastName = "Adama",
        DateOfBirth = DateTime.Now
    };

   context.Persons.Add(person); // Datenbank-Initialisierer wird ausgeführt
   context.SaveChanges();
}

using (var context = new MyDbEntities())
{
    // Erstelle zwei Personen-Entities
    var person1 = new Person() {
        FirstName = "William",
        LastName = "Adama",
        DateOfBirth = DateTime.Now
    };
    var person2 = new Person() {
        FirstName = "Laura",
        LastName = "Roslin",
        DateOfBirth = DateTime.Now
    };
    // Erstelle ein Adressen-Entity
    var address = new Address() {
        Street = "Market Street 70",
        City = "Philadelphia",
        State = "PA",
        Zip = "12345"
    };

    // Erste Variante
    context.Persons.Add(person1);

    // Zweite Variante
    // mit dem Kontext verlinken und als hinzugefügt markieren.
    context.Entry(person2).State = EntityState.Added;

    // Dritte Variante
    // Das Entity wird an ein bereits vom Kontext beobachtetes Entity gehängt
    person1.Address.Add(address);

    // Speichere Änderungen am Kontext in der Datenbank
    context.SaveChanges();
}

using (var context = new MyDbEntities())
{
    foreach (var person in context.Persons) // entspricht SELECT * FROM [Persons]
    {
       // führt zusätzliche SQL-Abfragen an die Adresses-Tabelle
       // mit einem entsprechenden JOIN aus
       foreach (var address in person.Adresses)
       {
           // ...
       }
    }
}

using (var context = new MyDbEntities())
{
    var persons = context.Persons;

    // Datenbankabfrage wird ausgeführt und als Liste zurückgegeben
    var allPersons = persons.ToList();

    // Keine weitere Datenbankabfragen durch Verwendung der Liste
    foreach (var person in allPersons) { /* ... */ }
    foreach (var person in allPersons) { /* ... */ }
}

var person = context.Persons.SingleOrDefault(p => p.PersonId == personId);

var person = (from p in context.Persons
              where p.PersonId == personId
              select p).SingleOrDefault();

var person = context.Persons.Find(personId);

// lazy loading
// nur die Personen werden abgefragt und geladen
var persons = context.Peoples;

// eager loading
// Adressen werden bereits bei der Abfrage der Personen geladen
var persons = context.Peoples.Include("Addresses");

// LINQ-to-Entities Beispiel für eager loading
var persons = context.Peoples.Include("Addresses").Where(p => p.FirstName == fname);

// LINQ-to-Entities Beispiel für eager loading
var persons = context.Peoples.Include(p => p.Addresses).Where(p => p.FirstName == fname);

// explicit loading
var persons = context.Peoples; // wie lazy loading; Adressen werden nicht mitgeladen
foreach (var person in persons)
{
    person.Addresses.Load(); // explicit loading; navigation properties für Adressen werden geladen
    foreach (var address in person.Addresses)
    {
        // ...
    }
}

using (var context = new MyDbEntities())
{
    // Abfrage eines Entities aus der Datenbank
    var person = context.Persons.SingleOrDefault(p => p.Id == id);
    if (person == null)
       return;

    context.Persons.DeleteObject(person);
    context.SaveChanges();
}

using (var context = new MyDbEntities())
{
    // Abfrage eines Entities aus der Datenbank
    var person = (for p in context.Persons.SingleOrDefault(p => p.Id == id);

    if (person == null)
        return;

    context.Entry(person).State = EntityState.Deleted; // Entity zur Löschung markieren
    context.SaveChanges(); // Entity in der Datenbank löschen
}

static Func<MyDbEntities, int, ObjectQuery<Person>> QueryContactById =
    CompiledQuery.Compile<MyDbEntities, int, IQueryable<Person>>( (context, personId) => context.Persons.Select(p => p.Id == personId) );

using (var context = new MyDbEntities())
{
    using (var scope = new TransactionScope())
    {
        // Der TransactionScope sucht den neuesten Context auf dem
        // Stacktrace und verlinkt sich automatisch mit diesem
        try
        {
            // Bearbeitung von Entities

            context.SaveChanges(); // Speichern der Änderungen in der Datenbank
            scope.Complete(); // Transaktion wird abgeschlossen
        }
        catch (InvalidOperationException e)
        {
            // Transaktion fehlgeschlagen
        }
    } // scope.Dispose()
} // context.Dispose()