|
Módulo 1 - Fundamentos
1a.
Apresentação - 4:58 minutos
- Apresentação do Curso
2a.
Introdução - 6:59 minutos
-
Apresentação do EF Core
3a. Configurando o Ambiente - 6:48 minutos
- Pacotes necessários
- EF Core Provider
- EF Core Tools
- Provedores de banco de dados
- Instalação dos pacotes : VStudio e Package Manager Console
4a.Abordagens de
desenvolvimento - 2:35 minutos
- Abordagem : Code-First e Database-First
- Apresentando Code-First
- Apresentando DB-First
- Vantagens de cada abordagem
5a. DbContext e DbSet - 6:52 minutos
- O Mapeamento ORM: Classes de domínio e BD
- Classes DbContext e DbSet
- Modelo de Entidades e Classe de Contexto
- O papel do DbContext
- O papel do DbSet
Atividade
- Atividade1
- Atividade2
- Resolução das Atividades
Exercício
- Exercício Proposto
- Resolução do Exercício
Módulo 2 - DB-First
1a. Abordagem DB-First : Criando o BD e tabela - 7:08 minutos
- Usando a Abordagem DB-First
- Criando o banco de dados e tabela no SQL Server
- Usando o Object Explorer do VS 2017 Community
2a. Acessando Dados via DB-First - 9:59 minutos
- Criando uma app no VS 2017
- Referenciar os pacotes do EF Core
- Criando a classe de Contexto
- Definir o mapeamento usando o DbSet<T>
- Definir o modelo de entidades
- Acessando e exibindo dados
3a. DB-First - Scaffolding I - 8:18 minutos
- Gerando as entidades e classe de contexto
- Usando o Scaffold-DbContext
- Definindo a string de conexão e o provedor do BD
- Aplicar o comando Scaffold-DbContext
4a.
DB-First - Scaffolding
II - 6:37 minutos
- Usando o Scaffold-DbContext
com mais de uma tabela
- Usando o banco de dados Northwind.mdf
- Gerando as entidades e classe de Context
- Aplicando o comando Scaffold-DbContext
5a. DB-First - Usando a linha de comando a NET CLI I - 7:19 minutos
- Usando o .NET Core SDK e o Visual Studio Code
- Usando a ferramenta de linha de comando NET CLI
- Criando um projeto console: dotnet new console
- Instalando os pacotes do EF Core: dotnet add package
- Criando o modelo de entidades e a classe de contexto
- Compilando e Executando o projeto: dotnet build e dotnet run
6a.
DB-First - Usando a linha de comando a NET CLI II - 6:15
minutos
- Usando o .NET Core SDK e o Visual Studio Code
- Usando a ferramenta de linha de comando NET CLI
- Instalando os pacotes do EF Core e das ferramentas
- Gerando o modelo de entidades e a classe de contexto via NET CLI
Atividades
- Atividade1
- Atividade2
- Atividade3
- Resolução das Atividades
Módulo 3 - Code-First
1a.
Conceitos - 3:25 minutos
- Apresentando a Abordagem Code-Frist
- Gerando o banco de dados e as tabelas
- Criando o modelo de entidades
- Criando a classe de Contexto
- Definindo o mapeamento DbSet<T>
- Definindo o provedor e a string de conexão
- Aplicando o Migrations : Add-Migrations e Update-Database
2a. Fundamentos do EF Core Migrations - 3:54 minutos
-
Apresentando o Migrations
- Add-Migration - gerando o script com comandos SQL
- update-database - aplicando o script e gerando o BD e tabelas
- Os pacotes necessários para usar o MIgrations
3a. Code-First : Criando o BD e tabelas - 9:05 minutos
-
Criando o modelo de entidades
- Criando a classe de contexto
- Usando o método OnConfiguring()
- Definindo o provedor do BD e a string de conexão
- Aplicando o migrations
- O Script de migração
4a. Populando o banco de dados Via código - 8:00 minutos
-
Populando o banco de dados com dados iniciais
- Opções : via código e via Migrations
- Populando o BD via código : classe SeedDatabase
- Usando o método Add/AddRange e SaveChanges
5a. Populando o banco de dados Via
Migrations - 4:33 minutos
-
Populando o banco de dados com dados iniciais
- Opções : via código e via Migrations
- Populando o BD via Migrations
- Usando os métodos Up() e Down() do migrations
- Usando o método SQL da instância MigrationBuilder
- Comandos SQL: Insert Into e Delete From
6a. Populando
o banco de dados usando HasData - 8:41 minutos
- Populando o banco de dados com dados iniciais
- Populando o BD via método HasData do EF Core 2.1
- Usando o método HasData no método OnModelCreating
- Criando um método de extensão para usar o HasData
7a. Code-First - Usando a linha
de comando a NET CLI I - 12:58 minutos
-
Usando o .NET Core SDK e o VS Code
- Usando a linha de comando NET CLI
- Criando um projeto via NET CLI : dotnet new console
- Instalando os pacotes do EF Core e do provedor do BD
- Criando a entidade e classe de contexto
- Definindo o mapeamento com DbSet<T>
- Aplicando Migrations e criando o BD e a tabela
Atividades
- Atividade1
- Atividade2
- Atividade3
- Resolução das Atividades
Módulo 4 - Tratando-Objetos: CRUD
1a. Incluindo dados - 9:53
minutos
-
Adicionando dados via DbContext
- Usando os métodos Add e AddRange
- Criar a entidade a ser incluida
- Criar uma instância da classe de Contexto
- Incluir a entidade no contexto via métodos Add ou AddRange
- Persistir as informações usando o método SaveChanges()
2a. Alterando dados - 6:04
minutos
-
Alterando dados de entidades existentes via DbContext
- O Cenário Conectado : entidades rastreadas pelo contexto
- Alterando o EntityState como Modified
- Persistir as informações usando o método SaveChanges()
- O EF Core gera um comando SQL UPDATE para atualizar o
BD
-3a.
Excluindo Dados - 4:50 minutos
-
Deletando entidades existenes via DbContext
- O Cenário Conectado : entidades rastreadas pelo
contexto
- Alterando o EntityState como Deleted
- Persistir as informações usando o método SaveChanges()
- O EF Core gera um comando SQL DELETE para atualizar o
BD
4a. Combinando Operações - 8:09
minutos
-
Realizando várias operações em um SaveChanges
- O SaveChanges é transacional
- Se alguma operação falar todas as operações falham
- Incluindo, alterando e excluindo entidades em um SaveChanges
- Persistindo as informações com SaveChanges()
Atividades
- Atividade1
- Resolução da Atividade
Módulo 5 - Configuração-Convenções
1a. As convenções de
Configuração I - 10:56 minutos
-
Chave Primária
- Schema
- Colunas das tabelas
- Tipos de dados das colunas
- Tabelas
2a. As convenções de
Configuração II - 6:27 minutos
- Nome
das Tabelas com base nas entidades relacionadas
- Exemplo de aplicação da Convenção
- Mapeando entidades sem a propriedade DbSet
3a. As convenções padrão III - Foreign key - 8:14 minutos
-
Convenções aplicadas a chave estrangeira - foreign key
- Nome prop. Navegacao+Nome Prop. Chave Primária+Id
- Nome prop. chave primária+Id
- Aplicando as convenções para foreign key
4a. As convenções de
Configuração IV - 4:24 minutos
-
Convenções adotadas para as colunas das tabelas
- Colunas nulas ou Null
- Tipos dados de referência e tipos primitivos anúláveis
- Colunas não nulas ou Not Null
- Chaves primárias e tipos primitivos : int, float, decimal, DateTime
- Aplicação em exemplo prático
5a. Convenções um-para-um - 6:09 minutos
-
Definindo o relacionamento um-para-um
- Propriedade de navegação referenciada ambas entidades
- Incluir prop. que defina a chave estrangeira (opcional)
- Exemplo prático
Atividades
- Atividade1
- Atividade2
- Atividade3
- Resolução das Atividades
Módulo 6 - Configuração : Data Annotation
1a.
Sobrescrevendo as Convenções - 8:51 minutos
- Sobrescrevendo as convenções usando a Configuração
- Data Annotations - decorar classes e propriedades com atributos
- Fluent API - usa métodos encadeados aplicados a entidades
- Como funcionam as configurações
- Exemplo prático no VS 2017
2a.
Configuração Data Annotations I - 7:20 minutos
-
Aplicando atributos Data Annotations
- System.ComponentModel.DataAnnotations
-
System.ComponentModel.DataAnnotations.Schema
- Atributos: Table e Column
- Aplicação prática
3a. Configuração Data
Annotations II - 6:06 minutos
- Aplicando atributos
Data Annotations
- Atributos : Key e DatabaseGenerated
- Aplicação
prática
4a.
Configuração Data Annotations III - 6:16 minutos
- Aplicando atributos
Data Annotations
- Atributos : NotMapped , Required (Not Null), MaxLength, StringLength
- Aplicação
prática
5a.
Configuração Data Annotations III - 9:13 minutos
- Aplicando atributos
Data Annotations
- Atributos : ForeignKey
- Opções de configuração para chave estrangeira
- Aplicação
prática
Atividade
- Atividade1
- Atividade2
- Resolução das Atividades
Módulo 7 - Configuração :
Fluent API
1a.
Sobrescrevendo as configurações : Fluent API - 4:10 minutos
- Apresentando a Fluent API
- Configurando Modelo, Entidades e Propriedades
- Como usar a Fluent API
- Usando o método OnModelCreating() e a instância de ModelBuilder
- Aplicando os métodos da Fluent API - chamada encadeada de métodos
- Definir classes de configuração separadas: IEntityTypeConfiguration<T>
2a.
Configuração Fluent API I - 5:42 minutos
-
Apresentando os métodos do Model
- Métodos: HasDefaultSchema(), Ignore<T>()
- Aplicação prática
- Métodos :
HasDbFunction(), HasSequence(), HasAnnotation()
3a. Configuração
Fluent API II - 5:32 minutos
-
Apresentando os métodos a nível de Entidade : ModelBuilder.Entity()
- As versões genéricas e não genéricas
- Métodos : ToTable() e HasKey()
- Aplicação
prática no VS 2017
|
4a.
Configuração Fluent API III - 7:56 minutos
-
Apresentando os métodos a nível de Entidade : ModelBuilder.Entity()
- Métodos: HasKey() com chaves compostas, HasIndex() e IsUnique(),
- HasAlternateKey() criando uma chave alternativa
- Aplicação
prática no VS 2017
5a.
Configuração Fluent API IV - 9:12 minutos
-
Apresentando os métodos a nível de Propriedade
- Usando ModelBuilder.Entity<T>().Property(p=> p.Propriedade)
- Métodos: HasColumnName(), HasColumnType(), HasDefaultValue()
- HasDefaultValueSql(), HasMaxLength(), IsRequired(),
- Aplicação
prática no VS 2017
6a.
Configuração Fluent API V - 4:55 minutos
-
Apresentando os métodos a nível de Propriedade
- Métodos: ValueGeneratedNever(), ValueGeneratedOnAdd()
-
ValueGeneratedOnAddOrUpdate(), IsConcurrencyToken()
- Aplicação
prática no VS 2017
7a.
Configuração Fluent API VI - 6:47 minutos
- Movendo a
configuração para classes separadas
- Classes de configuração : IEntityTypeConfiguration<T>()
- Usando o método Configure() e aplicando o ApplyConfiguration()
- Aplicação
prática no VS 2017
Atividades
- Atividade1
- Resolução da Atividade
Módulo 8 - Configuração : Relacionamentos
1a.
Relacionamentos - Terminologia e Conceitos - 7:16 minutos
- Modelo de dados, Entidade Principal, Chave
Principal,
- Entidade Dependente, Chave Estrangeira, Propriedade de Navegação
- Configurando relacionamentos -
Padrão Has/With (Fluent API)
- Padrão Has/With - HasOne / HasMany e WithOne / WithMany
2a.
Relacionamento um-para-um
- 7:33 minutos
-
Relacionamento um-para-um usando a Fluent API
- Definindo as propriedades de navegação de referência
- Padrão Has/With - HasOne/WithOne e HasForeignKey
- Aplicando Migrations
- Aplicação
prática no VS 2017
3a.
Relacionamento um-para-muitos
- 8:38 minutos
-
Relacionamento um-para-muitos usando a Fluent API
- Definindo as propriedades de navegação de referência e Coleção
- Padrão
Has/With - HasMany/WithOne e HasOne/WithMany
- Chave estrangeira: obrigatório e não obrigatória
- Relacionamento opcional, OnDelete(DeleteBehavior.valor)
- Cascade, Restrict e SetNull
4a.
Relacionamentos um-para-muitos Prática
- 10:27 minutos
- Exemplo
no VS 2017
- Relacionamento um-para-muitos usando a Fluent API
- Definindo as propriedades de navegação de referência e Coleção
- Padrão
Has/With - HasMany/WithOne e HasOne/WithMany
- Aplicando Migrations
5a.
Relacionamentos muitos-para-muitos Conceitos
- 7:32 minutos
-
Relacionamento muitos-para-muitos usando a Fluent API
- Criando a entidade que representa a tabela de junção
- Definir prop. de navegação e referência de cada entidade
- Definir relacionamento um-para-muitos entre entidades e entidade de junção
- Configurar chave estrangeira na entidade de junção como chave composta
- Aplicar padrão Has/With - HasOne/WithMany e HasForeignKey()
6a.
Relacionamentos muitos-para-muitos
-
10:19 minutos
-
Relacionamento um-para-muitos usando a Fluent API
- Criando entidade de junção
- Definindo prop. de navegação e referência nas entidades
- Configurando a chave composta via Fluent API
- Aplicando Migrations
- Exemplo
no VS 2017
Atividades
- Atividade1
- Resolução da Atividade
Módulo 9 - Gerenciando : Entidades
1a.
ChangeTracker - Conceitos 7:24 minutos
- Gerenciando as entidades do contexto com
ChangeTracker
- Cenário Conectado - DbContext
-
Classe ChangeTracker -
monitora o estado de cada entidade
- EntityState : Addedd, Modified, Deleted, Unchanged, Detached
- SaveChanges - INSERT, UPDATE, DELETE
2a.
ChangeTracker
- Prática
- 13:31 minutos
-
Gerenciando do estado das entidades no contexto
-
Monitorando o estado das entidades
- Exibindo o estado das entidades
- Alterando o estado das entidades
- Exemplo
no VS 2017
3a.
ChangeTracker
- Detached
- 5:55 minutos
- Cenário
Conectado
- DbContext usando ChangeTracker
- Estado da
entidade : Detached
- O contexto não rastreia entidades detached
- Exemplo no VS 2017
4a. Montando a instrução SQL
- 6:25 minutos
- Como o EF
Core monta o SQL após o SaveChanges()
- Operações : SELECT, INSERT, DELETE, UPDATE
- Estado
das entidades: Unchanged, Added, Deleted e Modified
- Métodos: Add, Remove
- Exibindo as consultas SQL no console
- Exemplo no VS 2017
5a. Montando a
instrução SQL no CRUD
- 8:44 minutos
- Como o EF
Core monta o SQL após o SaveChanges()
-
Incluindo, Alterando e Excluindo entidades e persistindo no BD
- Exibindo os comandos SQL CRUD no console após o SaveChanges
- Exemplo no VS 2017
6a. Mudança de
Estado das Entidades
-
2:00 minutos
- Resumo
sobre mudança de estado das entidades
- SELECT - Unchanged
- Alteração - Modified , SaveChanges-Update
- Exclusão - Remove - Deleted , SaveChanges-Delete From - Detached
- Inclusão - Add - Added - SaveChanges - Insert Into
Atividades
- Atividade1
- Resolução da Atividade
Módulo 10 - Consultando Dados
1a.
Consultas LINQ - Conceitos - 10:50 minutos
- Consultas baseadas no DbSet do DbContext
- DbSet é uma coleção de entidades - IQueryable
- Mapeia para a tabela do BD - padrão repositório
- LINQ - Query Sintax e Method Sintax - sintaxe usada
- Provedor do BD transcreve consulta LINQ para SQL
- Exemplo
no VS 2017
2a.
Consultas LINQ Diferidas - Como funcionam -
7:33 minutos
-
Consultas LINQ - linguagem C# fortemente tipada
- EF Core processa e cria uma representação pronta para executar
- Armazena o resultado em cache
- Passa o resultado para o provedor do banco de dados
- Converte a consulta LINQ em um comando SQL
- Consultas são executadas apenas quando os dados são consumidos
- Exemplo
no VS 2017
3a.
Consultas LINQ - Retornam um Valor Único
- 6:45 minutos
- Consultas
LINQ que retornam um único objeto
- Projeto exemplo usado nas consultas
- Metódos
de extensão: Single, SingleOrDefault, Find
- First, FirstOrDefault, Last, LastOrDefault
- Contrapartida dos métodos assíncronos
- Exemplo no VS 2017
4a.
Consultas LINQ - Agregação
- 9:52 minutos
- Consultas
LINQ que usam operadores de agregação
- Atuam nas propriedades numéricas de uma coleção
- Métodos :
Average, Count, Max, Min e Sum
- Exemplo no VS 2017
5a.
Consultas LINQ - Retornando múltiplos objetos
- 13:41 minutos
- Consultas
LINQ - filtrando, ordenando, projetando e agrupando dados
- Filtrando dados usando o operador Where
- Aplicando operadores de agregação : Count, Sum, Average
- Aplicando mais de uma condição e ordenando com OrderBy, ThenBy
- Projetando um resultado : operador Select e SelectMany
- Agrupando dados com GroupBy
6a.
Consultas LINQ com particionamento e Nativas
- 17:28 minutos
- Consultas
com particionamento : operadores Skip e Take
- Consultas nativas usando o método DbSet.FromSql(), limitações
- Executando procedimentos armazenados com e sem parâmetros
- Usando o método ExecuteSqlCommand() - stored procedures
- Exemplo
no VS 2017
7a.
Consultas LINQ - Sem Acompanhamento
-
8:57 minutos
- Consultas
em acompanhamento: conceitos e quando usar
- Não precisamos incluir, alterar e excluir dados
- Usar dados apenas para exibição
- Consultas sem acompanhamento são mais rápidas
- Usando o método AsNoTracking
- Alterar comportamento usando: QueryTrackingBehavior.NoTracking
- Exemplo
no VS 2017
8a.
Consultas Junçao - 8 Aulas - 35 minutos
1a. Aula Conceitos -
SQL Joins conceitos
- 4:07 minutos
2a.
Aula
Projeto - Apresentação do projeto
- 4:18 minutos
3a.
Aula
Inner Join - Consultas Inner Join
- 6:11 minutos
4a.
Aula
Left Outer Join - Consultas Left Outer
Join - 5:50 minutos
5a.
Aula
Right Outer Join - Consultas Rigth Outer
Join - 2:43 minutos
6a.
Aula
Full Outer Join - Consultas Full Outer
Join - 3:58 minutos
7a.
Aula
Cross Join - Consultas Cross Join
- 4:43 minutos
8a.
Aula
Group Join - Consultas Group Join
- 5:44 minutos
Atividades
- Atividade1
- Resolução da Atividade
Módulo 11 - Entidades Relacionadas
1a.
Carregando Entidades Relacionadas - 5:58 minutos
- Carregando entidades relacionados usando
propriedades de navegação
- Eager Loading, Explicit Loading e Lazy Loading
-
Exemplo no VS 2017
2a.
Entidades Relacionadas - Eager Loading -
9:47 minutos
- Eager
Loading - carregamento adiantado
- Usando o método Include para especificar dados relacionados
- Carregando diversos níveis com ThenInclude()
- Exemplo no VS 2017
|
3a.
Entidades Relacionadas - Explicit Loading
- 7:55 minutos
-
Carregando explicitamente uma propriedade de navegação
- Usando a API DbCOntext.Entry(entidade).Collection().Load
- Usando a
API DbCOntext.Entry(entidade).Reference().Load
- Usando :
Collection, Reference e Load
- Propriedade IsLoaded() - verifica entidades carregadas
- Usando consultas LINQ via método Query()
- Exemplo no VS 2017
4a.
Entidades Relacionadas - Lazy Loading
- 9:07 minutos
-
Carregamento sob demanda das entidades relacionadas
- Recurso Lazy Loading suportado no EF Core 2.1
-
Habilitando o Lazy Loading
- Instalar o pacote Microsoft.EntityFrameworkCore.Proxies
- Chamar o método UseLazyLoadingProxies em OnConfiguring()
- Definindo as propriedades de navegação virtual
- Exemplo no VS 2017
5a.
Entidades Relacionadas - Salvando
- 9:53 minutos
- Salvando
entidades relacionadas
- Adicionando um gráfico de novas entidades
- Adicionar uma entidade relacionada
- Alterar propriedade de relacionamento
- Exemplo
no VS 2017
6a.
Entidades Relacionadas - Deletando
- 10:22 minutos
- Deletando
entidades relacionadas
- Relacionamento obrigatório ou totalmente definido - Delete ou SetNull
- Relacionamento Opcional - NoAction
- Usando as convenções : definir explicitamente prop. de navegação
- Usando a Fluent API - método IsRequired
- Usando a Fluent API - método OnDelete(DeleteBehavior.valor)
- Exemplo
no VS 2017
Atividades
- Atividade1
- Resolução da Atividade
Módulo 12 - Cenário Desconectado
1a.
Cenário Desconectado - Conceitos - 5:09 minutos
- O cenário desconectado e como o EF Core atua
neste cenário
- Como realizar as operações CRUD no cenário desconectado
- Cenário desconectado - DbSet não conhece entidades desconectadas
- EntityState de uma entidade desconectada: Detached
- Anexando as entidades desconectadas ao contexto
- Definindo o EntityState apropriado
- Invocar o método SaveChanges()
2a.
Cenário Desconectado - Incluir entidade -
16:20 minutos
-
Inserindo entidades em um cenário desconectado
- Anexar entidade ao DbContext com EntityState Added
- Usar métodos : Add, AddRange, Attache, Entry
- Invocar o método SaveChanges()
- Exemplo
no VS 2017
3a.
Cenário Desconectado - alterar entidade
- 10:48 minutos
- Alterando
entidades em um cenário desconectado
- Anexar entidade ao DbContext com EntityState Modified
- Usar métodos Update e/ou UpdateRange
- Invocar o método SaveChanges()
- Exemplo
no VS 2017
4a.
Cenário Desconectado - excluir entidade
- 7:54 minutos
- Excluindo
entidades em um cenário desconectado
- Anexar entidade ao DbContext com EntityState Deleted
- Usar métodos Remove e/ou RemoveRange, Attach ou Entry
- Invocar o método SaveChanges()
- Exemplo
no VS 2017
5a.
Cenário Desconectado - TrackGraph
- 10:08 minutos
- Como
rastrear um gráfico de entidades e definindo o EntityState
- Um gráfico de entidades - coleção de entidades
- Método TrackGraph do ChangeTracker : rootEntity e delegate Callback
- Permite rastrear gráfico de entidades e definir seus estados
- Propriedade IsKeySet
- Exemplo
no VS 2017
Atividades
- Atividade1
- Resolução da Atividade
Módulo 13 - Concorrência e Transações
1a.
Concorrência - Conceitos - 10:03 minutos
- Gerenciando os conflitos de concorência-
Conceitos
- Apresentando os controles de concorrência
- Last in wins, concorrência pessimista e concorrência otimista
- Suporte a concorrência otimista
- Detectando conflitos de concorrência
- Configurar propriedades das entidades como tokens de concorrência
- Adicionar propriedade 'rowversion' para atuar como token
- Data Annotations : atributo [ConcurrencyCheck] ou [TimeStamp]
- Fluent API - método IsConcurrencyToken() ou IsRowVersion()
- Tratando a exceção : DbUpdateConcurrencyException()
2a.
Concorrência -
ConcurrencyCheck -
12:37 minutos
-
Tratando conflitos usando entidades com tokens de concorrência
- Fluent API - método IsConcurrencyToken()
-
Data Annotations : atributo [ConcurrencyCheck]
- Tratando a exceção : DbUpdateConcurrencyException()
- Exemplo no VS 2017
3a.
Concorrência -
IsRowVersion
- 11:25 minutos
- Tratando conflitos
usando entidades com tokens de concorrência
- Fluent API - método
IsRowVersion()
-
Data Annotations : atributo
[TimeStamp]
- Tratando a exceção : DbUpdateConcurrencyException()
- Exemplo no VS 2017
4a.
Transações - Conceitos
- 7:06 minutos
- Por
padrão SaveChanges() é transacional
- Controlando transações via código
- Usando DbContext.Database.BeginTransaction
- ou
DbContext.Database.UseTransaction
- Commit() e RollBack()
-
Tratando a exceção : DbUpdateConcurrencyException()
- Novos recursos :System.Transactions
- Exemplo
no VS 2017
5a.
Transações - BeginTransaction
- 8:43 minutos
-
Controlando transações usando o método BeginTransaction()
- Inicia e completa uma transação para uma conexão no contexto
- Permite usar várias chamadas de SaveChanges()
- Commit() - Confirma e executa todas as operações pendentes
- RollBack() - desfaz todas as operações pendentes
- Exemplo
no VS 2017
5a.
Transações - UseTransaction
- 8:59 minutos
- Controlando transações usando o método UseTransaction()
- Compartilhando uma transação com mais de um contexto
- Exemplo
no VS 2017
Atividades
- Atividade1
- Resolução da Atividade
Módulo 14 - Novos Recursos do EF Core
1a.
Apresentando o projeto - 4:56 minutos
- Apresentando o projeto usado no módulo 14
- Projeto no VS 2017
2a.
Consultas Globais -
8:05 minutos
- Filtros
de consultas Globais - HasQueryFilter()
- Criar filtros globais por tipo e exclusão reversível
- Usando Fluent API - HasQueryFilter(expressão)
- Desabilitando o filtro com IgnorQueryFilters()
- Exemplo
no VS 2017
3a.
Mapeamento Flexível
- 7:54 minutos
-
Mapeamento usando campos ao invés de propriedades
-
Usar o
backing Field ou campo de apoio para o mapeamento
- Usando o método HasField() para aceitar o campo de apoio
- Exemplo
no VS 2017
4a. Mapeamento de Função Escalar
- 9:46 minutos
- Permite
mapear funções escalares do BD para método
- Criar função escalar no BD
- Declarar método estático na classe de contexto
- Usar
atributo [DbFunction]
- Exemplo no VS 2017
5a. Interpolação de
strings
- 7:07 minutos
- Suporte a
strings interpoladas nas APIs
- FromSql() e ExecuteSqlCommand()
- Permite usar o recurso de forma segura
- O EF Core emite a string SQL parametrizada
- Evitando a injeção SQL
- Exemplo
no VS 2017
6a. Table Splitting -
I
- 8:23 minutos
- Permite usar uma única tabela para mais de uma entidade
- Permite mapear duas ou mais entidades para mesma tabela
- Definir modelo de entidades
- Definir relacionamento um-para-um usando Fluent API
- Mapear entidades para a mesma tabela
- Exemplo
no VS 2017
7a. Table Splitting -
II
- 6:45 minutos
- Realizando as operações CRUD
- Vantagens em usar o recurso
- Exemplo
no VS 2017
8a. Consultas
Compiladas
- 7:24 minutos
- Permite melhorar o desempenho de consultas
- EF.CompileQuery()
- EF.CompileAsyncQuery()
- Exemplo
no VS 2017
Módulo 15 - Usando EF Core na Prática
1a.
Acessando o MySQL - 15:56 minutos
- Criando uma aplicação Console para acessar o
MySQL
-
Usando o MySqlWorkBench e o EF Core
- Usando a ferramenta de linha de comando NET CLI
- Usando o Visual Studio Code
- Instalando o pacote Pomelo.EntityFrameworkCore.MySql
- Criando o modelo de entidades e a classe de contexto
- Aplicando o Migrations e gerando o BD e a tabela
- Acessando os dados no MySQL
2a.
Criando uma aplicação ASP .NET Core MVC -
14:12 minutos
- Criando
uma aplicação ASP .NET Core MVC
- Acessando o SQL Server com EF Core
- Usando a abordagem Code-First
- Definindo o modelo de entidades e a classe de contexto
- Aplicando o Migrations
- Gerando os controladores via Scaffolding com EF Core
- Usando o Visual Studio 2017
3a. Acessar o
PostgreSql com Windows Forms
I - 9:28 minutos
- Criando
uma aplicação Windows Forms
- Acessando o PostgreSQL com EF Core
- Usando o PgAdmin 4
- Instalando o pacote
Npgsql.EntityFrameworkCore.PostgreSQL
- Criando o modelo de entidades e a classe de contexto
- Aplicando o Migrations
- Exemplo no VS 2017
3a.
Acessar o PostgreSql com
Windows Forms
II - 8:13 minutos
-
Continuando o projeto para acessar o PostgreSQL
- Definindo os formulários Windows Forms
- Definindo os métodos para realizar as operações CRUD
- Exemplo
no VS 2017
5a. Criando uma ASP .NET Core Web API
-
12:59 minutos
-
Criando uma
aplicação ASP .NET Core Web API
- Web API - Conceitos
- Acessando o SQL Server
usando o VS 2017
- Usando a abordagem DbFirst
- Definindo o modelo de entidades e o mapeamento
- Gerando a Web API via Scaffolding usando o EF Core
- Exemplo no VS 2017
|
