Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.Design
Microsoft.EntityFrameworkCore.Relational
Microsoft.EntityFrameworkCore.SqlServer
Microsoft.EntityFrameworkCore.Tools (optional; this enables using Package Manager Console for EF migrations)

 Avoid mixed evaluation, using throw an exception when mixed-mode evaluation occurs.
	.ConfigureWarnings(warnings=>warnings.Throw(RelationalEventId.QueryClientEvaluationWarning));

  internal AutoLotContext()
 {
 }

To use this constructor and leverage the OnConfiguring() event handler, you need to expose the internal items in AutoLotDAL_Core2 to the AutoLotDAL_Core2.TestDriver project. Put the following statement in the AssemblyInfor.cs of AutoLotDAL_Core2 project:
	
	using System.Runtime.CompilerServices;
	[assembly: InternalsVisibleTo("AutoLotDAL_Core2.TestDriver")]

 public class AutoLotContextFactory : IDesignTimeDbContextFactory<AutoLotContext>
{
}

EF Core has completely removed the hash from the process. All that is stored in the database is the name of the migration and the EF version number. The database definition is stored in a C# file named <contextname>ModelSnapshot.cs. Then developers can use a standard diff tool to work out any conflicting changes.

	<ItemGroup>
		<DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.0" />
	</ItemGroup>
	
To add the migration to create your database, make sure to save all of the files, build the project (for safe measure), and then execute the following:
	
	dotnet ef migrations add Initial --context AutoLotDAL_Core2.EF.AutoLotContext -o EF\Migrations
	dotnet ef migrations add Staging --context AutoLotDAL_Core2.EF.AutoLotContext -o EF\Migrations
	dotnet ef migrations add Product --context AutoLotDAL_Core2.EF.AutoLotContext -o EF\Migrations

This creates the timestamped files (similar to EF 6 migrations) that are used to update the database and creates the AutoLotContextModelSnapshot.cs file, which stores the complete database model.
To apply this migration, simply execute the following command:

	dotnet ef database update

public static class MyDataInitializer
{
	public static void InitializeData(AutoLotContext context)
	{
		......
	}
}

The following two statements are quivalent if the value of tableName is CreditRisk:

	context.Database.ExecuteSqlCommand($"SET IDENTITY_INSERT dbo.{tableName} ON;");
	context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT dbo.CreditRisk ON;");

In EF Core 2, the first query gets translated into a parameterized query, like this:

	SET IDENTITY_INSERT dbo.@p0 ON

EnsureDeleted 	Deletes the database if it exists; does nothing if it doesn’t.
EnsureCreated 	Creates the database based on the <context>ModelSnapshot code if it doesn’t exist; does nothing if it exists. 
				This is mutually exclusive of Migrate().
Migrate 		Creates the database and executes all migrations if it doesn’t exist; applies any missing migrations if it exists. 
				This is mutually exclusive with EnsureCreated().

In this version, the Add()/AddRange() and Update()/UpdateRange() methods have been converted to just Add() and Update(), respectively, with overloads.
There is a new method, GetSome(), that takes an expression for the where clause, and there is an overload of GetAll() that takes an expression for the sort expression.

public class BaseRepo<T> : IDisposable,IRepo<T> where T:EntityBase, new()
{
	private readonly DbSet<T> _table;
	private readonly AutoLotContext _db;
	protected AutoLotContext Context => _db;
	
	public BaseRepo() : this(new AutoLotContext())
	{
	}
	public BaseRepo(AutoLotContext context)
	{
		_db = context;
		_table = _db.Set<T>();
	}
	
	public void Dispose()
	{
		_db?.Dispose(); //if not null then dispose it.
	}

	public int Update(T entity)
	{
		_table.Update(entity);
		return SaveChanges();
	}
	
	public int Update(IList<T> entities)
	{
		_table.UpdateRange(entities);
		return SaveChanges();
	}
	
	public int Delete(int id, byte[] timeStamp)
	{
		_db.Entry(new T() {Id = id, Timestamp = timeStamp}).State = EntityState.Deleted;
		return SaveChanges();
	}
	
	public int Delete(T entity)
	{
		_db.Entry(entity).State = EntityState.Deleted;
		return SaveChanges();
	}
	
	public T GetOne(int? id) => _table.Find(id);
	public virtual List<T> GetAll() => _table.ToList();
}

One of the great features of FromSql() is that you can add LINQ queries on top of the call. For example, if you wanted to return all Inventory records and the related Order and Customer records, you could write the following:

return Context.Cars.FromSql("SELECT * FROM Inventory").Include(x => x.Orders).ThenInclude(x => x.Customer).ToList();

The exception handlers for the SaveChanges() method on the DbContext are simply stubbed out. In a production application, you would need to handle any exceptions accordingly

internal int SaveChanges()
{
	try
	{
		return _db.SaveChanges();
	}
	catch (DbUpdateConcurrencyException ex)
	{
		//Thrown when there is a concurrency error
		//for now, just rethrow the exception
		throw;
	}
	catch (RetryLimitExceededException ex)
	{
		//Thrown when max retries have been hit
		//Examine the inner exception(s) for additional details
		//for now, just rethrow the exception
		throw;
	}
	catch (DbUpdateException ex)
	{
		//Thrown when database update fails
		//Examine the inner exception(s) for additional
		//details and affected objects
		//for now, just rethrow the exception
		throw;
	}
	catch (Exception ex)
	{
		//some other exception happened and should be handled
		throw;
	}
}

This handles specific work on the Inventory table that isn’t covered by the base repo. You will also need to create an IInventoryRepo interface to set you up for ASP.NET Core dependency injection.

Add a constructor that takes an AutoLotContext as the parameter and chain it to the base constructor. This will be used by the DI framework in ASP.NET Core to create the repository using one of the pooled AutoLotContext instances.

public class InventoryRepo : BaseRepo<Inventory>, IInventoryRepo
{
	public InventoryRepo(AutoLotContext context) : base(context)
	{
	}
}

public List<Inventory> Search(string searchString)=> Context.Cars.Where(c => Functions.Like(c.PetName, $"%{searchString}%")).ToList();

this exactly like the SQL statement as follow:

	SELECT * FROM Inventory WHERE PetName like '%searchString%'