Code First и Database First в Entity Framework

public class Student
{
    public int StudentID { get; set; }
    public string Name { get; set; }
    public string Address { get; set; }
    public string Mobile { get; set; }
}

public class StudentContext : DbContext
{
    public DbSet<Student> Students { get; set; }
}

public class Student
{
    [Key]
    public int StudentID { get; set; }
    
    [Required]
    [StringLength(50, MinimumLength = 3)]
    [Display(Name = "Имя студента")]
    public string Name { get; set; }
    
    [StringLength(100)]
    public string Address { get; set; }
    
    [RegularExpression(@"^\d{10}$", ErrorMessage = "Мобильный должен содержать 10 цифр")]
    public string Mobile { get; set; }
}

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>()
        .Property(s => s.Name)
        .IsRequired()
        .HasMaxLength(50);
    
    modelBuilder.Entity<Student>()
        .Property(s => s.Mobile)
        .HasMaxLength(10);
        
    // Сложные связи и ограничения
    modelBuilder.Entity<Student>()
        .HasMany(s => s.Courses)
        .WithMany(c => c.Students)
        .Map(m => {
            m.ToTable("StudentCourses");
            m.MapLeftKey("StudentId");
            m.MapRightKey("CourseId");
        });
}

Enable-Migrations

Add-Migration AddStudentBirthDate

public partial class AddStudentBirthDate : DbMigration
{
    public override void Up()
    {
        AddColumn("dbo.Students", "BirthDate", c => c.DateTime());
    }
    
    public override void Down()
    {
        DropColumn("dbo.Students", "BirthDate");
    }
}

Update-Database

public class StudentContext : DbContext
{
    public StudentContext() 
        : base("name=StudentDB") // Имя строки подключения в конфиге
    {
        // Настройки инициализации
        Database.SetInitializer<StudentContext>(new CreateDatabaseIfNotExists<StudentContext>());
        // или для пересоздания БД при каждом запуске:
        // Database.SetInitializer<StudentContext>(new DropCreateDatabaseAlways<StudentContext>());
    }
    
    public DbSet<Student> Students { get; set; }
}

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    // Таблицы в единственном числе, а не множественном
    modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
    
    // Соглашения о внешних ключах
    modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();
}

public class MyContextConfiguration : DbConfiguration
{
    public MyContextConfiguration()
    {
        this.SetDatabaseInitializer(new NullDatabaseInitializer<StudentContext>());
        this.SetProviderServices("System.Data.SqlClient", SqlProviderServices.Instance);
        this.SetDefaultConnectionFactory(new SqlConnectionFactory());
        this.SetModelCacheKey(typeof(StudentContext), new StringModelCacheKey(typeof(StudentContext).Name));
    }
}

public class StudentContextInitializer : DropCreateDatabaseIfModelChanges<StudentContext>
{
    protected override void Seed(StudentContext context)
    {
        var students = new List<Student>
        {
            new Student { Name = "Алексей Петров", Address = "Москва", Mobile = "9001234567" },
            new Student { Name = "Мария Иванова", Address = "Санкт-Петербург", Mobile = "9007654321" }
        };
        
        students.ForEach(s => context.Students.Add(s));
        context.SaveChanges();
    }
}

Database.SetInitializer(new StudentContextInitializer());

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<Student>()
        .ToTable("TBL_STUDENTS", "school");
        
    modelBuilder.Entity<Student>()
        .Property(s => s.StudentID)
        .HasColumnName("STUDENT_ID");
        
    modelBuilder.Entity<Student>()
        .Property(s => s.Name)
        .HasColumnName("STUDENT_NAME");
}

modelBuilder.Entity<StudentCourse>()
    .HasKey(sc => new { sc.StudentId, sc.CourseId });

modelBuilder.Entity<Student>()
    .Property(s => s.Status)
    .HasConversion(
        v => v.ToString(),
        v => (StudentStatus)Enum.Parse(typeof(StudentStatus), v));

public partial class Student
{
    public int StudentID { get; set; }
    public string Name { get; set; }
    public string Address { get; set; }
    public string Mobile { get; set; }
}

public partial class SchoolEntities : DbContext
{
    public SchoolEntities()
        : base("name=SchoolEntities")
    {
    }
 
    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        throw new UnintentionalCodeFirstException();
    }
 
    public virtual DbSet<Student> Students { get; set; }
}

// Сгенерированная модель для хранимой процедуры
public virtual ObjectResult<GetTopStudents_Result> GetTopStudents(Nullable<int> count)
{
    var countParameter = count.HasValue ?
        new ObjectParameter("count", count) :
        new ObjectParameter("count", typeof(int));
 
    return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction<GetTopStudents_Result>("GetTopStudents", countParameter);
}

public virtual DbSet<StudentDetails> StudentDetails { get; set; }

// Автоматически сгенерированный код
public partial class Student
{
    public int StudentID { get; set; }
    public string Name { get; set; }
}
 
// Ваши дополнения в отдельном файле
public partial class Student
{
    // Дополнительные свойства или методы
    public string FullName => $"{Name} (ID: {StudentID})";
}

public class MyConfiguration : DbConfiguration
{
    public MyConfiguration()
    {
        this.SetQueryCacheKey(
            SchoolEntities.DefaultConnectionFactory,
            key => new DatabaseGeneratedViewCacheKey(key));
    }
}

View -> Other Windows -> Package Manager Console
PM> Install-Package EntityFramework.PowerTools

<#
foreach (var property in entity.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType)) {
  var isKey = entity.KeyMembers.Contains(property);
  var isNullable = property.Nullable;
  var maxLength = property.MaxLength;
#>
<# if (isKey) { #>
  [Key]
<# } #>
<# if (!isNullable) { #>
  [Required]
<# } #>
<# if (maxLength.HasValue) { #>
  [MaxLength(<#=maxLength.Value#>)]
<# } #>
  public <#=property.TypeName#> <#=property.Name#> { get; set; }
<# } #>

public class SchoolContextInitializer : IgnoreChangesInitializer<SchoolEntities>
{
  protected override void Seed(SchoolEntities context)
  {
      // Seed-данные для разработки
  }
}

// Настройка тестовой БД с Code First
using (var context = new TestStudentContext())
{
    context.Database.EnsureDeleted();
    context.Database.Migrate();
    context.Seed(); // Заполнение тестовыми данными
    
    // Выполнение тестов
}

migrationBuilder.Sql(@"
  UPDATE Orders SET Status = 'Pending' WHERE Status = '0';
  UPDATE Orders SET Status = 'Processing' WHERE Status = '1';
");

// Базовый интерфейс репозитория
public interface IRepository<T> where T : class
{
    T GetById(int id);
    IEnumerable<T> GetAll();
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
}
 
// Базовый интерфейс Unit of Work
public interface IUnitOfWork : IDisposable
{
    IStudentRepository Students { get; }
    ICourseRepository Courses { get; }
    void Save();
}

public class CodeFirstUnitOfWork : IUnitOfWork
{
    private readonly StudentContext _context;
    
    public CodeFirstUnitOfWork()
    {
        _context = new StudentContext();
        Students = new StudentRepository(_context);
        Courses = new CourseRepository(_context);
    }
    
    public IStudentRepository Students { get; private set; }
    public ICourseRepository Courses { get; private set; }
    
    public void Save()
    {
        _context.SaveChanges();
    }
    
    // Реализация IDisposable
}

public class DatabaseFirstUnitOfWork : IUnitOfWork
{
    private readonly SchoolEntities _context;
    
    public DatabaseFirstUnitOfWork()
    {
        _context = new SchoolEntities();
        Students = new StudentRepository(_context);
        Courses = new CourseRepository(_context);
    }
    
    // Остальной код такой же, как в Code First
}

// Базовый интерфейс спецификации
public interface ISpecification<T>
{
    Expression<Func<T, bool>> Criteria { get; }
    List<Expression<Func<T, object>>> Includes { get; }
    List<string> IncludeStrings { get; }
}
 
// Базовая реализация
public abstract class BaseSpecification<T> : ISpecification<T>
{
    public Expression<Func<T, bool>> Criteria { get; private set; }
    public List<Expression<Func<T, object>>> Includes { get; } = new List<Expression<Func<T, object>>>();
    public List<string> IncludeStrings { get; } = new List<string>();
    
    protected BaseSpecification(Expression<Func<T, bool>> criteria)
    {
        Criteria = criteria;
    }
    
    protected virtual void AddInclude(Expression<Func<T, object>> includeExpression)
    {
        Includes.Add(includeExpression);
    }
    
    protected virtual void AddInclude(string includeString)
    {
        IncludeStrings.Add(includeString);
    }
}

public class StudentsFromCitySpecification : BaseSpecification<Student>
{
    public StudentsFromCitySpecification(string city)
        : base(s => s.Address.Contains(city))
    {
        AddInclude(s => s.Courses);
    }
}

public interface IRepository<T> where T : class
{
    // Предыдущие методы...
    IEnumerable<T> Find(ISpecification<T> spec);
}
 
public class Repository<T> : IRepository<T> where T : class
{
    protected readonly DbContext Context;
    
    public Repository(DbContext context)
    {
        Context = context;
    }
    
    public IEnumerable<T> Find(ISpecification<T> spec)
    {
        return ApplySpecification(spec).ToList();
    }
    
    private IQueryable<T> ApplySpecification(ISpecification<T> spec)
    {
        var query = Context.Set<T>().AsQueryable();
        
        if (spec.Criteria != null)
        {
            query = query.Where(spec.Criteria);
        }
        
        query = spec.Includes.Aggregate(query, (current, include) => current.Include(include));
        
        return spec.IncludeStrings.Aggregate(query, (current, include) => current.Include(include));
    }
    
    // Реализация остальных методов...
}

public interface IStudentService
{
    IEnumerable<StudentDto> GetStudentsFromCity(string city);
    void EnrollStudentInCourse(int studentId, int courseId);
}
 
public class StudentService : IStudentService
{
    private readonly IUnitOfWork _unitOfWork;
    
    public StudentService(IUnitOfWork unitOfWork)
    {
        _unitOfWork = unitOfWork;
    }
    
    public IEnumerable<StudentDto> GetStudentsFromCity(string city)
    {
        var spec = new StudentsFromCitySpecification(city);
        return _unitOfWork.Students.Find(spec)
            .Select(s => new StudentDto
            {
                Id = s.StudentID,
                Name = s.Name,
                // Маппинг остальных свойств
            });
    }
    
    public void EnrollStudentInCourse(int studentId, int courseId)
    {
        var student = _unitOfWork.Students.GetById(studentId);
        var course = _unitOfWork.Courses.GetById(courseId);
        
        if (student == null || course == null)
            throw new ArgumentException("Student or course not found");
        
        // Логика проверки бизнес-правил
        
        student.Courses.Add(course);
        _unitOfWork.Save();
    }
}