/// <summary> /// Constructor /// </summary> /// <param name="connectionString">Full connection string</param> /// <param name="dataBaseTypes">The type of the database Ms-sql or Sql-light</param> public Transaction(string connectionString, DataBaseTypes dataBaseTypes) : base() { base._transaction = this; _attachedObjects = new Custom_ValueType <string, object>(); if (string.IsNullOrEmpty(connectionString)) { if (string.IsNullOrEmpty(connectionString)) { throw new EntityException("ConnectionString can not be empty"); } } ConnectionString = connectionString; DataBaseTypes = dataBaseTypes; _dbSchema = new DbSchema(this); if (!_moduleIni[dataBaseTypes]) { lock (this) { if (!_moduleIni[dataBaseTypes]) { OnModuleConfiguration(new ModuleBuilder(dataBaseTypes)); OnModuleStart(); _moduleIni[dataBaseTypes] = true; } } } else { _moduleIni[dataBaseTypes] = true; } }
/// <summary> /// Get the ColumnSchema /// </summary> /// <param name="datatype"></param> /// <returns></returns> public Custom_ValueType <string, ColumnSchema> GetColumnSchema(Type datatype) { try { var key = datatype.FullName + _transaction.DataBaseTypes.ToString(); if (CachedColumnSchema.ContainsKey(key)) { return(CachedColumnSchema[key]); } datatype = datatype.GetActualType(); var tableName = datatype.TableName(); var sql = $"SELECT COLUMN_NAME as columnname, data_type as datatype ,TABLE_CATALOG as db,TABLE_NAME as tb , IS_NULLABLE as isnullable FROM INFORMATION_SCHEMA.COLUMNS WHERE LOWER(TABLE_NAME) = LOWER(String[{tableName.Name}])"; if (_transaction.DataBaseTypes == DataBaseTypes.Sqllight) { sql = $"SELECT name as columnname, type as datatype FROM pragma_table_info(String[{tableName.Name}])"; } var columns = (List <ColumnSchema>)_transaction.DataReaderConverter(_transaction.GetSqlCommand(sql), typeof(ColumnSchema)); var dic = new Custom_ValueType <string, ColumnSchema>(); if (columns != null) { columns.ForEach(x => dic.Add(x.ColumnName, x)); } return(CachedColumnSchema.GetOrAdd(key, dic)); } catch (NpgsqlException) { _transaction.Renew(); return(GetColumnSchema(datatype)); } }
internal static bool GetField(this FieldInfo field, Custom_ValueType <string, IFastDeepClonerProperty> properties) { if (!properties.ContainsKey(field.Name)) { return(properties.TryAdd(field.Name, new FastDeepClonerProperty(field))); } return(true); }
internal Dictionary <string, myPropInfo> Getproperties(Type type, string typename) { Dictionary <string, myPropInfo> sd = null; if (_propertycache.TryGetValue(typename, out sd)) { return(sd); } else { sd = new Custom_ValueType <string, myPropInfo>(); var pr = DeepCloner.GetFastDeepClonerProperties(type); foreach (var p in pr) { if (!p.CanRead)// Property is an indexer { continue; } myPropInfo d = CreateMyProp(p.PropertyType, p.Name); d.Property = p; d.CanWrite = p.CanWrite; foreach (var at in p.Attributes) { if (at is DataMemberAttribute) { var dm = (DataMemberAttribute)at; if (dm.Name != "") { d.memberName = dm.Name; } } } if (d.memberName != null) { sd.Add(d.memberName, d); } else { sd.Add(p.Name.ToLowerInvariant(), d); } } _propertycache.Add(typename, sd); } return(sd); }
internal static Dictionary <string, IFastDeepClonerProperty> GetFastDeepClonerProperties(this Type primaryType) { if (!CachedPropertyInfo.ContainsKey(primaryType)) { var properties = new Custom_ValueType <string, IFastDeepClonerProperty>(); if (primaryType.GetTypeInfo().BaseType != null && primaryType.GetTypeInfo().BaseType.Name != "Object") { primaryType.GetRuntimeProperties().Where(x => x.GetField(properties)).ToList(); primaryType.GetTypeInfo().BaseType.GetRuntimeProperties().Where(x => x.GetField(properties)).ToList(); } else { primaryType.GetRuntimeProperties().Where(x => x.GetField(properties)).ToList(); } CachedPropertyInfo.Add(primaryType, properties); } return(CachedPropertyInfo[primaryType]); }
internal static object Creator(this Type type) { if (!DefaultConstructor.ContainsKey(type)) { DefaultConstructor.Add(type, type.GetConstructor(Type.EmptyTypes)); } if (DefaultConstructor[type] != null) { #if NETSTANDARD2_0 || NETSTANDARD1_3 || NETSTANDARD1_5 if (CachedConstructor.ContainsKey(type)) { return(CachedConstructor[type].Invoke()); } return(CachedConstructor.GetOrAdd(type, Expression.Lambda <Func <object> >(Expression.New(type)).Compile()).Invoke()); #else if (CachedDynamicMethod.ContainsKey(type)) { return(CachedDynamicMethod[type]()); } var emptyConstructor = DefaultConstructor[type]; var dynamicMethod = new System.Reflection.Emit.DynamicMethod("CreateInstance", type, Type.EmptyTypes, true); System.Reflection.Emit.ILGenerator ilGenerator = dynamicMethod.GetILGenerator(); ilGenerator.Emit(System.Reflection.Emit.OpCodes.Nop); ilGenerator.Emit(System.Reflection.Emit.OpCodes.Newobj, emptyConstructor); ilGenerator.Emit(System.Reflection.Emit.OpCodes.Ret); return(CachedDynamicMethod.GetOrAdd(type, (ObjectActivator)dynamicMethod.CreateDelegate(typeof(ObjectActivator)))()); #endif } else { return(FormatterServices.GetUninitializedObject(type)); } }
internal static DbCommandExtended ProcessSql(this IRepository repository, IDbConnection connection, IDbTransaction tran, string sql) { var i = 1; var dicCols = new Custom_ValueType <string, Tuple <object, SqlDbType> >(); MatchCollection matches = null; while ((matches = stringExp.Matches(sql)).Count > 0) { var exp = matches[0]; var col = "@CO" + i + "L"; object str = exp.Value.TrimEnd(']').Substring(@"String\[".Length - 1); sql = sql.Remove(exp.Index, exp.Value.Length); sql = sql.Insert(exp.Index, col); dicCols.TryAdd(col, new Tuple <object, SqlDbType>(str.ConvertValue <string>(), SqlDbType.NVarChar)); i++; } while ((matches = dateExp.Matches(sql)).Count > 0) { var exp = matches[0]; var col = "@CO" + i + "L"; object str = exp.Value.TrimEnd(']').Substring(@"Date\[".Length - 1); sql = sql.Remove(exp.Index, exp.Value.Length); sql = sql.Insert(exp.Index, col); dicCols.TryAdd(col, new Tuple <object, SqlDbType>(str.ConvertValue <DateTime>(), SqlDbType.DateTime)); i++; } while ((matches = guidExp.Matches(sql)).Count > 0) { var exp = matches[0]; var col = "@CO" + i + "L"; object str = exp.Value.TrimEnd(']').Substring(@"Guid\[".Length - 1); sql = sql.Remove(exp.Index, exp.Value.Length); sql = sql.Insert(exp.Index, col); dicCols.TryAdd(col, new Tuple <object, SqlDbType>(str.ConvertValue <Guid?>(), SqlDbType.UniqueIdentifier)); i++; } sql = sql.CleanValidSqlName(repository.DataBaseTypes); DbCommand cmd = null; if (repository.DataBaseTypes == DataBaseTypes.Mssql) { cmd = tran != null ? new SqlCommand(sql, connection as SqlConnection, tran as SqlTransaction) : new SqlCommand(sql, connection as SqlConnection); } else if (repository.DataBaseTypes == DataBaseTypes.Sqllight) { cmd = tran == null ? new SQLiteCommand(sql, connection as SQLiteConnection) : new SQLiteCommand(sql, connection as SQLiteConnection, tran as SQLiteTransaction); } else { cmd = tran == null ? new NpgsqlCommand(sql, connection as NpgsqlConnection) : new NpgsqlCommand(sql, connection as NpgsqlConnection, tran as NpgsqlTransaction); } var dbCommandExtended = new DbCommandExtended(cmd, repository); foreach (var dic in dicCols) { repository.AddInnerParameter(dbCommandExtended, dic.Key, dic.Value.Item1, dic.Value.Item2); } return(dbCommandExtended); }
internal static IList DataReaderConverter(Transaction.Transaction repository, IDataReader reader, DbCommandExtended command, Type type) { var tType = type.GetActualType(); var attachable = tType.GetPrimaryKey() != null; var baseListType = typeof(List <>); var listType = baseListType.MakeGenericType(tType); var iList = DeepCloner.CreateInstance(listType) as IList; var props = DeepCloner.GetFastDeepClonerProperties(tType); try { var colNames = new Custom_ValueType <int, string>(); var pp = new Custom_ValueType <int, FastDeepCloner.IFastDeepClonerProperty>(); while (reader.Read()) { object item = null; object clItem = null; item = DeepCloner.CreateInstance(tType); clItem = attachable ? DeepCloner.CreateInstance(tType) : null; var col = 0; while (col < reader.FieldCount) { string columnName; if (colNames.ContainsKey(col)) { columnName = colNames[col]; } else { columnName = reader.GetName(col); colNames.TryAdd(col, columnName); } var value = reader[columnName]; IFastDeepClonerProperty prop; if (!pp.ContainsKey(col)) { prop = DeepCloner.GetProperty(tType, columnName); if (prop == null) { prop = props.FirstOrDefault(x => string.Equals(x.GetPropertyName(), columnName, StringComparison.CurrentCultureIgnoreCase) || x.GetPropertyName().ToLower() == columnName); } pp.TryAdd(col, prop); } else { prop = pp[col]; } if (prop != null && value != DBNull.Value && value != null && prop.CanRead) { if (value as byte[] != null && prop.PropertyType.FullName.Contains("Guid")) { value = new Guid(value as byte[]); } var dataEncode = prop.GetCustomAttribute <DataEncode>(); if (prop.ContainAttribute <ToBase64String>()) { if (value.ConvertValue <string>().IsBase64String()) { value = MethodHelper.DecodeStringFromBase64(value.ConvertValue <string>()); } else { value = MethodHelper.ConvertValue(value, prop.PropertyType); } } else if (dataEncode != null) { value = new DataCipher(dataEncode.Key, dataEncode.KeySize).Decrypt(value.ConvertValue <string>()); } else if (prop.ContainAttribute <JsonDocument>()) { value = value?.ToString().FromJson(prop.PropertyType); } else if (prop.ContainAttribute <XmlDocument>()) { value = value?.ToString().FromXml(); } else { value = MethodHelper.ConvertValue(value, prop.PropertyType); } prop.SetValue(item, value); if (attachable) { prop.SetValue(clItem, value); } } col++; } if (clItem != null && !(repository?.IsAttached(clItem) ?? true)) { repository?.AttachNew(clItem); } iList.Add(item); } } catch (Exception e) { throw e; } finally { reader.Close(); reader.Dispose(); if (repository.OpenedDataReaders.ContainsKey(reader)) { repository.OpenedDataReaders.Remove(reader); } } return(iList); }