public void NotifyWireupTask(IWireupCoordinator coordinator, WireupTaskAttribute task, Type target)
{
var cra = task as DTOAttribute;
if (cra != null && target != null)
{
var concreteMethod = ConcreteTypeMethod.MakeGenericMethod(target);
var concrete = (Type)concreteMethod.Invoke(null, null);
var reg = RegisterMethod.MakeGenericMethod(target, concrete);
reg.Invoke(FactoryProvider.Factory, null);
}
}
public void Register_ShouldThrowWhenClassDoesNotImplementGivenInterface(RegisterMethod registerMethod)
{
// Arrange
var typesProvider = Substitute.For <ITypesProvider>();
typesProvider.GetTypes().Returns(new[] { typeof(IDummyClassImplementingInterface).GetTypeInfo(), typeof(DummyClassNotImplementingInterface).GetTypeInfo() });
var serviceRegistrator = new ServiceRegistrator(typesProvider);
// Act
// Assert
Assert.That(() => Register(serviceRegistrator, (toImplement, implementation) => { }, registerMethod),
Throws.InstanceOf <RegistrationException>());
}
public void Register_ShouldThrowWhenClassDeclaredToImplementDerivingClass(RegisterMethod registerMethod)
{
// Arrange
var typesProvider = Substitute.For <ITypesProvider>();
typesProvider.GetTypes().Returns(new[] { typeof(DummyClassDeclaringImplementationOfDerivingClass).GetTypeInfo(), typeof(DummyClass4).GetTypeInfo() });
var serviceRegistrator = new ServiceRegistrator(typesProvider);
// Act
// Assert
Assert.That(() => Register(serviceRegistrator, (toImplement, implementation) => { }, registerMethod),
Throws.InstanceOf <RegistrationException>());
}
// Function to get instance of type if there is
// cached one.
public object TryGetInstance(Type type)
{
if (methodMap.ContainsKey(type))
{
methodMap[type] = RegisterMethod.MethodInstance;
RegisterMethod m = methodMap[type];
if (m == RegisterMethod.MethodInstance)
{
return(instances[type]);
}
else if (m == RegisterMethod.MethodSingleton)
{
return(GetSingleton(type));
}
}
return(null);
}
public ActionResult Register1(RegisterViewpage register, string Code)
{
IRegister Ir = new RegisterMethod();
string message = Ir.CheckRegister(register);
string checkcode = Session["CheckCode"].ToString().ToLower();
if (message == "注册成功")
{
if (checkcode != Code.ToString().ToLower())
{
return(Json("验证码错误！"));
}
else
{
Ir.Add(register);
}
}
return(Json(message));
}
public void Register_ShouldProcessTypeWithProperAttributeForDerivingClass(RegisterMethod registerMethod)
{
// Arrange
var dummyClassRegisteredCount = 0;
var typesProvider = Substitute.For <ITypesProvider>();
typesProvider.GetTypes().Returns(new[] { typeof(DummyClass2).GetTypeInfo(), typeof(DummyClass3).GetTypeInfo() });
void RegisterStub(Type toImplement, Type implementation)
{
if (implementation == typeof(DummyClass3) && toImplement == typeof(DummyClass2))
{
dummyClassRegisteredCount++;
}
}
var serviceRegistrator = new ServiceRegistrator(typesProvider);
// Act
Register(serviceRegistrator, RegisterStub, registerMethod);
// Assert
Assert.That(dummyClassRegisteredCount, Is.EqualTo(1));
}
private object ResolveConcType(Type type)
{
bool singleton = false;
// If there is type in list alredy, cycle is detecded.
if (pathToResolve.Contains(type))
{
throw new DependencyCycleException();
}
pathToResolve.Add(type);
if (methodMap.ContainsKey(type))
{
RegisterMethod m = methodMap[type];
switch (m)
{
case RegisterMethod.MethodType:
break;
case RegisterMethod.MethodInstance:
pathToResolve.Remove(type);
return(instances[type]);
case RegisterMethod.MethodSingleton:
singleton = true;
break;
default:
break;
}
}
var resolve = ResolveType(type);
if (instances.ContainsKey(type))
{
if (singleton && instances[type] != null)
{
pathToResolve.Remove(type);
return(instances[type]);
}
}
var constructors = resolve.GetConstructors();
if (constructors.Length < 1)
{
if (resolve.IsValueType)
{
pathToResolve.Remove(type);
return(Activator.CreateInstance(resolve));
}
else
{
throw new DependencyTypeException(resolve);
}
}
var constructor = constructors[0];
FindConstructor(ref constructors, ref constructor);
var parameters = constructor.GetParameters();
List <object> resolvedParameters = new List <object>();
FillParameterList(ref parameters, ref resolvedParameters);
// Throw exception when not all parameters are resolved.
if (parameters.Length != resolvedParameters.Count)
{
throw new DependencyTypeException(resolve);
}
object result = constructor.Invoke(resolvedParameters.ToArray());
if (singleton)
{
instances[type] = result;
}
var properties = resolve.GetProperties();
ResolveDependencyProperties(ref result, ref properties);
var methods = resolve.GetMethods();
ResolveDependencyMethods(ref result, ref methods);
pathToResolve.Remove(type);
return(result);
}
public static void RegisterCommandHandlers(Type controlType, bool acceptsRichContent, bool readOnly, bool registerEventListeners)
{
RegisterMethod.Invoke(null, new object[] { controlType, acceptsRichContent, readOnly, registerEventListeners });
}
public void Register(FluentPerCharacterSettings settings) => RegisterMethod?.Invoke(Object, new object[] { settings });
private static void Register(ServiceRegistrator registrator, Action <Type, Type> registrationStub, RegisterMethod registerMethod)
{
switch (registerMethod)
{
case RegisterMethod.Singleton:
registrator.RegisterSingletons(registrationStub);
return;
case RegisterMethod.Transient:
registrator.RegisterTransient(registrationStub);
return;
default:
throw new ArgumentOutOfRangeException("Not supported method!");
}
}
public void Register(FluentGlobalSettings settings) => RegisterMethod?.Invoke(Object, new object[] { settings });