public IEnumerable <T> ReadAll(object param) { ParameterException.Check(param != null, ParameterError.NotExistParameter); DbCommand command = EntityManager.Connection.CreateCommand(); command.CommandText = QueryBuilder.ReadAll(param); command.CommandType = CommandType.Text; if (!ParameterGeneratorCache.ContainsKey(param.GetType())) { ParameterGeneratorCache.Add(param.GetType(), CreateParamInfoGenerator(param)); } var fillParameterGenerator = ParameterGeneratorCache[param.GetType()]; fillParameterGenerator(command, param); EntityManager.Connection.Open(); using (var reader = command.ExecuteReader()) { if (!ConstructInstanceCache.ContainsKey(typeof(T))) { ConstructInstanceCache.Add(typeof(T), CreateConstructInstance(reader)); } var constructingInstance = ConstructInstanceCache[typeof(T)]; while (reader.Read()) { object row = constructingInstance(reader); yield return((T)row); } } EntityManager.Connection.Close(); }
public AutowiredPositionalParameter() { if (!typeof(TParam).IsAutowirable()) { throw ParameterException.ParameterIsNotAutowirable(typeof(TParam)); } }
public async Task <T> CreateAsync(T data) { ParameterException.Check(data != null, ParameterError.NotExistData); DbCommand command = EntityManager.Connection.CreateCommand(); command.CommandText = QueryBuilder.Create(data); command.CommandType = CommandType.Text; if (!ParameterGeneratorCache.ContainsKey(data.GetType())) { ParameterGeneratorCache.Add(data.GetType(), CreateParamInfoGenerator(data)); } var fillParameterGenerator = ParameterGeneratorCache[data.GetType()]; fillParameterGenerator(command, data); await EntityManager.Connection.OpenAsync().ConfigureAwait(false); var id = Convert.ToInt32(await command.ExecuteScalarAsync().ConfigureAwait(false)); EntityManager.Connection.Close(); if (!ConstructDataInstanceCache.ContainsKey(typeof(T))) { ConstructDataInstanceCache.Add(typeof(T), CreateConstructDataInstance()); } var constructingInstance = ConstructDataInstanceCache[typeof(T)]; var result = constructingInstance(data, id); return(result); }
static DependencyProvider[] DoCreateParameterProviders(ObjectDescription description, MethodBase methodBase, bool strongTyped) { var paramInfos = methodBase.GetParameters(); var methodParameterCount = paramInfos.Length; if (methodParameterCount == 0) { return(null); } var dependencies = new DependencyProvider[methodParameterCount]; for (var i = 0; i < methodParameterCount; i++) { var paramInfo = paramInfos[i]; if (paramInfo.ParameterType.IsAutowirable()) { dependencies[i] = CreateAutowiredDependencyProvider(new ParameterInjectionTargetInfo(paramInfo, description), strongTyped); } else { throw ParameterException.RequiredParameterNotProvided(methodBase, paramInfo); } } return(dependencies); }
object[] MergePositionalParameters(InjectionContext context, ParameterSet myParams) { var paramLength = myParams.Length - 1; var result = new object[_ctorDependencyProviders.Length]; for (var i = 0; i < _ctorDependencyProviders.Length; i++) { var depProvider = _ctorDependencyProviders[i]; if (i > paramLength) { if (depProvider.IsAutowirable) { depProvider.CreateObject(context, out result[i]); } else { throw ParameterException.NonautowirableParameterNotSpecified(context, depProvider, i); } } else { var providedParam = myParams[i]; if (providedParam.CanSupplyValueFor(depProvider)) { result[i] = providedParam.ParameterValue; } else { depProvider.CreateObject(context, out result[i]); } } } return(result); }
//DataReader로 부터 값들을 읽어 인스턴스를 만든다 private ConstructInstance CreateConstructInstance(IDataReader reader) { ParameterException.Check(reader != null, ParameterError.NotExistReader); var type = typeof(T); var dynamicMethod = new DynamicMethod("ConstructInstance", type, new[] { typeof(IDataReader) }, type); var il = dynamicMethod.GetILGenerator(); Label startLoop = il.DefineLabel(); Label endLoop = il.DefineLabel(); ConstructorInfo constructor = type.GetConstructor(Type.EmptyTypes); il.Emit(OpCodes.Newobj, constructor); //[instance] il.MarkLabel(startLoop); PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (PropertyInfo property in properties) { Label startValueTypeNullLoop = il.DefineLabel(); Label endValueTypeNullLoop = il.DefineLabel(); Label jumpToEnd = il.DefineLabel(); var columnAttribute = property.GetCustomAttribute <ColumnAttribute>(); AttributeException.Check(columnAttribute != null, AttributeError.NotExistColumnAttribute); var columnName = columnAttribute.Name ?? property.Name; //SetValue il.Emit(OpCodes.Dup); //[instance][instance] il.Emit(OpCodes.Ldarg_0); //[instance][instance][IDataReader] il.Emit(OpCodes.Ldstr, columnName); //[instance][instance][IDataReader][Name] il.Emit(OpCodes.Call, typeof(IDataReaderHelper).GetMethod(nameof(IDataReaderHelper .GetValue))); //[instance][instance][value] il.Emit(OpCodes.Dup); //[instance][instance][value][value] il.Emit(OpCodes.Ldsfld, typeof(DBNull).GetField(nameof(DBNull.Value))); //[instance][instance][value][value][DBNullValue] il.Emit(OpCodes.Ceq); // [instance][instance][value][result] il.Emit(OpCodes.Brtrue, startValueTypeNullLoop); //[instance][instance] if (property.PropertyType.IsValueType) { il.Emit(OpCodes.Unbox_Any, property.PropertyType); //[instance][instance][unbox_value] } il.MarkLabel(endValueTypeNullLoop); il.Emit(OpCodes.Call, property.GetSetMethod()); //[instance] il.Emit(OpCodes.Br, jumpToEnd); il.MarkLabel(startValueTypeNullLoop); if (property.PropertyType.IsValueType) { il.Emit(OpCodes.Pop); //[instance][instance] il.Emit(OpCodes.Ldc_I4_0); //[instance][instance][0] } il.Emit(OpCodes.Br, endValueTypeNullLoop); il.MarkLabel(jumpToEnd); } il.MarkLabel(endLoop); il.Emit(OpCodes.Ret); return((ConstructInstance)dynamicMethod.CreateDelegate(typeof(ConstructInstance))); }
public void ProcessInputs_DefaultValues_ThrowsParameterException() { Options input = new Options(); ParameterException e = Assert.ThrowsException <ParameterException>(() => OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object)); Assert.AreEqual("Please specify either processId or processName on the command line", e.Message); VerifyAllMocks(); }
public void ProcessInputs_DefaultValues_ThrowsParameterException() { Options input = new Options(); ParameterException e = Assert.ThrowsException <ParameterException>(() => OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object)); Assert.AreEqual(DisplayStrings.ErrorNoTarget, e.Message); VerifyAllMocks(); }
//param으로부터 값들을 받아 Parameter를 채운다 private FillParamInfoGenerator CreateParamInfoGenerator(object param) { ParameterException.Check(param != null, ParameterError.NotExistParameter); var parameterType = param.GetType(); var propertyInfos = parameterType.GetProperties(); var dynamicMethod = new DynamicMethod("CreateParameterGenerator", null, new[] { typeof(IDbCommand), typeof(object) }); var il = dynamicMethod.GetILGenerator(); var commandIL = il.DeclareLocal(typeof(IDbCommand)); il.Emit(OpCodes.Ldarg_0); //[DbCommand] il.Emit(OpCodes.Stloc, commandIL); //Empty foreach (var property in propertyInfos) { il.Emit(OpCodes.Ldloc, commandIL); //[DbCommand] il.Emit(OpCodes.Callvirt, typeof(IDbCommand).GetProperty(nameof(IDbCommand.Parameters)).GetGetMethod()); //[Parameters] il.Emit(OpCodes.Ldloc, commandIL); //[Parameters][Dbcommand] il.Emit(OpCodes.Callvirt, typeof(IDbCommand).GetMethod(nameof(IDbCommand.CreateParameter))); //[Parameters] [DbParameter] // SetName il.Emit(OpCodes.Dup); //[Parameters][DbParameter][DbParameter] il.Emit(OpCodes.Ldstr, property.Name); //[Parameters][DbParameter][DbParameter][Name] il.Emit(OpCodes.Callvirt, typeof(IDataParameter).GetProperty(nameof(IDbDataParameter.ParameterName)) .GetSetMethod()); //[Parameters][DbParameter] // SetDbType DbType dbType = LookupDbType(property.PropertyType); il.Emit(OpCodes.Dup); //[Parameters][DbParameter][DbParameter] il.Emit(OpCodes.Ldc_I4, (int)dbType); //[Parameters][DbParameter][DbParameter][dbType-num] il.EmitCall(OpCodes.Callvirt, typeof(IDataParameter).GetProperty(nameof(IDataParameter.DbType)).GetSetMethod(), null); //[Parameters][DbParameter] // SetValue il.Emit(OpCodes.Dup); //[Parameters][DbParameter][DbParameter] il.Emit(OpCodes.Ldarg_1); ////[Parameters][DbParameter][DbParameter][object] il.Emit(OpCodes.Call, property.GetGetMethod()); //[Parameters][DbParameter][DbParameter][Value] if (property.PropertyType.IsValueType) { il.Emit(OpCodes.Box, property.PropertyType); //[Parameters][DbParameter][DbParameter][boxed-Value] } il.Emit(OpCodes.Callvirt, typeof(IDataParameter).GetProperty(nameof(IDataParameter.Value)) .GetSetMethod()); //[Parameters][DbParameter] il.Emit(OpCodes.Callvirt, typeof(IList).GetMethod(nameof(IList.Add))); //[int] il.Emit(OpCodes.Pop); } il.Emit(OpCodes.Ret); return((FillParamInfoGenerator)dynamicMethod.CreateDelegate(typeof(FillParamInfoGenerator))); }
public void ProcessIdFromName_GetProcessesThrowsException_ThrowsParameterException() { _processAbstractionMock.Setup(x => x.GetProcessesByName(TestProcessName)) .Throws <ArgumentException>(); ProcessHelper helper = new ProcessHelper(_processAbstractionMock.Object); ParameterException e = Assert.ThrowsException <ParameterException>( () => helper.ProcessIdFromName(TestProcessName)); Assert.AreEqual("Unable to find process with name SomeProcess", e.Message); _processAbstractionMock.VerifyAll(); }
public void ProcessInputs_SpecifiesOverlyLongDelay_ThrowsParameterException() { const int delayInSeconds = 61; Options input = new Options { DelayInSeconds = delayInSeconds }; ParameterException e = Assert.ThrowsException <ParameterException>(() => OptionsEvaluator.ProcessInputs( input, _processHelperMock.Object)); Assert.AreEqual( string.Format(CultureInfo.CurrentCulture, DisplayStrings.ErrorInvalidDelayFormat, delayInSeconds), e.Message); }
public void ProcessIdFromName_GetProcessesReturnsArrayOfTwoElements_ThrowsParameterException() { Process[] processes = new Process[2]; _processAbstractionMock.Setup(x => x.GetProcessesByName(TestProcessName)) .Returns(processes); ProcessHelper helper = new ProcessHelper(_processAbstractionMock.Object); ParameterException e = Assert.ThrowsException <ParameterException>( () => helper.ProcessIdFromName(TestProcessName)); Assert.AreEqual("Found multiple processes with name SomeProcess", e.Message); _processAbstractionMock.VerifyAll(); }
public void ProcessNameFromId_GetProcessByIdReturnsThrowsException_ThrowsParamterException() { Exception expectedException = new MissingMethodException(); _processAbstractionMock.Setup(x => x.GetProcessById(TestProcessId)) .Throws(expectedException); ProcessHelper helper = new ProcessHelper(_processAbstractionMock.Object); ParameterException e = Assert.ThrowsException <ParameterException>( () => helper.ProcessNameFromId(TestProcessId)); Assert.AreEqual("Unable to find process with id -123", e.Message); Assert.AreEqual(expectedException, e.InnerException); _processAbstractionMock.VerifyAll(); }
public async Task <IEnumerable <T> > ReadAllAsync(object param) { DbDataReader reader = null; IEnumerable <T> result = null; bool isClosed = EntityManager.Connection.State == ConnectionState.Closed; ParameterException.Check(param != null, ParameterError.NotExistParameter); DbCommand command = EntityManager.Connection.CreateCommand(); command.CommandText = QueryBuilder.ReadAll(param); command.CommandType = CommandType.Text; if (!ParameterGeneratorCache.ContainsKey(param.GetType())) { ParameterGeneratorCache.Add(param.GetType(), CreateParamInfoGenerator(param)); } var fillParameterGenerator = ParameterGeneratorCache[param.GetType()]; fillParameterGenerator(command, param); var source = new CancellationTokenSource(); var cancelToken = source.Token; var behavior = CommandBehavior.SequentialAccess | CommandBehavior.SingleResult; try { await EntityManager.Connection.OpenAsync().ConfigureAwait(false); reader = await command.ExecuteReaderAsync(GetBehavior(isClosed, behavior), cancelToken) .ConfigureAwait(false); if (!ConstructInstanceCache.ContainsKey(typeof(T))) { ConstructInstanceCache.Add(typeof(T), CreateConstructInstance(reader)); } var constructingInstance = ConstructInstanceCache[typeof(T)]; isClosed = false; result = ExecuteReaderSync(reader, constructingInstance); return(result); } finally { if (isClosed) { EntityManager.Connection.Close(); } } }
public void ProcessInputs_SpecifiesInvalidVerbosity_ThrowsParameterException() { const string verbosity = "Not_A_Valid_Value"; _processHelperMock.Setup(x => x.ProcessIdFromName(TestProcessName)).Returns(TestProcessId); Options input = new Options { ProcessName = TestProcessName, Verbosity = verbosity, }; ParameterException e = Assert.ThrowsException <ParameterException>(() => OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object)); Assert.AreEqual("Invalid verbosity level: Not_A_Valid_Value", e.Message); VerifyAllMocks(); }
internal protected object[] MergeConstructorParameters(InjectionContext context) { object[] result = null; var myParams = context.Parameters; if (_ctorDependencyProviders != null) { if (myParams == null || myParams.Length == 0) { result = new object[_ctorDependencyProviders.Length]; for (var i = 0; i < _ctorDependencyProviders.Length; i++) { _ctorDependencyProviders[i].CreateObject(context, out result[i]); } } else { var paramLength = myParams.Length - 1; if (paramLength > _ctorDependencyProviders.Length - 1) { throw ParameterException.ParameterNumberExceeds(context, _ctorDependencyProviders.Length, myParams.Length); } switch (myParams.ParameterKind) { case ParameterKind.Positional: result = MergePositionalParameters(context, myParams); break; case ParameterKind.Named: result = MergeNamedParameters(context, myParams); break; } } } else { if (myParams != null && myParams.Length > 0) { throw ParameterException.RedundantParametersProvided(context); } } return(result); }
public void DeleteAll(object param) { ParameterException.Check(param != null, ParameterError.NotExistParameter); DbCommand command = EntityManager.Connection.CreateCommand(); command.CommandText = QueryBuilder.DeleteAll(param); command.CommandType = CommandType.Text; if (!ParameterGeneratorCache.ContainsKey(param.GetType())) { ParameterGeneratorCache.Add(param.GetType(), CreateParamInfoGenerator(param)); } var fillParameterGenerator = ParameterGeneratorCache[param.GetType()]; fillParameterGenerator(command, param); EntityManager.Connection.Open(); command.ExecuteNonQuery(); EntityManager.Connection.Close(); }
public void ProcessInputs_SpecifiesInvalidVerbosity_ThrowsParameterException() { const string verbosity = "Not_A_Valid_Value"; _processHelperMock.Setup(x => x.ProcessIdFromName(TestProcessName)).Returns(TestProcessId); Options input = new Options { ProcessName = TestProcessName, Verbosity = verbosity, }; ParameterException e = Assert.ThrowsException <ParameterException>(() => OptionsEvaluator.ProcessInputs(input, _processHelperMock.Object)); Assert.AreEqual( string.Format(CultureInfo.CurrentCulture, DisplayStrings.ErrorInvalidVerbosityFormat, verbosity), e.Message); VerifyAllMocks(); }
public void WriteOutput_ParameterExceptionIsThrown_VerbosityIsQuiet_WritesBannerAndError() { const string errorMessage = "A parameter was bad"; SetOptions(verbosityLevel: VerbosityLevel.Quiet); Exception caughtException = new ParameterException(errorMessage); WriteCall[] expectedCalls = { new WriteCall(AppTitleStart, WriteSource.WriteLineOneParam), new WriteCall(UnableToComplete, WriteSource.WriteStringOnly), new WriteCall(errorMessage, WriteSource.WriteLineStringOnly) }; TextWriterVerifier textWriterVerifier = new TextWriterVerifier(_writerMock, expectedCalls); _testSubject.WriteOutput(_optionsMock.Object, null, caughtException); textWriterVerifier.VerifyAll(); VerifyAllMocks(); }
public void Update(int id, T data) { ParameterException.Check(data != null, ParameterError.NotExistData); DbCommand command = EntityManager.Connection.CreateCommand(); command.CommandText = QueryBuilder.Update(id, data); command.CommandType = CommandType.Text; if (!DataParamGeneratorCache.ContainsKey(data.GetType())) { DataParamGeneratorCache.Add(data.GetType(), CreateDataInfoGenerator(data, id)); } var fillParameterGenerator = DataParamGeneratorCache[data.GetType()]; fillParameterGenerator(command, data, id); EntityManager.Connection.Open(); command.ExecuteNonQuery(); EntityManager.Connection.Close(); }
protected static Exception ParameterNumberExceeds(InjectionContext context, int neededParamNumber, int providedParamNumber) { return(ParameterException.ParameterNumberExceeds(context, neededParamNumber, providedParamNumber)); }
//Parameter의 @id 부분은 id로, 나머지는 data의 값을 채워넣는다 private FillDataInfoGenerator CreateDataInfoGenerator(Object data, int id) { ParameterException.Check(data != null, ParameterError.NotExistData); var type = data.GetType(); var propertyInfos = type.GetProperties(); ColumnInfos = type.GetProperties() .Select(info => new ColumnInfo(info, info.GetCustomAttribute <ColumnAttribute>())) .Where(info => info.ColumnAttribute != null).ToArray(); var primaryKey = ColumnInfos.FirstOrDefault(info => info.PropertyInfo.IsDefined(typeof(PrimaryKeyAttribute))); var dynamicMethod = new DynamicMethod("CreateDataInfoGenerator", null, new[] { typeof(IDbCommand), typeof(object), typeof(int) }); var il = dynamicMethod.GetILGenerator(); var commandIL = il.DeclareLocal(typeof(IDbCommand)); il.Emit(OpCodes.Ldarg_0); //[DbCommand] il.Emit(OpCodes.Stloc, commandIL); //Empty foreach (var property in propertyInfos) { Label isIDProperty = il.DefineLabel(); Label endSetValue = il.DefineLabel(); il.Emit(OpCodes.Ldloc, commandIL); //[DbCommand] il.Emit(OpCodes.Callvirt, typeof(IDbCommand).GetProperty(nameof(IDbCommand.Parameters)).GetGetMethod()); //[Parameters] il.Emit(OpCodes.Ldloc, commandIL); //[Parameters][Dbcommand] il.Emit(OpCodes.Callvirt, typeof(IDbCommand).GetMethod(nameof(IDbCommand.CreateParameter))); //[Parameters] [DbParameter] // SetName il.Emit(OpCodes.Dup); //[Parameters][DbParameter][DbParameter] il.Emit(OpCodes.Ldstr, property.Name); //[Parameters][DbParameter][DbParameter][Name] il.Emit(OpCodes.Callvirt, typeof(IDataParameter).GetProperty(nameof(IDbDataParameter.ParameterName)) .GetSetMethod()); //[Parameters][DbParameter] // SetDbType DbType dbType = LookupDbType(property.PropertyType); il.Emit(OpCodes.Dup); //[Parameters][DbParameter][DbParameter] il.Emit(OpCodes.Ldc_I4, (int)dbType); //[Parameters][DbParameter][DbParameter][dbType-num] il.EmitCall(OpCodes.Callvirt, typeof(IDataParameter).GetProperty(nameof(IDataParameter.DbType)).GetSetMethod(), null); //[Parameters][DbParameter] if (property.Name.ToLower() == primaryKey.Name.ToLower()) { //SetIDValue il.Emit(OpCodes.Dup); //[Parameters][DbParameter][DbParameter] il.Emit(OpCodes.Ldarg_2); //[Parameters][DbParameter][DbParameter][Value] } else { // SetValue il.Emit(OpCodes.Dup); //[Parameters][DbParameter][DbParameter] il.Emit(OpCodes.Ldarg_1); ////[Parameters][DbParameter][DbParameter][object] il.Emit(OpCodes.Call, property.GetGetMethod()); //[Parameters][DbParameter][DbParameter][Value] } if (property.PropertyType.IsValueType) { il.Emit(OpCodes.Box, property.PropertyType); //[Parameters][DbParameter][DbParameter][boxed-Value] } il.Emit(OpCodes.Callvirt, typeof(IDataParameter).GetProperty(nameof(IDataParameter.Value)) .GetSetMethod()); //[Parameters][DbParameter] il.Emit(OpCodes.Callvirt, typeof(IList).GetMethod(nameof(IList.Add))); //[int] il.Emit(OpCodes.Pop); } il.Emit(OpCodes.Ret); return((FillDataInfoGenerator)dynamicMethod.CreateDelegate(typeof(FillDataInfoGenerator))); }