Entity Framework Core & Micro-Orms with Asp.Net Core

ASPNET CORE DATA ACCESS
ENTITY FRAMEWORK CORE & MICRO ORMS

ETAT DES LIEUX : EF CORE 1.0
 Nouvelles plateformes
 .NET CORE (ASP.NET Core, UWP)
 .NET Framework (ASP.NET, WPF, Windows Forms)
 XAMARIN
 Windows Phone
 Windows Store
 MAC
 Linux

ETAT DES LIEUX : EF CORE 1.0
 Nouvelles sources de données
 Relationnelles (SQL Server, SQL Lite, SQL Compact, Postgres, MySQL, Oracle)
 Non relationnelles (Redis, Azure Table Storage)
 InMemory (à utiliser pour les test)
 Providers disponibles uniquement pour les SGBD relationnels pour la v 1.0
 Possibilité de créer son propre provider

ENTITY FRAMEWORK CORE 1.0
 On repart de Zero mais on garde le meilleur
 Code First
 Code First from Database
 Approche totalement modulaire
 IOC friendly
 Totalement Open source comme tout ce qui finit par Core… donc code source disponible sur
GitHub et possiblité de contribuer son l’évolution.
 EF Core n’est pas production ready

 Fonctionnalités legacy
 Change tracking
 Migrations
 DbContext API
 Linq to Entities
 SaveChanges
 Fonctionnalités supprimées
 EDMX
 Entity SQL
 Complex Mapping
 Migrations automatiques

 Nouvelles fonctionnalités
 Dependency injection
 Lancer des Batch avec CUD
 Créer des clé étrangères
 SQL généré plus propre et plus light
 Amélioration des graphes d’objets déconnectés
 Fonctionnalités à venir
 Mapping des procédures stockées
 Lazy loading

ENTITY FRAMEWORK CORE 1.0.1
DEMARRAGE

 Package à installer
"Microsoft.EntityFrameworkCore.SqlServer": "1.0.1 "
 Création d’un DbContext
public class CookBookContext : DbContext
{
public CookBookContext(DbContextOptions<CookBookContext> options) : base(options) { }
public DbSet<Book> Book { get; set; }
public DbSet<Recipe> Recipe { get; set; }
}

 Config dans appsettings.json
{
"ConnectionStrings": {
"DbConnection": "Data Source=mcnltp173;Initial Catalog=CookBook;Integrated Security=True"
}
}
 Config dans Startup.cs
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<CookBookContext>(
options => options.UseSqlServer(Configuration.GetConnectionString("DbConnection")));
}

 Utilisation
public class HomeController : Controller
{
private readonly CookBookContext _context;
public HomeController(CookBookContext context)
{
_context = context;
}
public IActionResult Index()
{
var books = _context.Book.ToList();
return View(books);
}
}

ENTITY FRAMEWORK CORE 1.0.1
REVERSE ENGINEERING

 Command
dotnet ef dbcontext scaffold -c DbContextName -o ModelsFolder "MyConnectionString"
Microsoft.EntityFrameworkCore.SqlServer –force
 Config dans project.json
"dependencies": {
"Microsoft.EntityFrameworkCore.SqlServer": "1.0.1",
"Microsoft.EntityFrameworkCore.SqlServer.Design": "1.0.1",
"Microsoft.EntityFrameworkCore.Design": "1.0.0-preview2-final"
},
"tools": {
"Microsoft.EntityFrameworkCore.Tools": "1.0.0-preview2-final"
}

 Code généré
public partial class CookBookContext : DbContext
{
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlServer(
@"Data Source=mcnltp173;Initial Catalog=CookBook;Integrated Security=True");
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Book>(entity =>
{
entity.Property(e => e.Name)
.IsRequired()
.HasColumnType("varchar(50)");
});
}
public virtual DbSet<Book> Book { get; set; }
public virtual DbSet<Recipe> Recipe { get; set; }
}

MICRO ORMS
DAPPER - PETAPOCO - MASSIVE - SIMPLE.DATA - SERVICESTACK.ORMLITE

MICRO ORMS : DAPPER
POCO
DYNAMIC OBJECTS
MULTIPLE RESULTS
STORED PROCEDURE
TRANSACTION
ASYNC
PROVIDERS: SQLLite, SQL CE, Firebird, Oracle, MySQL, PostgreSQL and SQL Server

MICRO ORMS : DAPPER
CONFIG:
{
services.Add(new ServiceDescriptor(typeof(IConfiguration),
provider => new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json",
optional: false,
reloadOnChange: true)
.Build(),
ServiceLifetime.Singleton));
services.AddScoped<ICookBookRepository, CookBookRepository>();
}
// ou (v2) :
public static IConfigurationRoot Configuration;
{
}

MICRO ORMS : DAPPER
CTOR:
private readonly IConfiguration _config;
public CookBookRepository(IConfiguration config)
{
_config = config;
}
public IDbConnection Connection
{
get
{
return new SqlConnection(_config.GetConnectionString("DbConnection"););
}
}
// ou (v2) :
public IDbConnection Connection
{
get
{
return new SqlConnection(Startup.Configuration["connectionStrings:DbConnection"]);

MICRO ORMS : DAPPER
REPO:
public IEnumerable<Book> GetAll()
{
using (IDbConnection db = Connection)
{
db.Open();
// version requete Sql
return db.Query<Book>("SELECT * FROM Book").ToList<Book>;
//return await db.QueryAsync<Book>("SELECT * FROM Book");
// version ps
//return db.Query<Book>("GetAllBooks", commandType: CommandType.StoredProcedure);
}
}

MICRO ORMS : DAPPER
public Book GetByID(int id)
{
{
db.Open();
string sQuery = "SELECT * FROM Book WHERE Id = @Id";
return db.Query<Book>(sQuery, new { Id = id }).FirstOrDefault();
// version ps
//string sp = "GetBookByID";
//var parameter = new DynamicParameters();
//parameter.Add("@Id", id, dbType: DbType.Int32, direction: ParameterDirection.Input);
//return db.Query<Book>(sp, parameter, commandType: CommandType.StoredProcedure).FirstOrDefault();
}
}

MICRO ORMS : DAPPER
public Book GetMultiple(int id)
{
{
db.Open();
//string query = "SELECT * FROM Book WHERE Id=@id; SELECT * FROM Recipe WHERE IdBook=@id;";
//var multipleResults = db.QueryMultiple(query, new { id = id });
// version sp
var parameter = new DynamicParameters();
parameter.Add("@id", id, dbType: DbType.Int32, direction: ParameterDirection.Input);
var multipleResults = db.QueryMultiple("GetBookRecipes", parameter,
commandType: CommandType.StoredProcedure);
var book = multipleResults.Read<Book>().SingleOrDefault();
var recipes = multipleResults.Read<Recipe>().ToList();
if (book != null && recipes != null)
book.Recipes = new List<Recipe>(); book.Recipes.AddRange(recipes);
return book;
}

MICRO ORMS : DAPPER
public void Add(Book book)
{
{
db.Open();
parameter.Add("@name", book.Name, dbType: DbType.String, direction: ParameterDirection.Input);
//string sQuery = "INSERT INTO Book (Name) VALUES(@Name)";
// version 1 requete Sql
//db.Execute(sQuery, parameter);
//db.Execute(sQuery, book);
// version sp
db.Execute("InsertBook", parameter, commandType: CommandType.StoredProcedure);
}
}

MICRO ORMS : DAPPER
public void Update(Book book)
{
{
db.Open();
var parameters = new DynamicParameters();
parameters.Add("@Id", book.Id, dbType: DbType.Int32, direction: ParameterDirection.Input);
parameters.Add("@Name", book.Name, dbType: DbType.String, direction: ParameterDirection.Input);
string sQuery = "UPDATE Book SET Name = @Name WHERE Id = @Id";
//db.Execute(sQuery, parameters, commandType: CommandType.Text);
//db.Execute(sQuery, book, commandType: CommandType.Text);
// version sp
db.Execute("UpdateBook", parameters, commandType: CommandType.StoredProcedure);
}
}

MICRO ORMS : DAPPER
public void Delete(int id)
{
{
db.Open();
//string sQuery = "DELETE FROM Book WHERE Id = @Id";
//db.Execute(sQuery, new { Id = id });
// version sp
parameter.Add("@Id", id, dbType: DbType.Int32, direction: ParameterDirection.Input);
string sp = "DeleteBook";
db.Execute(sp, parameter, commandType: CommandType.StoredProcedure);
}
}

MICRO ORMS : PETAPOCO
POCO
DYNAMIC OBJECTS MAPPING
MULTIPLE RESULTS
STORED PROCEDURE
TRANSACTION
ASYNC
T4
PROVIDERS: SQL Server, SQL Server CE, MS Access, SQLite, MySQL, MariaDB, PostgreSQL, Firebird DB, and Oracle
APP.CONFIG

CONFIG:
{
}
CTOR:
private readonly Database _db;
public CookBookRepository()
{
var connectionString = ConfigurationManager.ConnectionStrings["DbConnection"].ConnectionString;
_db = new Database(connectionString, new SqlServerDatabaseProvider());
}

REPO:
{
using (IDatabase dbConnection = Connection)
{
return _db.Query<Book>("SELECT * FROM Book");
}
}
{
{
return _db.FirstOrDefault<Book>($"SELECT * FROM Book WHERE Id={id}");
}
}

{
{
_db.Insert(book);
}
}
{
{
_db.Update(book);
}
}
public void Delete(Book book)
{
{
_db.Delete(book);
}
}

MICRO ORMS : MASSIVE
DYNAMIC OBJECTS
MULTIPLE RESULTS
STORED PROCEDURE
TRANSACTION
ASYNC
PROVIDERS: SQL Server, Oracle, SQLite, PostgreSQL
APP.CONFIG

CONFIG:
{
}
public class Book : DynamicModel
{
public Book():base("DbConnection", "Book","Id") { }
public int Id { get; set; }
public string Name { get; set; }
}

REPO:
public async Task<IList<dynamic>> GetAll()
{
return await table.AllAsync();
}
public async Task<dynamic> GetByID(int id)
{
return await table.SingleAsync($"WHERE Id={id}");
}

public async Task Add(dynamic book)
{
await table.InsertAsync(book);
}
public async Task Update(dynamic book)
{
await table.UpdateAsync(book, book.Id);
}
public async Task Delete(int id)
{
await table.DeleteAsync(id);
}

MICRO ORMS : SIMPLE.DATA
POCO
DYNAMIC OBJECTS
MULTIPLE RESULTS
STORED PROCEDURE
TRANSACTION
ASYNC
PROVIDERS: SQL Server, SQL Azure, SQL Server Compact, Oracle, MySQL, SQLite, PostgreSQL, SQLAnywhere, Informix,
MongoDB, OData

CONFIG:
public Startup(IHostingEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
Configuration = builder.Build();
}
public static IConfigurationRoot Configuration;
{
services.AddScoped<ICookBookRepository, CookBookRepository>()
}
CTOR:
private readonly dynamic _db;
{
_db = Database.OpenConnection(Startup.Configuration["connectionStrings:DbConnection"]);
}

REPO:
public async Task<List<Book>> GetAll()
{
return await _db.Book.All().ToList<Book>();
//return await _db["Book"].All().ToList<Book>();
}
public async Task<Book> GetByID(int id)
{
return await _db.Book.Find(_db.Book.Id == id);
//return await _db.Book.Get(id).Cast<Book>();
}

public async Task Add(Book book)
{
await _db.Book.Insert(book);
}
public async Task Update(Book book)
{
await _db.Book.UpdateById(Id: book.Id, Name: book.Name);
}
public async Task Delete(int id)
{
await _db.Book.DeleteById(id);
}

MICRO ORMS : SERVICESTACK.ORMLITE
POCO
DYNAMIC OBJECTS
MULTIPLE RESULTS
STORED PROCEDURE
TRANSACTION
ASYNC
PROVIDERS: SqlServer, PostgreSQL, MySql, Sqlite.Mono, Sqlite.Windows, Oracle, Firebird, VistaDb,
AWS RDS (PostgreSQL, Aurora, MySQL, MariaDB, SQL Server)

CONFIG:
{
}
CTOR:
private readonly IDbConnectionFactory _dbFactory;
{
_dbFactory = new OrmLiteConnectionFactory(
Startup.Configuration["connectionStrings:DbConnection"],
SqlServer2012Dialect.Provider);
}

MICRO ORM : SERVICESTACK.ORMLITE
REPO:
{
using (IDbConnection dbConnection = _dbFactory.OpenDbConnection())
{
return dbConnection.Select<Book>();
//return await dbConnection.SelectAsync<Book>();
}
}
{
{
return dbConnection.Select<Book>(s => s.Id == id).FirstOrDefault();
//return await dbConnection.SelectAsync<Book>(s => s.Id == id).FirstOrDefault();
}
}

{
{
dbConnection.Insert<Book>(book);
// await dbConnection.InsertAsync<Book>(book);
}
}
public void Delete(int id)
{
{
dbConnection.Delete<Book>(s => s.Id == id);
// await dbConnection.DeleteAsync<Book>(s => s.Id == id);
}
}

{
{
// dbConnection.Update<Book>(
// dbConnection.UpdateAdd<Book>(
// dbConnection.UpdateAll<Book>(
// await dbConnection.UpdateOnlyAsync<Book>(
dbConnection.UpdateOnly<Book>(
book,
onlyFields: f => f.Name == book.Name,
where: s => s.Id == book.Id
);
}
}

LINKS
 PETAPOCO
 http://www.toptensoftware.com/petapoco/
 https://github.com/CollaboratingPlatypus/PetaPoco
 MASSIVE OK
 https://github.com/FransBouma/Massive
 ORMLITE OK
 https://github.com/ServiceStack/ServiceStack.OrmLite
 http://gistlyn.com/?collection=991db51e44674ad01d3d318b24cf0934&gist=a62b1e7a8da57c7d1fda95b3da5303eb
 SIMPLEDATA OK
 https://github.com/markrendle/Simple.Data
 DAPPER OK
 https://github.com/StackExchange/dapper-dot-net

Entity Framework Core & Micro-Orms with Asp.Net Core

Recommended

More Related Content

What's hot (19)

Viewers also liked (20)

Similar to Entity Framework Core & Micro-Orms with Asp.Net Core (20)

Recently uploaded (20)

Entity Framework Core & Micro-Orms with Asp.Net Core