/// <summary>Pre save changes.</summary>
/// <param name="audit">The audit to use to add changes made to the context.</param>
/// <param name="context">The context used to audits and saves all changes made.</param>
public static void PreSaveChanges(Audit audit, DbContext context)
{
#if EF5 || EF6
var objectContext = context.GetObjectContext();
objectContext.DetectChanges();
var changes = objectContext.ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Modified | EntityState.Deleted);
foreach (var objectStateEntry in changes)
{
if (objectStateEntry.IsRelationship)
{
if (objectStateEntry.State == EntityState.Added && audit.Configuration.IncludeRelationAdded)
{
AuditRelationAdded(audit, objectStateEntry);
}
else if (objectStateEntry.State == EntityState.Deleted && audit.Configuration.IncludeRelationDeleted)
{
AuditRelationDeleted(audit, objectStateEntry);
}
}
else
{
if (objectStateEntry.State == EntityState.Added && audit.Configuration.IncludeEntityAdded)
{
AuditEntityAdded(audit, objectStateEntry);
}
else if (objectStateEntry.State == EntityState.Deleted && audit.Configuration.IncludeEntityDeleted)
{
AuditEntityDeleted(audit, objectStateEntry);
}
else if (objectStateEntry.State == EntityState.Modified && audit.Configuration.IncludeEntityModified)
{
AuditEntityModified(audit, objectStateEntry);
}
}
}
#elif EF7
context.ChangeTracker.DetectChanges();
var manager = context.ChangeTracker.GetStateManager();
var entries = manager.Entries;
foreach (var entry in entries)
{
if (entry.EntityState == EntityState.Added)
{
}
else if (entry.EntityState == EntityState.Deleted)
{
}
else if (entry.EntityState == EntityState.Modified)
{
}
}
#endif
}
internal static object LoadStub(Type t, string primaryKeyName, object id, DbContext db)
{
var cachedEnt =
db.ChangeTracker.Entries().Where(x => ObjectContext.GetObjectType(x.Entity.GetType()) == t).SingleOrDefault(x =>
{
Type entType = x.Entity.GetType();
object value = entType.InvokeMember(primaryKeyName, System.Reflection.BindingFlags.GetProperty, null, x.Entity, new object[] { });
return value.Equals(id);
});
if (cachedEnt != null)
{
return cachedEnt.Entity;
}
else
{
object stub = Activator.CreateInstance(t);
t.InvokeMember(primaryKeyName, System.Reflection.BindingFlags.SetProperty, null, stub, new object[] { id });
db.Entry(stub).State = EntityState.Unchanged;
return stub;
}
}
public TransactionsHandler(DbContext dbContext, ICardAccountRepository cardAcountRepo, IGenericRepository<TransactionHistory> transactionLogRepo)
{
this.dbContext = dbContext;
this.cardAcountRepo = cardAcountRepo;
this.transactionLogRepo = transactionLogRepo;
this.errors = new List<string>();
}
public MigrationResult Migrate(DbContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (!context.IsAzureDatabase())
{
return new MigrationResult
{
MigrationWasApplied = true,
Log = "Database is not an Azure SQL database so no action taken."
};
}
var sql =
$@"
alter database {context.Database.Connection.Database}
modify (MAXSIZE = {MaxSize},
EDITION = '{Edition}',
SERVICE_OBJECTIVE = '{ServiceObjective}')";
context.Database.ExecuteSqlCommand(sql);
return new MigrationResult
{
MigrationWasApplied = true,
Log = sql
};
}
/// <summary>
/// 根据数据库类型获取适配器
/// </summary>
/// <param name="dbContext"></param>
/// <returns></returns>
public static DBAdapterBase GetDBAdapterBase(DbContext dbContext)
{
DBAdapterBase db = null;
switch (dbContext.DBHelper.CurrentDBType)
{
case CoreHelper.DBType.MSSQL:
db = new MSSQLDBAdapter(dbContext);
break;
case CoreHelper.DBType.MSSQL2000:
db = new MSSQL2000DBAdapter(dbContext);
break;
case CoreHelper.DBType.ACCESS:
break;
case CoreHelper.DBType.MYSQL:
db = new MySQLDBAdapter(dbContext);
break;
case CoreHelper.DBType.ORACLE:
db = new ORACLEDBAdapter(dbContext);
break;
}
if (db == null)
{
throw new Exception("找不到对应的DBAdapte" + dbContext.DBHelper.CurrentDBType);
}
return db;
}
/// <summary>
/// sample invocation code
/// int codPers = 21024;
/// string tipPers = "fiz";
/// SqlCommand sqlCommand = new SqlCommand("dbo.GetSolduri");
/// sqlCommand.CommandType = CommandType.StoredProcedure;
/// sqlCommand.Parameters.AddWithValue("@codPers", codPers);
/// sqlCommand.Parameters.AddWithValue("@tipPers", tipPers);
/// return HelperController.SqlCommandToDynamicEntity(repository.Context, sqlCommand);
/// </summary>
/// <param name="context"></param>
/// <param name="sqlCommand"></param>
/// <returns></returns>
public static List<object> SqlCommandToDynamicEntity(DbContext context, SqlCommand sqlCommand)
{
string dynamicEntity = "DynamicEntity";
bool isFirstRow = true;
AssemblyName assemblyName = new AssemblyName("MyAssembly");
AssemblyBuilder assemblyBuilder = System.Threading.Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name);
TypeBuilder typeBuilder = moduleBuilder.DefineType(dynamicEntity, TypeAttributes.Public | TypeAttributes.AutoClass | TypeAttributes.AnsiClass |
TypeAttributes.BeforeFieldInit, typeof(System.Object));
List<object> entities = new List<object>();
// Get the type contained in the name string
Type type = typeBuilder.AsType();
DataTable dt = new DataTable();
///sample invocation code
//int codPers = 21024;
//string tipPers = "fiz";
//sqlCommand = new SqlCommand("dbo.GetSolduri");
//sqlCommand.CommandType = CommandType.StoredProcedure;
//sqlCommand.Parameters.AddWithValue("@codPers", codPers);
//sqlCommand.Parameters.AddWithValue("@tipPers", tipPers);
using (SqlConnection con = new SqlConnection(context.Database.Connection.ConnectionString))
{
using (sqlCommand)
{
sqlCommand.Connection = con;
con.Open();
SqlDataAdapter da = new SqlDataAdapter(sqlCommand);
da.Fill(dt);
foreach (DataRow dr in dt.Rows)
{
if (isFirstRow)
{
isFirstRow = false;
foreach (DataColumn col in dt.Columns)
{
typeBuilder.DefineField(col.ColumnName, (dr[col]).GetType(), FieldAttributes.Public);
}
type = typeBuilder.CreateType();
var prop = type.GetFields().First().Name;
}
// create an instance of that type
object entity = Activator.CreateInstance(type);
foreach (DataColumn col in dt.Columns)
{
if (dr[col] == null || dr[col] == System.DBNull.Value) continue;
FieldInfo prop = type.GetField(col.ColumnName);
// Set the value of the given property on the given instance
prop.SetValue(entity, dr[col]);
}
entities.Add(entity);
}
return entities;
}
}
}
public void SetUp()
{
DbContextBuilder<DbContext> builder = new DbContextBuilder<DbContext>("DefaultDb", new[] { "QV.Tests" }, true, true);
context = builder.BuildDbContext();
customerRepository = new QV.Tests.Data.Lab.CustomerRepository(context);
repository = new QV.Data.EntityFramework.Lab.GenericRepository(context);
}
public void TearDown()
{
if ((context != null) && (((IObjectContextAdapter)context).ObjectContext.Connection.State == System.Data.ConnectionState.Open))
{
((IObjectContextAdapter)context).ObjectContext.Connection.Close();
context = null;
}
}
public void SetUp()
{
var builder = new DbContextBuilder<DbContext>("DefaultDb", new[] { "Infrastructure.Tests" }, true, true);
this.context = builder.BuildDbContext();
this.customerRepository = new CustomerRepository(this.context);
this.repository = new GenericRepository(this.context);
}
public OperationRepository(DbContext context)
{
if (context == null)
{
throw new ArgumentNullException("context", "DbContext should not be empty");
}
Context = context;
}
internal static void AssignStubx(object poco, DbContext db)
{
IEnumerable<PropertyMapping> piNeedStub = Mapper.StubsNeeded(poco.GetType());
foreach (PropertyMapping pm in piNeedStub)
{
// pm.PropertyPoco.First(). e.g. Customer of Customer.CustomerId. Customer is PropertyPoco[0], CustomerId is PropertyPoco[1]
PropertyInfo pocoForeign = poco.GetType().GetProperty(pm.PropertyPoco[0], BindingFlags.Public | BindingFlags.Instance);
if (pocoForeign == null) continue;
object val = pocoForeign.GetValue(poco, null);
if (val != null)
{
PropertyInfo pocoForeignId = pocoForeign.PropertyType.GetProperty(pm.PropertyPoco.Last(), BindingFlags.Public | BindingFlags.Instance);
object id = pocoForeignId.GetValue(val, null);
pocoForeign.SetValue(poco, LoadStub(pocoForeign.PropertyType, pm.PropertyPoco.Last(), id, db), null);
}
else
{
// foreign key is null'd
// nullable foreign key association
// http://www.codetuning.net/blog/post/Understanding-Entity-Framework-Associations.aspx
var dummy = pocoForeign.GetValue(poco, null); // work-around
pocoForeign.SetValue(poco, val, null);
}
}
IEnumerable<PropertyInfo> piCollection =
poco.GetType().GetProperties()
.Where(x => x.PropertyType.IsGenericType && typeof(IEnumerable).IsAssignableFrom(x.PropertyType));
foreach (PropertyInfo item in piCollection)
{
PropertyInfo px = poco.GetType().GetProperty(item.Name, BindingFlags.Public | BindingFlags.Instance);
// same property exists from dto to poco
if (px != null)
{
IList col = (IList)px.GetValue(poco, null);
if (col == null) continue;
Type dtoType = item.PropertyType.GetInterfaces().Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(ICollection<>)).Single().GetGenericArguments()[0];
foreach (object elem in col)
{
db.AssignStub(elem);
}
}
}
}
public void TearDown()
{
if ((this.context != null)
&& (((IObjectContextAdapter)this.context).ObjectContext.Connection.State == ConnectionState.Open))
{
((IObjectContextAdapter)this.context).ObjectContext.Connection.Close();
this.context = null;
}
}
public EventRepository(DbContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
_db = context as DevAgendaCtx;
}
public void TestGetTheRightCopier3()
{
DbContext dc = new DbContext("SqlServer");
dc.NewTransaction(delegate()
{
IDbBulkCopy c = dc.GetDbBulkCopy();
Assert.IsNotNull(c);
Assert.IsTrue(c is SqlServerBulkCopy);
});
}
//Ctor
public SEORepository(DbContext _DbContext, string _TableName = "")
{
this.TableName = _TableName;
if (_DbContext == null)
throw new ArgumentNullException("DbContext");
DbContext = _DbContext;
DbSet = _DbContext.Set<SEO>();
}
public BulkOperationProvider(DbContext context)
{
if (context == null)
throw new ArgumentNullException("context");
_context = context;
//ConnectionStringSettings cs = ConfigurationManager.ConnectionStrings[context.GetType().Name];
_connectionString = context.Database.Connection.ConnectionString;
}
public EF6UnitOfWorkTests()
{
DbConnection connection = Effort.DbConnectionFactory.CreateTransient();
_context = new FooContext(connection);
_unitOfWork = new Ef6UnitOfWork(_context, IsolationLevel.Unspecified);
var repository = new BaseRepository<Foo>(_unitOfWork);
_repositoryWriter = repository;
_repositoryReader = repository;
}
/// <summary>
/// Create News Media Content
/// </summary>
/// <param name="newsMedia">newsMedia</param>
/// <returns>Returns the news media content</returns>
public NewsMedia Create(NewsMedia newsMedia)
{
using(var database = new DbContext(CONNECTION_NAME))
{
database.Set<NewsMedia>().Add(newsMedia);
database.SaveChanges();
return newsMedia;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AuditLogger"/> class.
/// </summary>
/// <param name="dbContext">The <see cref="DbContext"/> to create the <see cref="AuditLog"/> from.</param>
/// <param name="configuration">The <see cref="AuditConfiguration"/> to use when creating the <see cref="AuditLog"/>.</param>
public AuditLogger(DbContext dbContext, AuditConfiguration configuration)
{
if (dbContext == null)
throw new ArgumentNullException("dbContext");
var adapter = (IObjectContextAdapter)dbContext;
_objectContext = adapter.ObjectContext;
_configuration = configuration ?? AuditConfiguration.Default;
AttachEvents();
}
public BaseRepositoryTests()
{
DbConnection connection = DbConnectionFactory.CreateTransient();
_context = new FooContext(connection);
var repository = new BaseRepository<Foo>(new Ef6UnitOfWork(_context, IsolationLevel.Unspecified));
_repositoryWriter = repository;
_repositoryReader = repository;
_repositoryWriterAsync = repository;
_repositoryReaderAsync = repository;
}
public static DbParameter[] GetCachedParameters(DbContext dbContext)
{
if (((dbContext == null) || (dbContext.Connection == null)) || (dbContext.CurrentCommand == null))
{
throw new ArgumentNullException("dbContext");
}
if ((dbContext.CurrentCommand.CommandType != CommandType.StoredProcedure) || string.IsNullOrEmpty(dbContext.CurrentCommand.CommandText))
{
throw new InvalidOperationException("命令不是存储过程，或没有设置存储过程。");
}
return InnerGetCachedParameters(dbContext.Connection, dbContext.CurrentCommand.CommandText);
}
/// <summary>
/// Gets the list of News Media
/// </summary>
/// <param name="date">created date.</param>
/// <returns>Returns the list of List<NewsMedia>.</returns>
public List<NewsMedia> Select(DateTime date)
{
using (var database = new DbContext(CONNECTION_NAME))
{
IQueryable<NewsMedia> query = database.Set<NewsMedia>();
query = AppendFilters(query,date);
return query.ToList();
}
}
public virtual void OnBeforeSaveChanges(DbContext context)
{
foreach (var entry in context.GetDbStateEntries())
{
var type = entry.Entity.GetType();
foreach (var complexProperty in GetComplexProperties(type))
{
// instantiate complex type if null
object currentValue = complexProperty.Key.GetValue(entry.Entity, new object[0]);
object newValue = currentValue == null ? complexProperty.Value() : null;
OnInitializeComplexType(complexProperty.Key, entry, currentValue, newValue);
}
}
}
public void Dispose()
{
if (Context != null)
{
//if (Transaction != null)
//{
// Transaction.Dispose();
//}
//Transaction = null;
Context.Dispose();
Context = null;
}
}
/// <summary>
/// Submits the change through Entity Framework while logging any exceptions
/// and produce appropriate <see cref="HttpResponseMessage"/> instances.
/// </summary>
/// <returns>A <see cref="Task"/> representing the operation.</returns>
public static async Task<int> SubmitChangesAsync(DbContext context, HttpRequestMessage request, Func<DbUpdateConcurrencyException, object> getOriginalValue)
{
HttpConfiguration config = request.GetConfiguration();
ITraceWriter traceWriter = config.Services.GetTraceWriter();
try
{
int result = await context.SaveChangesAsync();
return result;
}
catch (DbEntityValidationException ex)
{
string validationDescription = EntityUtils.GetValidationDescription(ex);
string validationError = EFResources.DomainManager_ValidationError.FormatForUser(validationDescription);
traceWriter.Debug(validationError, request, LogCategories.TableControllers);
HttpResponseMessage invalid = request.CreateErrorResponse(HttpStatusCode.BadRequest, validationError, ex);
throw new HttpResponseException(invalid);
}
catch (DbUpdateConcurrencyException ex)
{
string conflictError = EFResources.DomainManager_ChangeConflict.FormatForUser(ex.Message);
traceWriter.Info(conflictError, request, LogCategories.TableControllers);
var content = getOriginalValue != null ? getOriginalValue(ex) : conflictError;
HttpStatusCode statusCode = GetConflictStatusCode(request);
HttpResponseMessage conflict = request.CreateResponse(statusCode, content);
throw new HttpResponseException(conflict);
}
catch (DbUpdateException ex)
{
HttpResponseMessage error;
Exception baseEx = ex.GetBaseException();
SqlException sqlException = baseEx as SqlException;
if (sqlException != null && sqlException.Number == SqlUniqueConstraintViolationError)
{
string message = CommonResources.DomainManager_Conflict.FormatForUser(sqlException.Message);
error = request.CreateErrorResponse(HttpStatusCode.Conflict, message);
traceWriter.Info(message, request, LogCategories.TableControllers);
}
else
{
string message = EFResources.DomainManager_InvalidOperation.FormatForUser(baseEx.Message);
error = request.CreateErrorResponse(HttpStatusCode.BadRequest, message);
traceWriter.Error(message, request, LogCategories.TableControllers);
}
throw new HttpResponseException(error);
}
}
/// <summary>
/// 通过EF执行sql语句获得Table
/// </summary>
/// <param name="db">数据库上下文</param>
/// <param name="sql">sql语句</param>
/// <returns></returns>
public static DataTable SqlQueryForDataTatable(DbContext db,
string sql)
{
SqlConnection conn = new System.Data.SqlClient.SqlConnection();
conn.ConnectionString = db.Database.Connection.ConnectionString;
if (conn.State != ConnectionState.Open) {
conn.Open();
}
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = sql;
SqlDataAdapter adapter = new SqlDataAdapter(cmd);
DataTable table = new DataTable();
adapter.Fill(table);
return table;
}
/// <summary>
/// 根据数据库的不同调用不同的子类进行分页等操作
/// </summary>
/// <param name="dbContext"></param>
/// <returns></returns>
public static GridDataBuliderProvider Create(DbContext dbContext)
{
var dbprovider = dbContext.Db.DbProvider;
if (dbprovider is Liger.Data.MsAccess.MsAccessProvider)
{
return new AccessGridDataBuliderProvider(dbContext);
}
if (dbprovider is Liger.Data.SqlServer9.SqlServer9Provider)
{
return new SqlServer9GridDataBuliderProvider(dbContext);
}
if (dbprovider is Liger.Data.SqlServer.SqlServerProvider)
{
return new SqlServerGridDataBuliderProvider(dbContext);
}
return new GridDataBuliderProvider(dbContext);
}
/// <summary>
/// Update News Media Content
/// </summary>
/// <param name="newsMedia">newsMedia</param>
/// <returns>Returns the news media content</returns>
public NewsMedia Update(NewsMedia newsMedia)
{
using (var database = new DbContext(CONNECTION_NAME))
{
var entryMedia = database.Entry<NewsMedia>(newsMedia);
entryMedia.State = EntityState.Unchanged;
entryMedia.Property("Status").IsModified = true;
entryMedia.Property("Remarks").IsModified = true;
entryMedia.Property("IsCompleted").IsModified = true;
database.SaveChanges();
}
}
private void button1_Click_1(object sender, EventArgs e)
{
CodeTimer.Initialize();
CodeTimer.Time("1", 10, new Action(
() =>
{
using (DbContext dbContext = new DbContext("oracle"))
{
List<TbasicPrice> list = FastDBEngine.DbHelper.FillList<TbasicPrice>(
"select * from TBASIC_PRICE t", null, dbContext, FastDBEngine.CommandKind.SqlTextNoParams);
//List<TbasicPrice> list2 = DbHelper.FillList<TbasicPrice>(
// "select * from TBASIC_PRICE where PKID = :Id",
// new { Id = 10000068 },
// dbContext,
// CommandKind.SqlTextWithParams);
//var query = "select * from TBASIC_PRICE where PKID =".AsCPQuery(true);
//query += 10000068;
//List<TbasicPrice> list7 = DbHelper.FillList<TbasicPrice>(query);
};
}));
}
public MigrationResult Migrate(DbContext context)
{
var originalTimeout = context.Database.CommandTimeout;
try
{
context.Database.CommandTimeout = 600;
context.Database.ExecuteSqlCommand(
TransactionalBehavior.EnsureTransaction,
SqlText);
}
finally
{
context.Database.CommandTimeout = originalTimeout;
}
return new MigrationResult
{
MigrationWasApplied = true,
Log = SqlText
};
}
