/// <summary>
/// 创建或获取一个非泛型类型的 <see cref="EntityAccessor"/> 实体数据模型访问器对象，并指定其可操作的 实体数据模型类型。<br />
/// 该 实体数据模型访问器对象 在未更改 EntityType 属性的情况下仅可用于操作 指定的实体数据模型类型。<br />
/// 因实体数据模型访问器对象由 实体数据上下文 <see cref="DbContext"/> 创建，其 AutoDisposeContext 属性值为 false，表示不销毁其 DbContext 属性。
/// </summary>
/// <param name="_this">实体数据上下文对象。</param>
/// <param name="entityType">指定的实体数据模型类型。</param>
/// <returns>返回一个非泛型类型的 <see cref="EntityAccessor"/> 实体数据模型访问器对象。</returns>
public static EntityAccessor Accessor(this System.Data.Entity.DbContext _this, Type entityType)
{
EntityAccessor accessor = new EntityAccessor(_this, entityType);
accessor.AutoDisposeContext = false;
return(accessor);
}
/// <summary>
/// Initializes a new instance of the <see cref="HookEntityMetadata" /> class.
/// </summary>
/// <param name="hookType"></param>
/// <param name="entry"></param>
/// <param name="state">The state.</param>
/// <param name="context">The optional existing context (I believe this is usable for migrations).</param>
public HookEntityMetadata(HookType hookType, HookedEntityEntry entry, EntityState state, System.Data.Entity.DbContext context = null)
{
HookType = hookType;
Entry = entry;
_state = state;
CurrentContext = context;
}
public void Init(System.Data.Entity.DbContext db)
{
List <Tuple <string, string> > l = new List <Tuple <string, string> >();
l.Add(Tuple.Create("管理主页", "supervise/main/index"));
l.Add(Tuple.Create("审核", "supervise/audit/index"));
l.Add(Tuple.Create("用户", "supervise/appusers/index"));
l.Add(Tuple.Create("货币", "supervise/coin/index"));
l.Add(Tuple.Create("合约", "supervise/contracts/index"));
l.Add(Tuple.Create("论坛", "supervise/forum/index"));
l.Add(Tuple.Create("帮助", "supervise/helper/index"));
l.Add(Tuple.Create("新闻", "supervise/new/index"));
l.Add(Tuple.Create("数据", "supervise/tradedata/index"));
l.Add(Tuple.Create("安全", "supervise/security/index"));
l.Add(Tuple.Create("监控", "supervise/snap/index"));
l.Add(Tuple.Create("参数", "supervise/parameter/index"));
l.Add(Tuple.Create("网站参数", "supervise/siteParameter/index"));
l.Add(Tuple.Create("交易用户", "supervise/appusers/index"));
List <Menu> lm = new List <Menu>();
for (int i = 0; i < l.Count; i++)
{
var m = new Menu {
Id = i + 1, Name = l[i].Item1, Url = l[i].Item2
};
lm.Add(m);
}
db.Set <Menu>().AddOrUpdate(lm.ToArray());
db.SaveChanges();
}
/// <summary>
/// 获取当前 实体数据模型 上下问中指定实体类型的数据库表映射关系。
/// </summary>
/// <param name="_this">实体数据上下文对象。</param>
/// <param name="entityType">实体数据模型类型，对应当前数据库上下文中的一个表。</param>
/// <returns>返回实体数据模型类型 <paramref name="entityType"/> 对应当前实体数据上下文对象中数据库的相应数据表的映射关系描述对象。</returns>
public static EntityTable GetEntityTable(this System.Data.Entity.DbContext _this, Type entityType)
{
Check.NotNull(_this);
Check.NotNull(entityType);
Type thisType = _this.GetType();
Dictionary <Type, EntityTable> dict = null;
EntityTable table = null;
lock (_entityTableCache)
{
if (!_entityTableCache.Value.TryGetValue(thisType, out dict))
{
dict = new Dictionary <Type, EntityTable>();
_entityTableCache.Value.Add(thisType, dict);
}
if (!dict.TryGetValue(entityType, out table))
{
table = GetEntityTables(_this).FirstOrDefault(t => t.EntityType == entityType);
if (table != null)
{
dict.Add(entityType, table);
}
}
}
return(table);
}
/// <summary>
/// 清空数据库表中的数据。
/// </summary>
/// <param name="_this">表示一个 实体数据库上下文对象。</param>
/// <param name="tableName">数据库表名称。</param>
/// <remarks>注意：该操作不受数据库访问事务影响（不管有无设定事务或者事务有无提交，该操作都立即生效且不可逆）。</remarks>
public static void TruncateTable(this System.Data.Entity.DbContext _this, string tableName)
{
if (!string.IsNullOrWhiteSpace(tableName))
{
_this.Database.ExecuteSqlCommand("TRUNCATE TABLE " + tableName);
}
}
static public System.Collections.Generic.List <T> queryData <T>(object db, object where) where T : class
{
Expression <Func <T, bool> > Where = where as Expression <Func <T, bool> >;
System.Data.Entity.DbContext Db = db as System.Data.Entity.DbContext;
return(Db.Set <T>().Where(Where).ToList());
}
public UpdateUndercarriageSetupAction(System.Data.Entity.DbContext context, IEquipmentActionRecord actionRecord, SetupViewModel Paramteres)
: base(context)
{
Params = Paramteres;
Status = ActionStatus.Close;
_current = actionRecord;
}
public void Load(System.Data.Entity.DbContext db, DbSet <DbOption> dbOptions)
{
foreach (var cs in ControlStates)
{
cs.Load(dbOptions);
}
}
/// <summary>
/// 导出
/// </summary>
//public void Export(string directory)
//{
//}
/// <summary>
/// 导入基础数据
/// </summary>
/// <param name="context">数据库实例</param>
/// <param name="directory"></param>
/// <param name="orderFile"></param>
/// <param name="importConfig">部分导入基础数据时可选</param>
public void Import(System.Data.Entity.DbContext context, IEnumerable <SeedImportConfig> importConfig = null)
{
try
{
Type t = typeof(HSJXEntities);
PropertyInfo[] properties = t.GetProperties();
IEnumerable <PropertyInfo> pInfos = this.GetOrderedProperties(properties, this.DataDirectory, this.DataOrderFile);
foreach (PropertyInfo pInfo in pInfos)
{
try
{
if (judgeTableImport(pInfo.Name, importConfig) == false)
{
continue;
}
object dbSet = pInfo.GetValue(context);
MethodInfo dbSetAddMethod = dbSet.GetType().GetMethod("Add");
if (pInfo.PropertyType.GenericTypeArguments.Length > 0)
{
object deserializeResult = this.Deserialize(this.DataDirectory, pInfo.PropertyType.GenericTypeArguments[0]);
//Log.Info(string.Format("开始导入表{0}数据", pInfo.PropertyType.GenericTypeArguments[0].Name));
IEnumerable list = deserializeResult as IEnumerable;
if (list != null)
{
foreach (object o in list)
{
if (judgeRecordImport(pInfo.Name, o, importConfig) == false)
{
continue;
}
dbSetAddMethod.Invoke(dbSet, new object[] { o });
}
}
// Log.Info(string.Format("导入表{0}数据结束", pInfo.PropertyType.GenericTypeArguments[0].Name));
}
context.SaveChanges();
}
catch (Exception e)
{
// Log.Info(string.Format("导入表{0}数据结束", pInfo.PropertyType.GenericTypeArguments[0].Name), e);
}
}
// Log.Info("导入数据库数据成功");
}
catch (Exception e)
{
// Log.Info("导入数据库数据失败", e);
}
}
/// <summary>
/// Możliwość ustawienia innego kontekstu niż wbudowany
/// </summary>
/// <param name="context">Nowy kontekst EF</param>
protected void SetNewContext(System.Data.Entity.DbContext context)
{
if (context != null)
{
Context = context as AdServContext;
isBuildInContext = false;
}
}
public override void Save(System.Data.Entity.DbContext db, DbSet <DbOption> dbOptions, bool saveInstantly = false)
{
dbOptions.AddOrUpdate(new DbOption(Key, TabOrder.JoinAsString(",")));
if (saveInstantly)
{
db.SaveChanges();
}
}
public override void Save(System.Data.Entity.DbContext db, DbSet <DbOption> dbOptions, bool saveInstantly = false)
{
dbOptions.AddOrUpdate(new DbOption(Key, Dp.SelectedDate != null ? Dp.SelectedDate.ToString() : null));
if (saveInstantly)
{
db.SaveChanges();
}
}
public override void Save(System.Data.Entity.DbContext db, DbSet <DbOption> dbOptions, bool saveInstantly = false)
{
dbOptions.AddOrUpdate(new DbOption(Key, (Cb.IsChecked == true).ToInt().ToString()));
if (saveInstantly)
{
db.SaveChanges();
}
}
public override void Save(System.Data.Entity.DbContext db, DbSet <DbOption> dbOptions, bool saveInstantly = false)
{
dbOptions.AddOrUpdate(new DbOption(Key, string.Join(",", Mddl.SelectedItems.Cast <DdlItem>().Select(item => item.Index))));
if (saveInstantly)
{
db.SaveChanges();
}
}
public override void Save(System.Data.Entity.DbContext db, DbSet <DbOption> dbOptions, bool saveInstantly = false)
{
dbOptions.AddOrUpdate(new DbOption(Key, ((DdlItem)Ddl.SelectedItem).Index.ToString()));
if (saveInstantly)
{
db.SaveChanges();
}
}
public override void Save(System.Data.Entity.DbContext db, DbSet <DbOption> dbOptions, bool saveInstantly = false)
{
dbOptions.AddOrUpdate(new DbOption(Key, Num.Value.ToString()));
if (saveInstantly)
{
db.SaveChanges();
}
}
public override void Save(System.Data.Entity.DbContext db, DbSet <DbOption> dbOptions, bool saveInstantly = false)
{
dbOptions.AddOrUpdate(new DbOption(Key, string.Join(",", Gv.SelectedItems.IColToArray().Select(i => i.GetType().GetProperty(ByProperty)?.GetValue(i, null)).OrderBy(id => id))));
if (saveInstantly)
{
db.SaveChanges();
}
}
/// <summary>
/// 创建或获取一个泛型类型的 <see cref="EntityAccessor"/> 实体数据模型访问器对象，并指定其可操作的 实体数据模型类型。<br />
/// 该 实体数据模型访问器对象 仅可用于操作 指定的实体数据模型类型。<br />
/// 因实体数据模型访问器对象由 实体数据上下文 <see cref="DbContext"/> 创建，其 AutoDisposeContext 属性值为 false，表示不销毁其 DbContext 属性。
/// </summary>
/// <typeparam name="TEntity">指定的实体数据模型类型。</typeparam>
/// <param name="_this">实体数据上下文对象。</param>
/// <returns>返回一个泛型类型的 <see cref="EntityAccessor<TEntity>"/> 实体数据模型访问器对象。</returns>
public static EntityAccessor <TEntity> Accessor <TEntity>(this System.Data.Entity.DbContext _this)
where TEntity : class, new()
{
EntityAccessor <TEntity> accessor = new EntityAccessor <TEntity>(_this);
accessor.AutoDisposeContext = false;
return(accessor);
}
private bool IsEntityKeyGenerated <T>(System.Data.Entity.DbContext dbContext, T entity) where T : class
{
var objectContext = ((IObjectContextAdapter)dbContext).ObjectContext;
var set = objectContext.CreateObjectSet <T>();
var isKeyGenerated = set.EntitySet.ElementType.KeyMembers.Any(k => k.IsStoreGeneratedComputed | k.IsStoreGeneratedIdentity);
return(isKeyGenerated);
}
/// <summary>
/// 验证当前 实体数据库上下文对象 所示类型中是否定义了实体类型为 <paramref name="type"/> 的数据集合 <see cref="DbSet<TEntity>"/> 属性。
/// </summary>
/// <param name="_this">表示一个 实体数据库上下文对象。</param>
/// <param name="type">表示需要验证的 实体数据类型。</param>
/// <returns>如果 <paramref name="_this"/> 所示的 实体数据库上下文对象 所示类型中定义了实体类型为 <paramref name="type"/> 的数据集合 <see cref="DbSet<TEntity>"/> 属性，则返回 true，否则返回 false。</returns>
public static bool IsDefinedEntity(this System.Data.Entity.DbContext _this, Type type)
{
Check.NotNull(type);
var types = from t in GetSetTypes(_this, false)
let args = t.GenericTypeArguments
where t.IsGenericType && args != null && args.Length > 0
select args[0];
return(types.Contains(type));
}
public override void Save(System.Data.Entity.DbContext db, DbSet <DbOption> dbOptions, bool saveInstantly = false)
{
var isExtended = TilesMenu.IsFullSize;
dbOptions.AddOrUpdate(new DbOption(Key, isExtended.ToString()));
if (saveInstantly)
{
db.SaveChanges();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RepositoryWithTypedId{T,TId}"/> class.
/// </summary>
/// <param name="dbContext">
/// The db context.
/// </param>
/// <exception cref="ArgumentNullException">
/// Argument Null Exception
/// </exception>
public RepositoryWithTypedId(System.Data.Entity.DbContext dbContext)
{
if (dbContext == null)
{
throw new ArgumentNullException("dbContext may not be null");
}
this._dbContext = dbContext;
this.Includes = new Collection <string>();
}
public void CreateBaseService(string connection)
{
this.Context = new System.Data.Entity.DbContext(connection); //连接数据库字符串
this.Context.Configuration.ProxyCreationEnabled = false; //创建实体类型
this.Context.Configuration.LazyLoadingEnabled = false; //延迟加载
this.Context.Configuration.ValidateOnSaveEnabled = false; //上下文跟踪
this.Context.Configuration.AutoDetectChangesEnabled = false; //上下文跟踪
this.Context.Configuration.UseDatabaseNullSemantics = false; //上下文跟踪
this.Context.Configuration.EnsureTransactionsForFunctionsAndCommands = false; //上下文跟踪
}
public void Save(System.Data.Entity.DbContext db, DbSet <DbOption> dbOptions, bool saveEachControlInstantly = false)
{
foreach (var cs in ControlStates)
{
cs.Save(db, dbOptions, saveEachControlInstantly);
}
if (!saveEachControlInstantly)
{
db.SaveChanges();
}
}
public static List <string> GetTableList(System.Data.Entity.DbContext db)
{
var tableNames = db.Database.SqlQuery <string>("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' AND TABLE_NAME NOT LIKE '%Migration%' AND TABLE_NAME NOT LIKE 'AspNet%'").ToList();
return(tableNames);
var type = db.GetType();
return(db.GetType().GetProperties()
.Where(x => x.PropertyType.Name == "DbSet`1")
.Select(x => x.Name).ToList());
}
/// <summary>
/// 获取当前 实体数据模型 上下文中定义的所有 实体数据模型 类型所映射的数据表信息。
/// </summary>
/// <param name="_this">实体数据上下文对象。</param>
/// <returns>返回当前 实体数据模型 上下文中定义的所有 实体数据模型 类型所映射的数据表信息。</returns>
public static EntityTable[] GetEntityTables(this System.Data.Entity.DbContext _this)
{
Check.NotNull(_this);
Type thisType = _this.GetType();
EntityTable[] tables = null;
lock (_entityTablesCache)
{
if (!_entityTablesCache.Value.TryGetValue(thisType, out tables))
{
MetadataWorkspace metadata = GetMetadataWorkspace(_this);
ObjectItemCollection collection = metadata.GetItemCollection(DataSpace.OSpace) as ObjectItemCollection;
EntityContainer container = metadata.GetItems <EntityContainer>(DataSpace.CSpace).FirstOrDefault();
if (container == null)
{
throw new InvalidConstraintException("获取实体数据上下文对象中的 实体容器对象失败，无法获取其 EntityContainer。");
}
var entitySets = container.EntitySets;
var entitySetMappings = metadata.GetItems <EntityContainerMapping>(DataSpace.CSSpace).FirstOrDefault().EntitySetMappings;
var entityTypes = metadata.GetItems <EntityType>(DataSpace.OSpace);
List <EntityTable> list = new List <EntityTable>();
foreach (var entityType in entityTypes)
{
var elemType = collection.GetClrType(entityType);
if (elemType == null)
{
continue;
}
var entitySet = entitySets.First(s => s.ElementType.Name == entityType.Name);
var mapping = entitySetMappings.First(s => s.EntitySet == entitySet);
var mappingFragment = (mapping.EntityTypeMappings.FirstOrDefault(a => a.IsHierarchyMapping) ?? mapping.EntityTypeMappings.First()).Fragments.Single();
EntityTable table = new EntityTable();
table.ModelSet = entitySet;
table.StoreSet = mappingFragment.StoreEntitySet;
table.ModelType = entityType;
table.StoreType = mappingFragment.StoreEntitySet.ElementType;
table.EntityType = elemType;
table.TableName = entitySet.GetTableName();
table.Schema = entitySet.Schema;
list.Add(table);
}
tables = list.ToArray();
_entityTablesCache.Value.Add(thisType, tables);
}
}
return(tables);
}
public static int Execute(this System.Data.Entity.DbContext ctx, string sqlText, object parameter)
{
var args = AnonymousObjectToParameters(parameter);
if (args != null)
{
return(ctx.Database.ExecuteSqlCommand(sqlText, args));
}
else
{
return(ctx.Database.ExecuteSqlCommand(sqlText));
}
}
public static IEnumerable <T> Query <T>(this System.Data.Entity.DbContext ctx, string query, object parameter)
{
var args = AnonymousObjectToParameters(parameter);
if (args != null)
{
return(ctx.Database.SqlQuery <T>(query, args));
}
else
{
return(ctx.Database.SqlQuery <T>(query));
}
}
/// <summary>
/// Gets table schema
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbCtx"></param>
/// <param name="obj"></param>
/// <returns></returns>
public static string GetTableSchema <T>(this System.Data.Entity.DbContext dbCtx, T obj)
{
var mappings = dbCtx.GetMappings(obj);
// Find the storage entity set (table) that the entity is mapped
var table = mappings
.EntityTypeMappings.Single()
.Fragments.Single()
.StoreEntitySet;
// Return the table name from the storage entity set
return((string)table.MetadataProperties["Schema"].Value ?? table.Schema);
}
public override void Save(System.Data.Entity.DbContext db, DbSet <DbOption> dbOptions, bool saveInstantly = false)
{
dbOptions.AddOrUpdate(new DbOption(Key, Rbs.Select((rb, i) =>
new
{
i,
rb
}).Single(el => el.rb.IsChecked == true).i.ToString()));
if (saveInstantly)
{
db.SaveChanges();
}
}
