public static void DependencyAttributeTests()
{
var attr1 = new DependencyAttribute("DependentAssembly", LoadHint.Always);
Assert.Equal("DependentAssembly", attr1.DependentAssembly);
Assert.Equal(LoadHint.Always, attr1.LoadHint);
var attr2 = new DependencyAttribute(null, (LoadHint)(-2));
Assert.Null(attr2.DependentAssembly);
Assert.Equal((LoadHint)(-2), attr2.LoadHint);
}
public void ReturnsDependencyParameter()
{
DependencyAttribute attribute = new DependencyAttribute("Foo");
attribute.NotPresentBehavior = NotPresentBehavior.Throw;
IParameter result = attribute.CreateParameter(typeof(object));
DependencyParameter parameter = AssertHelper.IsType <DependencyParameter>(result);
Assert.AreEqual <object>("Foo", parameter.BuildKey);
Assert.AreEqual(NotPresentBehavior.Throw, parameter.NotPresentBehavior);
}
public void DependencyAttributeConstructor()
{
tlog.Debug(tag, $"DependencyAttributeConstructor START");
var testingTarget = new DependencyAttribute(typeof(int));
Assert.IsNotNull(testingTarget, "Can't create success object DependencyAttribute.");
Assert.IsInstanceOf <DependencyAttribute>(testingTarget, "Should return DependencyAttribute instance.");
Assert.IsNotNull(testingTarget.Implementor, "Should not be null");
tlog.Debug(tag, $"DependencyAttributeConstructor END");
}
/// <summary>
///
/// </summary>
/// <param name="il"></param>
/// <param name="paramAttr"></param>
/// <param name="parameterType"></param>
public override void EmitParameterResolution(ILGenerator il, ParameterAttribute paramAttr, Type parameterType)
{
DependencyAttribute attr = (DependencyAttribute)paramAttr;
ConstructorInfo dependencyResolverCtor =
GetConstructor <DependencyResolver>(typeof(IBuilderContext));
MethodInfo resolve = GetMethodInfo <DependencyResolver>("Resolve",
typeof(Type), typeof(Type), typeof(string),
typeof(NotPresentBehavior), typeof(SearchMode));
// Create the dependency resolver object
// Constructor takes context
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Newobj, dependencyResolverCtor);
// Call frame for call to .Resolve
// Actual parameter type
EmitLoadType(il, parameterType);
// Type to create
if (attr.CreateType != null)
{
EmitLoadType(il, attr.CreateType);
}
else
{
il.Emit(OpCodes.Ldnull);
}
// id
if (attr.Name != null)
{
il.Emit(OpCodes.Ldstr, attr.Name);
}
else
{
il.Emit(OpCodes.Ldnull);
}
// NotPresentBehavior
il.Emit(OpCodes.Ldc_I4, (int)attr.NotPresentBehavior);
// SearchMode
il.Emit(OpCodes.Ldc_I4, (int)attr.SearchMode);
// And call it
il.EmitCall(OpCodes.Call, resolve, null);
}
public static void InitializeDependencies(this IMobileObject obj)
{
if (obj == null)
{
throw new ArgumentNullException("Injection of dependencies cannot be performed in a 'null' instance.");
}
IBusinessScope scopedObject = obj as IBusinessScope;
if (scopedObject != null)
{
if (scopedObject.Scope == null)
{
throw new ArgumentNullException("obj", "An instance of IMobileObject that also implements IBusinessScope needs to have the Scope set before you can call InitializeDependencies on it!");
}
scopedObject.ReflectProperties(DPABindingFlags)
.Where(pi => Attribute.IsDefined(pi, typeof(DependencyAttribute)))
.ToList <PropertyInfo>()
.ForEach(pi =>
{
DependencyAttribute atb = pi.GetCustomAttribute <DependencyAttribute>();
if (scopedObject.Scope.IsRegistered(pi.PropertyType))
{
object depPropInstance = scopedObject.Scope.Resolve(pi.PropertyType);
if ((atb.DependencyScope == ResolutionScope.Client || atb.DependencyScope == ResolutionScope.ClientAndServer) && typeof(IDisposable).IsAssignableFrom(depPropInstance.GetType()))
{
IComponentRegistration reg = scopedObject.Scope
.ComponentRegistry
.RegistrationsFor(new TypedService(pi.PropertyType))
.Where(e => e.Ownership == InstanceOwnership.ExternallyOwned).FirstOrDefault();
if (reg == null)
{
throw new ConcreteTypeResolutionException(obj.GetType(), "Did not find a registration for given type.");
}
}
pi.SetValue(obj, depPropInstance);
}
});
}
}
/// <summary>
/// 检查 <paramref name="type"/> 类公共可写属性上的
/// <see cref="DependencyAttribute"/> 标注.
/// 如果找到, 则向容器注册此属性要求依赖注入.
/// </summary>
/// <param name="type"></param>
private void LoadDependencyAttributes(Type type)
{
foreach (PropertyInfo prop in type.GetProperties(
BindingFlags.Public | BindingFlags.SetProperty | BindingFlags.Instance))
{
if (prop.GetIndexParameters().Length == 0 &&
prop.CanWrite &&
prop.IsDefined(typeof(DependencyAttribute), false))
{
DependencyAttribute dep =
(DependencyAttribute)Attribute.GetCustomAttribute(
prop, typeof(DependencyAttribute), false);
_container.RegisterType(type,
new InjectionProperty(prop.Name,
new ResolvedParameter(prop.PropertyType, dep.ResolveName)));
}
}
}
/// <summary>属性注入</summary>
/// <param name="cls"></param>
private void DIAttr(BindData bindData, object cls)
{
if (cls == null)
{
return;
}
string typeName;
foreach (PropertyInfo property in cls.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (!property.CanWrite)
{
continue;
}
object[] propertyAttrs = property.GetCustomAttributes(typeof(DependencyAttribute), true);
if (propertyAttrs.Length <= 0)
{
continue;
}
DependencyAttribute dependency = propertyAttrs[0] as DependencyAttribute;
if (string.IsNullOrEmpty(dependency.Alias))
{
typeName = property.PropertyType.ToString();
}
else
{
typeName = dependency.Alias;
}
if (property.PropertyType.IsClass || property.PropertyType.IsInterface)
{
property.SetValue(cls, ResloveClassAttr(bindData, cls.GetType(), typeName), null);
}
else
{
property.SetValue(cls, ResolveNonClassAttr(bindData, cls.GetType(), typeName), null);
}
}
}
/// <summary>
/// InjectionConstructor 和 InjectionMethod 公用的参数列表分析过程
/// </summary>
/// <param name="method"></param>
/// <returns></returns>
private List <object> BuildMethodParametersInfoList(MethodBase method)
{
List <object> paramList = new List <object>();
foreach (ParameterInfo parameter in method.GetParameters())
{
if (parameter.IsDefined(typeof(DependencyAttribute), false))
{
DependencyAttribute dep = (DependencyAttribute)
Attribute.GetCustomAttribute(
parameter, typeof(DependencyAttribute));
ResolvedParameter p =
new ResolvedParameter(parameter.ParameterType, dep.ResolveName);
paramList.Add(p);
}
else
{
paramList.Add(parameter.ParameterType);
}
}
return(paramList);
}
//disposes the scoped objects ILifetimeScope and sets all dependency properties to null
public static void FinalizeDependencies(this IMobileObject obj)
{
if (obj == null)
{
throw new ArgumentNullException("Object to be processed for dependency injection cannot be 'null'.");
}
IBusinessScope scopedObject = obj as IBusinessScope;
if (scopedObject != null)
{
if (scopedObject.Scope != null)
{
//if the scope is disposed the dependency that was resolved from it will get disposed as well -
//we need to ensure that the dependencies we bring back from the client do NOT implememnt IDisposable
//OR - if they do - we need to ensure that the container was registered to not track the client dependency
//(this happens in the
scopedObject.Scope.Dispose();
scopedObject.Scope = null;
scopedObject.ReflectProperties(DPABindingFlags)
.Where(pi => Attribute.IsDefined(pi, typeof(DependencyAttribute)))
.ToList <PropertyInfo>()
.ForEach(pi =>
{
DependencyAttribute atb = pi.GetCustomAttribute <DependencyAttribute>();
//we only clear out the scoped object if it is only used on the server side
//we checked for IDisposable and made sure that the client side dependency was not being tracked by
//the server side resolution in Autofac when InitializeObject was called so we will be okay to not clear it out
//and do not need to worry about it getting disposed here as well
if (atb.DependencyScope == ResolutionScope.Server)
{
pi.SetValue(scopedObject, null);
}
});
}
}
}
public ScheduledDependencyInjection(string name, DependencyAttribute attribute, Action <PluginBase> injection)
{
Name = name;
Info = attribute;
Inject = injection;
}
static ServiceLifetime?GetLifeTimeOrNull(Type type, DependencyAttribute dependencyAttribute)
{
return(dependencyAttribute?.Lifetime ?? GetServiceLifetimeFromClassHierarcy(type));
}
protected virtual ServiceLifetime?GetLifeTimeOrNull(Type type, [CanBeNull] DependencyAttribute dependencyAttribute)
{
return(dependencyAttribute?.Lifetime ?? GetServiceLifetimeFromClassHierarchy(type) ?? GetDefaultLifeTimeOrNull(type));
}
protected virtual ServiceLifetime?GetLifeTimeOrNull(Type type, DependencyAttribute dependencyAttribute)
{
return(dependencyAttribute.Lifetime ?? GetServiceLifetimeFromCLassHierarcy(type));
}
public static string GetTaskName(DependencyAttribute attribute)
{
return(GetTaskName(attribute.Task));
}
private static Dependency CreateDependency(Type @class, DependencyAttribute attr)
{
return(new Dependency(@class, attr.Supplier, attr.Name));
}
