mylab

09_EntityFramework_CodeFirst

Os passos para trabalhar com o modo de 09_EntityFramework são:
_criar o contexto (classe que herda da DBcontext)
_especificar a connection string no ficheiro web.config

De seguida devemos:
criar os diferentes modelos de dados por exemplo:
aluno..

public class Aluno
{
public int AlunoID { get; set; }
public string AlunoNome { get; set; }
public DateTime? DataNascimento { get; set; }
public IList<Disciplina> Disciplinas { get; set; }
public Aluno()
{
}
}

Disciplina..

public class Disciplina
{
public int DisciplinaId { get; set; }
public string DisciplinaNome { get; set; }
public Curso Curso { get; set; }
public Docente Docente { get; set; }
public IList<Aluno> Alunos { get; set; }
}

Curso..

public enum Curso
{
INFORMATICA=1,
BIOMEDICA=2,
CIVIL=3,
MECANICA=4
}

Docente..

{
public class Docente
{
public int DocenteId { get; set; }
public string DocenteNome { get; set; }
}

Depois existe a necessidade de criar o contexto

public class EscolaContext : DbContext
{
public EscolaContext() : base("name=DefaultConnection")
{
}
public DbSet<Aluno> Alunos { get; set; }
public DbSet<Disciplina> Disciplinas { get; set; }
public DbSet<Docente> Docentes{ get; set; }
}

Especificar a conenection string no ficheiro web.config
Ir aos nugetpackage manager, e package manager manager console
Activar as Migrations: comando enable-migrations
Criar uma migration: comando add-migration “modeloInicialV0” (sempre que alterarmos os modelos)
E actualizar a base de dados: update-database

No ficheiro configuration.cs podemos realizar o seed das entidades e acrescentar dummy data nas tabelas
exemplo do seed (e a dummy data está noutro CS):

context.FixedStations.AddOrUpdate(
	f => new { f.RecordDateFs, f.LocalizationFs, f.StartIndexDisponibilityFs, f.EndIndexDisponibilityFs }, 
	DummyData.GetFixedStations().ToArray()
);
context.SaveChanges();

exemplo de dummy data:

context.Docentes.AddOrUpdate(a => a.DocenteNome, new Docente
{
DocenteNome = "Maria",
Disciplinas = new Collection<Disciplina>() {
new Disciplina() {DisciplinaNome="POO" }
}
});
}

É possivel alterar o que as convenções geram através de um processo de overriden:
usando DataAnnotaions ou FluentAPI

As DataAnnotaions:
simples de especificar, menos flexíveis, úteis para anotações simples: obrigações, tamanhos, máximos..

//exemplo de DataAnnotations
[Table("Alunos")]
public class Aluno
{}
//ou
[MaxLength(150), Required]
//ou
public DateTime? DataNascimento { get; set; }
//ou
[Column("Nome",TypeName="varchar")]
//ou
[ForeignKey("Docente")]
public int DocenteId { get; set; }
public virtual Docente Docente { get; set; }
//ou
[Key]
//ou
[NotMapped]

o FluentAPI:
permite configurar a configuração de relacionamentos entre classes mais complexas, separações de concerns
As fluentApi são escritas nos contextos
O código deve ser aplicado no método OnModelCreating(DbModelBuilder modelBuilder) da class que deriva do DbContext
Permite mais controlo na definição das relações usando HAS e o With

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
// Aplica as configurações recorrendo ao Fluent API
}

//exemplo de FluentAPI
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Entity<Disciplina>()
.Property(t => t.DisciplinaNome)
.IsRequired();
//ou
modelBuilder.Entity<Aluno>().ToTable("Alunos");
//ou
modelBuilder.Entity<Aluno>().HasKey(t => t.NAluno);

Podemos usar ambas mas temos que ter em conta que as precedências são:
FluentAPI
DataAnnotaions
Convenções

Os relacionamentos com o fluentApi:
HasMany() – Se A tem muitos objetos to B
HasRequired – Se A tem apenas um objeto de B
HasOptional – Se A tem 0 ou 1 objeto de B
WithMany() – Se B tem muitos objetos to A
WithRequired – Se B tem apenas um objeto de A
WithOptional – Se B tem 0 ou 1 objeto de A

//relacionamento 1-N
modelBuilder.Entity<Professor>()
.HasMany(p => p.Disciplinas)
.WithRequired(d => d.Professor)
.HasForeignKey(d => d.ProfessorId);
//relacionamento N-M
modelBuilder.Entity<Professor>()
.HasMany(p => p.Disciplinas)
.WithMany(d => d.Professores)
.Map(m => m.ToTable("ProfessorDisciplinas“)) 
//relacionamento 1-0..1
modelBuilder.Entity<Professor>()
.HasOptional(p => p.Disciplina)
.WithRequired(d => d.Professor);
//relacionamento 1-1
modelBuilder.Entity<Professor>()
.HasRequired(p => p.Disciplina)
.WithRequiredPrincipal(d => d.Professor);