List <IMemberBinder> CreateMemberBinders(IDbContext dbContext)
{
ObjectMemberMapper mapper = this.ConstructorDescriptor.GetEntityMemberMapper();
List <IMemberBinder> memberBinders = new List <IMemberBinder>(this.PrimitiveMembers.Count + this.ComplexMembers.Count + this.CollectionMembers.Count);
foreach (var kv in this.PrimitiveMembers)
{
MRMTuple mrmTuple = mapper.GetMappingMemberMapper(kv.Key);
PrimitiveMemberBinder binder = new PrimitiveMemberBinder(kv.Key, mrmTuple, kv.Value);
memberBinders.Add(binder);
}
foreach (var kv in this.ComplexMembers)
{
MemberValueSetter setter = mapper.GetMemberSetter(kv.Key);
IObjectActivator memberActivtor = kv.Value.CreateObjectActivator(dbContext);
ComplexMemberBinder binder = new ComplexMemberBinder(setter, memberActivtor);
memberBinders.Add(binder);
}
foreach (var kv in this.CollectionMembers)
{
MemberValueSetter setter = mapper.GetMemberSetter(kv.Key);
IObjectActivator memberActivtor = kv.Value.CreateObjectActivator(dbContext);
CollectionMemberBinder binder = new CollectionMemberBinder(setter, memberActivtor);
memberBinders.Add(binder);
}
return(memberBinders);
}
List <IObjectActivator> CreateArgumentActivators(IDbContext dbContext)
{
ParameterInfo[] parameters = this.ConstructorDescriptor.ConstructorInfo.GetParameters();
List <IObjectActivator> argumentActivators = new List <IObjectActivator>(parameters.Length);
for (int i = 0; i < parameters.Length; i++)
{
IObjectActivator argumentActivator = null;
ParameterInfo parameter = parameters[i];
if (this.ConstructorParameters.TryGetValue(parameter, out int ordinal))
{
argumentActivator = new PrimitiveObjectActivator(parameter.ParameterType, ordinal);
}
else if (this.ConstructorComplexParameters.TryGetValue(parameter, out IObjectActivatorCreator argumentActivatorCreator))
{
argumentActivator = argumentActivatorCreator.CreateObjectActivator(dbContext);
}
else
{
throw new UnbelievableException();
}
argumentActivators.Add(argumentActivator);
}
return(argumentActivators);
}
public static void CleanUp()
{
Lock();
try
{
ScriptNET.Ast.ScriptExpr.HandleOperator -= HandleOperator;
Handlers.Clear();
initializingTypes.Clear();
Binder = null;
Activator = null;
ScopeFactory = null;
if (AssemblyManager != null)
{
AssemblyManager.Dispose();
}
AssemblyManager = null;
SettingsItems.Clear();
BinOperators.Clear();
UnaryOperators.Clear();
InitializationScript = null;
Configuration = new ScriptConfiguration();
}
finally
{
UnLock();
}
}
public CollectionObjectFitter(IObjectActivator elementActivator, IEntityRowComparer entityRowComparer, IFitter elementFitter, PropertyDescriptor elementOwnerProperty)
{
this._elementActivator = elementActivator;
this._entityRowComparer = entityRowComparer;
this._elementFitter = elementFitter;
this._elementOwnerProperty = elementOwnerProperty;
}
public IObjectActivator Next()
{
IObjectActivator ret = this._objectActivators[this._next];
this._next++;
return(ret);
}
public object CreateObjectAsSingle(Type type, params object[] args)
{
var key = type.Name;
if (container.ContainsKey(key))
{
return(container[key]);
}
IObjectActivator activator = null;
if (!objectActivators.ContainsKey(key))
{
var argsType = Array.ConvertAll(args, x => x.GetType());
activator = CreateActivator(type, argsType);
objectActivators.Add(key, activator);
}
else
{
activator = objectActivators[key];
}
var obj = activator.Create(args);
container.Add(key, obj);
return(obj);
}
async BoolResultTask MoveNext(bool @async)
{
if (this._disposed)
{
return(false);
}
bool nextResult = @async ? await this._dataReaderEnumerator.MoveNextAsync() : this._dataReaderEnumerator.MoveNext();
if (nextResult)
{
if (this._objectActivator == null)
{
this._objectActivator = this._objectActivatorCreator(this._dataReaderEnumerator.Current);
}
this._current = (T)(await this._objectActivator.CreateInstance(this._dataReaderEnumerator.Current, @async));
}
else
{
this._current = default;
}
return(nextResult);
}
public QueryEnumerator(InternalSqlQuery <T> internalSqlQuery)
{
this._internalSqlQuery = internalSqlQuery;
this._reader = null;
this._objectActivator = null;
this._current = default(T);
this._hasFinished = false;
this._disposed = false;
}
static IDataReader DataReaderReady(IDataReader dataReader, IObjectActivator objectActivator)
{
if (objectActivator is RootEntityActivator)
{
dataReader = new QueryDataReader(dataReader);
}
objectActivator.Prepare(dataReader);
return(dataReader);
}
public QueryEnumerator(DbCommandFactor commandFactor, Func <DbCommandFactor, bool, Task <IDataReader> > dataReaderGetter)
{
this._commandFactor = commandFactor;
this._dataReaderGetter = dataReaderGetter;
this._objectActivator = commandFactor.ObjectActivator;
this._reader = null;
this._current = default(T);
this._hasFinished = false;
this._disposed = false;
}
public QueryEnumerator(InternalAdoSession adoSession, DbCommandFactor commandFactor)
{
this._adoSession = adoSession;
this._commandFactor = commandFactor;
this._objectActivator = commandFactor.ObjectActivator;
this._reader = null;
this._current = default(T);
this._hasFinished = false;
this._disposed = false;
}
public void Prepare(IDataReader reader)
{
for (int i = 0; i < this._argumentActivators.Count; i++)
{
IObjectActivator argumentActivator = this._argumentActivators[i];
argumentActivator.Prepare(reader);
}
for (int i = 0; i < this._memberBinders.Count; i++)
{
IMemberBinder binder = this._memberBinders[i];
binder.Prepare(reader);
}
}
void Prepare()
{
Type type = typeof(T);
if (Utils.IsMapType(type))
{
MappingField mf = new MappingField(type, 0);
this._objectActivator = mf.CreateObjectActivator();
this._reader = this.ExecuteReader();
return;
}
this._reader = this.ExecuteReader();
this._objectActivator = GetObjectActivator(type, this._reader);
}
void Prepare()
{
Type type = typeof(T);
if (Utils.IsMapType(type))
{
MappingField mf = new MappingField(type, 0);
this._objectActivator = mf.CreateObjectActivator();
this._reader = this._internalSqlQuery._dbContext.InnerDbSession.ExecuteReader(this._internalSqlQuery._sql, this._internalSqlQuery._parameters, CommandBehavior.Default, CommandType.Text);
return;
}
this._reader = this._internalSqlQuery._dbContext.InnerDbSession.ExecuteReader(this._internalSqlQuery._sql, this._internalSqlQuery._parameters, CommandBehavior.Default, CommandType.Text);
this._objectActivator = GetObjectActivator(type, this._reader);
}
void Prepare()
{
Type type = typeof(T);
if (type != UtilConstants.TypeOfObject && MappingTypeSystem.IsMappingType(type))
{
MappingField mf = new MappingField(type, 0);
this._objectActivator = mf.CreateObjectActivator();
this._reader = this.ExecuteReader();
return;
}
this._reader = this.ExecuteReader();
this._objectActivator = GetObjectActivator(type, this._reader);
}
void Prepare()
{
Type type = typeof(T);
if (type != PublicConstants.TypeOfObject && MappingTypeSystem.IsMappingType(type))
{
PrimitiveObjectActivatorCreator activatorCreator = new PrimitiveObjectActivatorCreator(type, 0);
this._objectActivator = activatorCreator.CreateObjectActivator();
this._reader = this.ExecuteReader();
return;
}
this._reader = this.ExecuteReader();
this._objectActivator = GetObjectActivator(type, this._reader);
}
public static void Initialize(Stream configuration)
{
Lock();
try
{
LoadConfiguration(configuration);
if (Binder == null)
{
Binder = new DefaultBinder();
}
if (Activator == null)
{
Activator = new DefaultActivator();
}
InitializeSettingItems();
RegisterOperators();
if (ScopeFactory == null)
{
ScopeFactory = Activator.CreateInstance(GetNativeType(GetSettingsItem <string>(ConfigSchema.ScopeFactoryAttribute))) as IScopeFactory;
}
RegisterScopes();
if (AssemblyManager == null)
{
AssemblyManager = new DefaultAssemblyManager();
}
OnInitializingTypes(AssemblyManager);
AssemblyManager.Initialize(Configuration);
if (!string.IsNullOrEmpty(Configuration.Initialization))
{
InitializationScript = Script.Compile(Configuration.Initialization);
}
RegisterOperatorHandler("+=", new EventOperatorHandler(true));
RegisterOperatorHandler("-=", new EventOperatorHandler(false));
ScriptNET.Ast.ScriptExpr.HandleOperator += HandleOperator;
}
finally
{
UnLock();
}
}
public IObjectActivator CreateObjectActivator(IDbContext dbContext)
{
EntityMemberMapper mapper = this.ConstructorDescriptor.GetEntityMemberMapper();
List <IValueSetter> memberSetters = new List <IValueSetter>(this.Members.Count + this.EntityMembers.Count);
foreach (var kv in this.Members)
{
IMRM mMapper = mapper.TryGetMappingMemberMapper(kv.Key);
MappingMemberBinder binder = new MappingMemberBinder(mMapper, kv.Value);
memberSetters.Add(binder);
}
foreach (var kv in this.EntityMembers)
{
Action <object, object> del = mapper.TryGetNavigationMemberSetter(kv.Key);
IObjectActivator memberActivtor = kv.Value.CreateObjectActivator();
NavigationMemberBinder binder = new NavigationMemberBinder(del, memberActivtor);
memberSetters.Add(binder);
}
Func <IDataReader, ReaderOrdinalEnumerator, ObjectActivatorEnumerator, object> instanceCreator = this.ConstructorDescriptor.GetInstanceCreator();
List <int> readerOrdinals = this.ConstructorParameters.Select(a => a.Value).ToList();
List <IObjectActivator> objectActivators = this.ConstructorEntityParameters.Select(a => a.Value.CreateObjectActivator()).ToList();
ObjectActivator ret;
if (dbContext != null)
{
ret = new ObjectActivatorWithTracking(instanceCreator, readerOrdinals, objectActivators, memberSetters, this.CheckNullOrdinal, dbContext);
}
else
{
ret = new ObjectActivator(instanceCreator, readerOrdinals, objectActivators, memberSetters, this.CheckNullOrdinal);
}
return(ret);
}
public QueryEnumerator(Func <bool, Task <IDataReader> > dataReaderCreator, IObjectActivator objectActivator) : this(dataReaderCreator, dataReader => objectActivator)
{
}
public DbCommandFactor(IObjectActivator objectActivator, string commandText, DbParam[] parameters)
{
this.ObjectActivator = objectActivator;
this.CommandText = commandText;
this.Parameters = parameters;
}
public static object CreateInstance(this IObjectActivator activator, IScriptContext context, IObjectBind bind)
{
return(activator.CreateInstance(null, bind));
}
public RootEntityActivator(IObjectActivator entityActivator, IFitter fitter, IEntityRowComparer entityRowComparer)
{
this._entityActivator = entityActivator;
this._fitter = fitter;
this._entityRowComparer = entityRowComparer;
}
public Factory(IObjectActivator objectActivator) : base(objectActivator)
{
}
public static object CreateInstance(this IObjectActivator activator, Type type)
{
return(activator.CreateInstance(type, null));
}
public ComplexMemberBinder(Action <object, object> setter, IObjectActivator activtor)
{
this._setter = setter;
this._activtor = activtor;
}
public DbCommandFactor(IObjectActivator objectActivator, string commandText, DbParam[] parameters)
{
this.ObjectActivator = objectActivator;
this.CommandText = commandText;
this.Parameters = parameters;
}
public static T CreateInstance <T>(this IObjectActivator activator)
{
return((T)CreateInstance(activator, typeof(T)));
}
public ComplexMemberBinder(MemberValueSetter setter, IObjectActivator activtor) : base(setter, activtor)
{
}
public static T CreateInstance <T>(this IObjectActivator activator, object[] args)
{
return((T)activator.CreateInstance(typeof(T), args));
}
public static T Activate <T>(this IObjectActivator activator, Func <string, Type, object> argumentGetter)
{
return((T)activator.Activate(typeof(T), argumentGetter));
}
public ModelBinder(IObjectActivator activator)
{
_activator = activator;
}
