ASP .NET MVC 3 - Alterando o  modelo de dados - Data Annotations - EF - IV


Este artigo é baseado no original: Creating an Entity Framework Data Model for an ASP.NET MVC Application (1 of 10) com adaptações e pequenos ajustes feitos por mim.

Antes de prosseguir verifique se você possui os seguintes recursos instalados:

Esta é quarta parte do artigo e você esta chegando agora deve ler obrigatoriamente as partes anteriores:

  1. ASP .NET MVC 3 - Criando uma aplicação ASP .NET MVC3
  2. ASP .NET MVC 3 - Implementando as funcionalidades CRUD básicas com EF - II
  3. ASP .NET MVC 3 - Ordenação, Filtragem e Paginação com EF - III

Neste artigo vamos mostrar como alterar o modelo de dados atual incluindo mais entidades e relacionamentos usando os atributos Data Annotation para controlar o comportamento do nosso modelo de classes.

Usando atributos para controlar a formatação, validação e o mapeamento do banco de dados

Abra o Visual Web Developer 2010 Express Edition e no menu File clique em Open Project; a seguir selecione o projeto que já foi criado no terceiro artigo com o nome UniversidadeMacoratti e clique em OK;

A estrutura do projeto exibida na janela Solution Explorer deverá ser a seguinte:

Obs: Se você quiser continuar a partir deste artigo faça o download do projeto UniversidadeMacoratti_3.zip para abri-lo no Visual Web Developer 2010 Express Edition.

O modelo de classes definido em nossa aplicação utiliza as seguintes entidades: Estudante, Curso, Matricula:

A seguir veremos os atributos que você pode incluir ao modelo de classes existente para especificar a formatação, validação e o mapeamento do banco de dados. Para isso vamos alterar o modelo de dados Escola pela inclusão de atributos as classes que já foram criadas e criar novas classes para o resto dos tipos das entidades no modelo.

Usando o atributo DisplayFormat

Nas páginas da nossa aplicação atual a data de matrícula do estudante exibe a hora junto com a data mas o que nos interessa na verdade é somente a data. Vamos então usar os atributos do Data Annotation para alterar o código permitindo que a informação seja exibida da forma que desejamos em todas as páginas pertinentes.

Os atributos Data Annotation foram introduzido no .NET 3.5 como uma forma de adicionar a validação para as classes usadas por aplicações ASP.NET. Desde aquela época, o RIA Services começou a usar anotações de dados e eles agora fazem parte do Silverlight também. No EF 4.0 o Code-First permite que você construa um EDM usando código (C#/VB .NET) e também permite realizar a validação com atributos Data Annotations.

Para este recurso devemos usar o namespace System.ComponentModel.DataAnnotations pois é ele que provê atributos de classes (usados para definir metadados) e métodos que podemos usar em nossas classes para alterar as convenções padrão e definir um comportamento personalizado que pode ser usado em vários cenários.

Com o projeto aberto, na janela Solution Explorer abra a pasta Model e em seguida abra a o arquivo Estudante.vb.

Inclua a declaração :  Imports System.ComponentModel.DataAnnotations

Para utilização do namespace do Data Annotation e a seguir na propriedade DataMatricula inclua o atributo DisplayFormat como mostrado no trecho de código a seguir:

A cadeia de formato {0:d}  especifica que apenas uma data curta deve ser exibida para a propriedade DataMatricula.

A configuração ApplyFormatInEditMode especifica que esta formatação também deve ser aplicada quando o valor é exibido em uma caixa de texto para edição.
(Você pode não desejar este comportamento para alguns campos - por exemplo, para valores de moeda, você pode não querer o símbolo da moeda na caixa de texto para edição.)

Execute o projeto novamente e abra a página para exibir as  informações dos estudantes. Note que a data exibida não inclui mais a informação da hora estando no seu formato dd/mm/yyyy que o que nos interessa. Todas as demais páginas serão afetadas por esta alteração.

Usando o atributo MaxLength

Podemos também regras para validação de dados e mensagens usando atributos. Vamos supor que desejamos limitar o tamanho do nome informado pelo usuário a 50 caracteres. Para implementar isso usando atributos devemos incluir o atributo MaxLength na propriedade Nome.

Abra o arquivo Estudante.vb na pasta Models e altere o código conforme abaixo:

Na propriedade Nome incluímos o atributo <MaxLength(50)> para indicar o tamanho máximo permitido. Se for informado um valor maior a mensagem de erro padrão será exibida.

Na propriedade Sobrenome incluímos o atributo <MaxLenght(50), ErrorMessage:="O sobrenome não pode ter mais de 50 caracteres")> para indicar o tamanho máximo. Se for informado um valor maior a mensagem de erro definida na propriedade ErrorMessage será exibida.

Executando o projeto e abrindo a página para Estudantes; depois de clicar no botão Criar Novo e informar valores para nome e sobrenome iremos obter o resultado abaixo:

É um bom procedimento definir o tamanho máximo das propriedades do tipo string caso contrário o Code First ao criar o banco de dados irá definir as colunas correspondentes com tamanho máximo permitido para strings o que não é muito eficiente.

Usando o atributo Column

Você pode também usar atributos para controlar como suas classes e propriedades são mapeados para o banco de dados.

Suponha que você tenha definido o nome PrimeiroNome para o campo relativo ao nome, porque este campo pode conter mais de um nome. Ex: Jose Carlos

Mas você deseja que a coluna de banco de dados venha a ser definida com o nome Nome, pois os usuários estão acostumados com esse padrão. Para fazer este mapeamento, você pode usar o atributo de Column.

O atributo Column especifica que quando o banco de dados for criado, a coluna da tabela Estudante que mapeia para a propriedade PrimeiroNome seja nomeada como Nome.(e não PrimeiroNome)

Em outras palavras, quando o seu código se referir a Estudante.PrimeiroNome, os dados serão obtidos ou atualizados na coluna Nome da tabela Estudante. (Se você não especificar os nomes da coluna, eles terão os mesmos nomes das propriedades.)

Criando a entidade Instrutor

Abra a pasta Models e com o botão direito do mouse selecione Add -> Class, informando o nome Instrutor.vb a seguir defina o seguinte código neste arquivo:

Imports System.Collections.Generic
Imports UniversidadeMacoratti.UniversidadeMacoratti.Models
Imports System.ComponentModel.DataAnnotations
Public Class Instrutor
    Public Overridable Property Cursos As ICollection(Of Curso)
    Public Property InstrutorID As Integer
    Public ReadOnly Property NomeCompleto As String
        Get
            Return PrimeiroNome & ", " & SobreNome
        End Get
    End Property
    <Column("Nome")> _
    <Required(ErrorMessage:="O nome é obrigatório.")> _
    <Display(Name:="Nome")> _
    <MaxLength(50)> _
    Public Property PrimeiroNome As String
    <Required(ErrorMessage:="O sobrenome é obrigatório.")> _
    <Display(Name:="Sobrenome")> _
    <MaxLength(50)> _
    Public Property SobreNome As String
    <DisplayFormat(DataFormatString:="{0:d}", ApplyFormatInEditMode:=True)> _
    <Required(ErrorMessage:="A data de admissão é obrigatória.")> _
    <Display(Name:="Data Admissão")> _
    Public Property DataAdmissao As Date
    Public Overridable Property Diretoria As Diretoria
End Class
Atenção !!!

Para que não ocorra um erro durante a definição do código ao lado você deve criar antes na pasta Models a classe Diretoria

Clique com o botão direito sobre a pasta Models e selecione Add-> Class e informe o nome Diretoria.vb

Vamos definir esta classe mais adiante.

Destaques do código:

A propriedade PrimeiroNome será mapeada para a coluna Nome no banco de dados

A propriedade NomeCompleto é somente leitura e retorna o valor da concatenação da propriedade PrimeiroNome com a propriedade Sobrenome.

O atributo Required indica que o campo é obrigatório.

O atributo Display define strings localizáveis para os tipos de entidades e membros que são usados na interface do usuário.

As propriedades Cursos e Diretoria são propriedades de navegação e são definidas como Overridable (virtual) para poder usar o recurso Lazy Loading do Entity Framework

Um instrutor pode ensinar em diversos cursos, desse modo a propriedade Cursos é definida como um conjunto de entidades Curso.  Por outro lado, um instrutor pode ter apenas uma Diretoria, assim a propriedade Diretoria é definida como uma única entidade Diretoria (que pode ser nula se nenhum cargo for atribuído)

Nota: Observe que várias propriedades são as mesmas nas entidades Estudante e Instrutor. Em outro artigo, onde iremos tratar da herança, vamos refatorar este código usando a herança para eliminar esta redundância.

Criando a entidade Diretoria

Vamos criar a entidade Diretoria criando o o arquivo Diretoria.vb na pasta Modesl e definindo a classe Diretoria. Clique com o botão direito sobre a pasta Models e selecione Add -> Class, informando o nome Diretoria.vb e a seguir defina o seguinte código nesta classe:

Imports System.Collections.Generic
Imports System.ComponentModel.DataAnnotations
Public Class Diretoria
    <Key()> _
    Public Property InstrutorID() As Integer
    <MaxLength(50)> _
    <Display(Name:="Localização")> _
    Public Property Localizacao() As String
    Public Overridable Property Instrutor() As Instrutor
End Class

 

Usando o atributo Key

Há um relacionamento um-para-zero-ou-um entre as entidade Instrutor e a entidade Diretoria.

Uma Diretoria só existe em relação ao instrutor que é atribuído e sua chave primária é também a chave estrangeira para a entidade instrutor.

Mas o Entity Framework não pode reconhecer automaticamente InstrutorID como a chave primária desta entidade, pois seu nome não segue a convenção usada pelo EF (ID ou nomedaclasseID); para que o EF reconheça InstrutorID como chave primária devemos usar o atributo Key:

 <Key()> _
    Public Property InstrutorID() As Integer

Definindo uma Propriedade de Navegação

A entidade Instrutor tem uma propriedade de navegação Diretoria anulável (porque um instrutor pode não ter uma Diretoria) , e a entidade Diretoria tem propriedade de navegação Instrutor não-anulável (porque uma Diretoria não pode existir sem um instrutor). Quando uma entidade Instrutor possui uma entidade Diretoria relacionada, cada entidade terá uma referência para o outra em sua propriedade de navegação.

Por isso definimos a propriedade de navegação :    Public Overridable Property Instrutor() As Instrutor

Modificando a entidade Curso

Vamos modificar a entidade Curso abrindo o arquivo Curso.vb na pasta Models e alterando o seu código conforme abaixo:

Obs: O código em azul foi incluído na entidade. Como ainda não criamos a entidade Departamento o VWD vai indicar um erro mas não se preocupe deixe assim por enquanto que mais adiante vamos criar a entidade Departamento.

Imports System.Collections.Generic
Imports System.ComponentModel.DataAnnotations
Namespace UniversidadeMacoratti.Models
    Public Class Curso
        <DatabaseGenerated(DatabaseGeneratedOption.None)> _
        <Display(Name:="Number")> _
        Public Property CursoID As Integer
        <Required(ErrorMessage:="O título é obrigatório.")> _
        <MaxLength(50)> _
        Public Property Titulo As String
        <Required(ErrorMessage:="O número de créditos é obrigatório.")> _
        <Range(0, 5, ErrorMessage:="Número de créditos deve estar entre 0 e 10.")> _
        Public Property Creditos As Integer
        <Display(Name:="Departamento")> _
        Public Property DepartamentoID() As Integer
        Public Overridable Property Departamento() As Departamento
        Public Overridable Property Instrutores() As ICollection(Of Instrutor)

        Public Overridable Property Matriculas As ICollection(Of Matricula)
    End Class
End Namespace

1- O atributo DatabaseGenerated com o parâmetro None na propriedade CursoID especifica que os valores da chave primária são fornecidos pelo usuário, ao invés de serem gerados pelo banco de dados.

 <DatabaseGenerated(DatabaseGeneratedOption.None)> _
        <Display(Name:="Number")> _

        Public Property CursoID As Integer

Por padrão, o Entity Framework assume que os valores da chave primária são gerados pelo banco de dados.  Em geral é esse o cenário padrão, mas para esse exemplo na entidade Curso, você vai usar um número de curso especificado pelo usuário como 1000 para um departamento, 2000 para outro departamento, e assim por diante.

2- As propriedades chave estrangeira e de navegação na entidade Curso de refletem as seguintes relações:

a- Um Curso é atribuído a um departamento, então existe uma chave estrangeira DepartamentoID e uma propriedade de navegação Departamento :

Public Property DepartamentoID() As Integer
Public
Overridable Property Departamento() As Departamento

b- Um Curso pode ter qualquer quantidade de Estudantes matriculados, dessa forma existe uma propriedade de navegação Matriculas;

Public Overridable Property Matriculas As ICollection(Of Matricula)

c- Um curso pode ser ministrado por múltiplos Instrutores , logo existe uma propriedade de navegação Instrutores:

  Public Overridable Property Instrutores() As ICollection(Of Instrutor)

Criando a entidade Departamento

Vamos criar a entidade Departamento criando o o arquivo Departamento.vb na pasta Models e definindo a classe Departamento. Clique com o botão direito sobre a pasta Models e selecione Add -> Class, informando o nome Departamento.vb e a seguir defina o seguinte código nesta classe:

Imports System.Collections.Generic
Imports System.ComponentModel.DataAnnotations
Imports UniversidadeMacoratti.UniversidadeMacoratti.Models
Public Class Departamento
    Public Property DepartamentoID() As Integer
    <Required(ErrorMessage:="O Departamento é obrigatório")> _
    <MaxLength(50)> _
    Public Property Nome() As String
    <DisplayFormat(DataFormatString:="{0:c}")> _
    <Required(ErrorMessage:="O orçamento é requerido.")> _
    <Column(TypeName:="money")> _
    Public Property Orcamento() As System.Nullable(Of Decimal)
    <DisplayFormat(DataFormatString:="{0:d}", ApplyFormatInEditMode:=True)> _
    <Required(ErrorMessage:="A data de início é requerida.")> _
    Public Property DataInicio() As DateTime
    <Display(Name:="Administrator")> _
    Public Property InstrutorID() As System.Nullable(Of Integer)
    Public Overridable Property Administrator() As Instrutor
    Public Overridable Property Cursos() As ICollection(Of Curso)
End Class

Anteriormente usamos o atributo Column para alterar o mapeamento do nome da coluna.

No código da entidade Departamento, o atributo Column está sendo usado para alterar o mapeamento do tipo de dado SQL para que a coluna seja definida usando o tipo  money do SQL Server no banco de dados:

    <DisplayFormat(DataFormatString:="{0:c}")> _
    <Required(ErrorMessage:="O orçamento é requerido.")> _
    <Column(TypeName:="money")> _
    Public Property Orcamento() As System.Nullable(Of Decimal)

Isto normalmente não é necessário, porque o Entity Framework escolhe o tipo de dados SQL Server apropriado com base no tipo CLR que você definir para a propriedade. O tipo CLR decimal normalmente mapa para um tipo decimal do SQL Server. Mas neste caso você sabe que a coluna vai usar valores em moeda, e o tipo de dados money é mais apropriado.

As propriedades chave estrangeira e de navegação refletem as seguintes relações:

a -  Um departamento pode ou não ter um Administrador, e um administrador é sempre um Instrutor. Portanto, a propriedade InstrutorID esta incluída como uma chave estrangeira para a entidade Instrutor e a  propriedade é definida como anulável. A propriedade de navegação é chamada administrador, mas trata uma entidade Instrutor:

Public Property InstrutorID() As System.Nullable(Of Integer)
Public Overridable Property Administrator() As Instrutor

b- Um Departamento pode ter muitos cursos por isso existe uma propriedade de navegação Cursos:

Public Overridable Property Cursos() As ICollection(Of Curso)

Modificando a entidade Estudante

Vamos modificar a entidade Estudante abrindo o arquivo Estudante.vb na pasta Models e alterando o seu código conforme abaixo:

Imports System.Collections.Generic
Imports System.ComponentModel.DataAnnotations
Namespace UniversidadeMacoratti.Models
    Public Class Estudante
        Public Property EstudanteID() As Integer
            Get
                Return _estudanteID
            End Get
            Set(value As Integer)
                _estudanteID = value
            End Set
        End Property
        Private _estudanteID As Integer
        <MaxLength(50, ErrorMessage:="O sobrenome não pode ter mais de 50 caracteres")> _
        <Required(ErrorMessage:="O Sobrenome é obrigatório.")> _
         <Display(Name:="Sobrenome")> _
        Public Property SobreNome() As String
            Get
                Return _sobrenome
            End Get
            Set(value As String)
                _sobrenome = value
            End Set
        End Property
        Private _sobrenome As String
        <MaxLength(50)> _
        <Required(ErrorMessage:="O Nome é obrigatório.")> _
         <Display(Name:="Nome")> _
        Public Property Nome() As String
            Get
                Return _nome
            End Get
            Set(value As String)
                _nome = value
            End Set
        End Property
        Private _nome As String
        <DisplayFormat(DataFormatString:="{0:d}", ApplyFormatInEditMode:=True)> _
        <Required(ErrorMessage:="A data de matrícula é obrigatória.")> _
        <Display(Name:="Data de matricula")> _
        Public Property DataMatricula() As DateTime
            Get
                Return _datamatricula
            End Get
            Set(value As DateTime)
                _datamatricula = value
            End Set
        End Property
        Private _datamatricula As DateTime
        Public Overridable Property Matriculas() As ICollection(Of Matricula)
            Get
                Return _matriculas
            End Get
            Set(value As ICollection(Of Matricula))
                _matriculas = value
            End Set
        End Property
        Private _matriculas As ICollection(Of Matricula)
    End Class
End Namespace

Observe que nesta classe eu estou usando a notação antiga para definir as propriedades. Fiz isso para você sentir a diferença.

No código acima apenas incluímos (o código destacado em azul) alguns atributos Display e Required que já foram discutidos anteriormente.

Modificando a entidade Matricula

Vamos modificar a entidade Matricula abrindo o arquivo Matricula .vb na pasta Models e alterando o seu código conforme abaixo:

Imports System.Collections.Generic
Imports System.ComponentModel.DataAnnotations
Namespace UniversidadeMacoratti.Models
    Public Class Matricula
        Public Property MatriculaID As Integer
        Public Property CursoID As Integer
        Public Property EstudanteID As Integer
        <DisplayFormat(DataFormatString:="{0:#.#}", ApplyFormatInEditMode:=True, NullDisplayText:="Sem grau")> _
        Public Property Grau As System.Nullable(Of Decimal)
        Public Overridable Property Curso As Curso
        Public Overridable Property Estudante As Estudante
    End Class
End Namespace

Há um relacionamento muitos-para-muitos entre as entidades Estudante e Curso, e a entidade de Matricula corresponde a uma tabela de junção muitos-para-muitos com carga no banco de dados. Isto significa que a tabela Matricula contém dados adicionais além de chaves estrangeiras para as tabelas associadas (neste caso, uma chave primária e uma propriedade de Grau).

Customizando o Contexto

Em seguida, vamos adicionar as novas entidades para a classe ContextoEscola e personalizar alguns dos mapeamentos usando chamadas a API fluente. (A API é "fluente", porque ela muitas vezes é usada por fazer uma série de chamadas de métodos em ma única instrução.) Em alguns casos você precisa usar métodos em vez de atributos, porque não há nenhum atributo para uma função particular. Em outros casos, você pode optar por usar um método quando ambos os métodos e atributos estão disponíveis.

Vamos substituir o código do arquivo  ContextoEscola.vb contido na pasta DAL conforme abaixo:

Imports System.Collections.Generic
Imports System.Data.Entity
Imports UniversidadeMacoratti.UniversidadeMacoratti.Models
Imports System.Data.Entity.ModelConfiguration.Conventions
Namespace UniversidadeMacoratti.Models
    Public Class ContextoEscola
        Inherits DbContext
        
        Public Property Cursos() As DbSet(Of Curso)
        Public Property Departamentos() As DbSet(Of Departamento)
        Public Property Matriculas() As DbSet(Of Matricula)
        Public Property Instrutores() As DbSet(Of Instrutor)
        Public Property Estudantes() As DbSet(Of Estudante)
        Public Property Diretorias() As DbSet(Of Diretoria)
        Protected Overrides Sub OnModelCreating(modelBuilder As DbModelBuilder)
            modelBuilder.Conventions.Remove(Of PluralizingTableNameConvention)()
            modelBuilder.Entity(Of Instrutor)().
                HasOptional(Function(p) p.Diretoria).
                WithRequired(Function(p) p.Instrutor)
            modelBuilder.Entity(Of Curso)().
                HasMany(Function(c) c.Instrutores).
                WithMany(Function(i) i.Cursos).
                    Map(Function(t) t.MapLeftKey("CursoID").
                            MapRightKey("InstrutorID").
                            ToTable("CursoInstructor"))
            modelBuilder.Entity(Of Departamento)().HasOptional(Function(x) x.Administrator)
        End Sub
    End Class
End Namespace

As novas instruções no método OnModelCreating especificam as seguintes relações:

- relacionamento um-para-zero entre as entidades Instrutor e Diretoria;

  modelBuilder.Entity(Of Instrutor)().
    HasOptional(
Function(p) p.Diretoria).
        WithRequired(
Function(p) p.Instrutor)

- relacionamento muitos-para-muitos entre as entidades Curso e Instrutor. O código especifica a tabela e os nomes da coluna para a tabela de junção. Primeiro código pode configurar o relacionamento muitos-para-muitos para você sem este código, mas se você não chamá-lo, você terá nomes definidos como InstrutorInstrutorID para a coluna InstrutorID.  

    modelBuilder.Entity(Of Curso)().
        HasMany(
Function(c) c.Instrutores).
        WithMany(
Function(i) i.Cursos).
            Map(
Function(t) t.MapLeftKey("CursoID").
                MapRightKey(
"InstrutorID").
                    ToTable(
"CursoInstructor"))

- O relacionamento um-para-zero-ou-um entre as tabelas Instrutor e Departamento representado pela propriedade de navegação Departamento.Administrador:

    modelBuilder.Entity(Of Departamento)().HasOptional(Function(x) x.Administrator)

Após estas definições e ajustes vamos alterar o arquivo EscolaInitializer.vb na pasta DAL para reinicializar o nosso modelo novamente de forma que as alterações se reflitam no projeto.

O conteúdo do arquivo EscolaInitializer.vb deve ser alterado conforme o código a seguir:

Imports System.Collections.Generic
Imports System.Linq
Imports System.Web
Imports System.Data.Entity
Imports UniversidadeMacoratti.UniversidadeMacoratti.Models
Namespace UniversidadeMacoratti.DAL
    Public Class EscolaInitializer
        Inherits DropCreateDatabaseIfModelChanges(Of ContextoEscola)
        Protected Overrides Sub Seed(context As ContextoEscola)
            Dim estudantes = New List(Of Estudante)() From { _
                New Estudante() With { _
                  .Nome = "Jose Carlos", _
                  .SobreNome = "Macoratti", _
                  .DataMatricula = DateTime.Parse("2005-09-01") _
                }, _
                New Estudante() With { _
                  .Nome = "Miriam", _
                  .SobreNome = "Alonso", _
                  .DataMatricula = DateTime.Parse("2002-09-01") _
                }, _
                New Estudante() With { _
                  .Nome = "Jefferson", _
                  .SobreNome = "Anand", _
                  .DataMatricula = DateTime.Parse("2003-09-01") _
                }, _
                New Estudante() With { _
                  .Nome = "Janice", _
                  .SobreNome = "Siqueira", _
                  .DataMatricula = DateTime.Parse("2002-09-01") _
                }, _
                New Estudante() With { _
                  .Nome = "Yan", _
                  .SobreNome = "Li", _
                  .DataMatricula = DateTime.Parse("2002-09-01") _
                }, _
                New Estudante() With { _
                  .Nome = "Bianca", _
                  .SobreNome = "Justice", _
                  .DataMatricula = DateTime.Parse("2001-09-01") _
                }, _
                New Estudante() With { _
                  .Nome = "Laura", _
                  .SobreNome = "Norman", _
                  .DataMatricula = DateTime.Parse("2003-09-01") _
                }, _
                New Estudante() With { _
                  .Nome = "Nino", _
                  .SobreNome = "Olivetto", _
                  .DataMatricula = DateTime.Parse("2005-09-01") _
                } _
               }
            estudantes.ForEach(Function(s) context.Estudantes.Add(s))
            context.SaveChanges()
            '
            Dim instrutores = New List(Of Instrutor)() From { _
              New Instrutor() With { _
                .PrimeiroNome = "Kim", _
                .SobreNome = "Novak", _
                .DataAdmissao = DateTime.Parse("1995-03-11") _
            }, _
            New Instrutor() With { _
                .PrimeiroNome = "Fadi", _
                .SobreNome = "Fakhouri", _
                .DataAdmissao = DateTime.Parse("2002-07-06") _
            }, _
            New Instrutor() With { _
                .PrimeiroNome = "Roger", _
                .SobreNome = "Harui", _
                .DataAdmissao = DateTime.Parse("1998-07-01") _
            }, _
            New Instrutor() With { _
                .PrimeiroNome = "Paulo", _
                .SobreNome = "Freire", _
                .DataAdmissao = DateTime.Parse("2001-01-15") _
           }, _
           New Instrutor() With { _
                .PrimeiroNome = "Roger", _
                .SobreNome = "Afonso", _
                .DataAdmissao = DateTime.Parse("2004-02-12") _
            } _
           }
            instrutores.ForEach(Function(s) context.Instrutores.Add(s))
            context.SaveChanges()
            Dim departamentos = New List(Of Departamento)() From { _
             New Departamento() With { _
              .Nome = "Inglês", _
              .Orcamento = 350000, _
              .DataInicio = DateTime.Parse("2007-09-01"), _
              .InstrutorID = 9 _
             }, _
             New Departamento() With { _
              .Nome = "Matemática", _
              .Orcamento = 100000, _
              .DataInicio = DateTime.Parse("2007-09-01"), _
              .InstrutorID = 10 _
             }, _
             New Departamento() With { _
              .Nome = "Engenharia", _
              .Orcamento = 350000, _
              .DataInicio = DateTime.Parse("2007-09-01"), _
              .InstrutorID = 11 _
             }, _
             New Departamento() With { _
              .Nome = "Economia", _
              .Orcamento = 100000, _
              .DataInicio = DateTime.Parse("2007-09-01"), _
              .InstrutorID = 12 _
             } _
            }
            departamentos.ForEach(Function(s) context.Departamentos.Add(s))
            context.SaveChanges()
            '
            Dim cursos = New List(Of Curso)() From { _
                        New Curso() With { _
                          .CursoID = 1050, _
                          .Titulo = "Quimica", _
                          .Creditos = 3, _
                          .DepartamentoID = 3, _
                          .Instrutores = New List(Of Instrutor)() _
                        }, _
                        New Curso() With { _
                           .CursoID = 4022, _
                           .Titulo = "Microeconomia", _
                           .Creditos = 3, _
                           .DepartamentoID = 4, _
                           .Instrutores = New List(Of Instrutor)() _
                        }, _
                        New Curso() With { _
                          .CursoID = 4041, _
                          .Titulo = "Macroeconomia", _
                          .Creditos = 3, _
                          .DepartamentoID = 4, _
                          .Instrutores = New List(Of Instrutor)() _
                        }, _
                        New Curso() With { _
                          .CursoID = 1045, _
                          .Titulo = "Calculo", _
                          .Creditos = 4, _
                          .DepartamentoID = 2, _
                          .Instrutores = New List(Of Instrutor)() _
                        }, _
                        New Curso() With { _
                          .CursoID = 3141, _
                          .Titulo = "Trigonometria", _
                          .Creditos = 4, _
                          .DepartamentoID = 2, _
                          .Instrutores = New List(Of Instrutor)() _
                        }, _
                        New Curso() With { _
                          .CursoID = 2021, _
                          .Titulo = "Composicao", _
                          .Creditos = 3, _
                          .DepartamentoID = 1, _
                          .Instrutores = New List(Of Instrutor)() _
                        }, _
                        New Curso() With { _
                          .CursoID = 2042, _
                          .Titulo = "Literatura", _
                          .Creditos = 4, _
                          .DepartamentoID = 1, _
                          .Instrutores = New List(Of Instrutor)() _
                        } _
                       }
            cursos.ForEach(Function(s) context.Cursos.Add(s))
            context.SaveChanges()
            cursos(0).Instrutores.Add(instrutores(0))
            cursos(0).Instrutores.Add(instrutores(1))
            cursos(1).Instrutores.Add(instrutores(2))
            cursos(2).Instrutores.Add(instrutores(2))
            cursos(3).Instrutores.Add(instrutores(3))
            cursos(4).Instrutores.Add(instrutores(3))
            cursos(5).Instrutores.Add(instrutores(3))
            cursos(6).Instrutores.Add(instrutores(3))
            context.SaveChanges()
            Dim matriculas = New List(Of Matricula)() From { _
                     New Matricula() With { _
                       .EstudanteID = 1, _
                       .CursoID = 1050, _
                       .Grau = 1 _
                     }, _
                     New Matricula() With { _
                       .EstudanteID = 1, _
                       .CursoID = 4022, _
                       .Grau = 3 _
                     }, _
                     New Matricula() With { _
                       .EstudanteID = 1, _
                       .CursoID = 4041, _
                       .Grau = 1 _
                     }, _
                     New Matricula() With { _
                       .EstudanteID = 2, _
                       .CursoID = 1045, _
                       .Grau = 2 _
                     }, _
                     New Matricula() With { _
                       .EstudanteID = 2, _
                       .CursoID = 3141, _
                       .Grau = 4 _
                     }, _
                     New Matricula() With { _
                       .EstudanteID = 2, _
                       .CursoID = 2021, _
                       .Grau = 4 _
                     }, _
                     New Matricula() With { _
                       .EstudanteID = 3, _
                       .CursoID = 1050 _
                     }, _
                     New Matricula() With { _
                       .EstudanteID = 4, _
                       .CursoID = 1050 _
                     }, _
                     New Matricula() With { _
                       .EstudanteID = 4, _
                       .CursoID = 4022, _
                       .Grau = 4 _
                     }, _
                     New Matricula() With { _
                       .EstudanteID = 5, _
                       .CursoID = 4041, _
                       .Grau = 3 _
                     }, _
                     New Matricula() With { _
                       .EstudanteID = 6, _
                       .CursoID = 1045 _
                     }, _
                     New Matricula() With { _
                       .EstudanteID = 7, _
                       .CursoID = 3141, _
                       .Grau = 2 _
                     } _
                    }
            matriculas.ForEach(Function(s) context.Matriculas.Add(s))
            context.SaveChanges()
            Dim diretorias = New List(Of Diretoria)() From { _
            New Diretoria() With { _
            .InstrutorID = 9, _
            .Localizacao = "Pedro 17" _
            }, _
            New Diretoria() With { _
            .InstrutorID = 10, _
            .Localizacao = "Joao 27" _
            }, _
            New Diretoria() With { _
            .InstrutorID = 11, _
            .Localizacao = "Senna 304" _
            } _
            }
            diretorias.ForEach(Function(s) context.Diretorias.Add(s))
            context.SaveChanges()
        End Sub
    End Class
End Namespace

Pronto ! já podemos executar o projeto para verificar as alterações feitas no modelo e seu reflexo em nossa aplicação.

Com isso terminamos essa parte aguarde em breve a abordagem de outros tópicos relacionados ao assunto.

Pegue o projeto completo aqui:   UniversidadeMacoratti_4.zip

"E a ninguém na terra chameis vosso pai, porque um só é o vosso Pai, o qual esta nos céus." "Nem vos chameis mestres, porque um só é o vosso Mestre, que é o Cristo." Mateus 23:9-10

Referências:

  1. VB .NET - Implementando o relacionamento um-para-muitos

  2. Entity Framework 4.0 - Lazy Loading - Macoratti.net

  3. Entity Framework 4.0 - Carregando dados - Macoratti.net

  4. Entity Framework 4.0 - Características e operações ... - Macoratti.net

  5. Entity Framework - Mestre Detalhes - Macoratti.net

  6. VS 2010 Novidades

  7. C# - Os tipos Nullable (Tipos Anuláveis)

  8. VB .NET - Nothing , Null (DBNull.Value) e Nullabe Types

  9. Entity Framework 4.0 - Lazy Loading - Macoratti.net

  10. ASP .NET MVC - Introdução

  11. ASP .NET - Apresentando o ASP .NET MVC 3 - Macoratti.net


José Carlos Macoratti