protected virtual void SetDependency<TResolvingInterface, TGenericInterface>
(ContainerBuilder builder
, IContainer Container
, IList<Type> DepTypes
, EnumServiceTypes sPosfix
, IConfigOptions opts
)
{
SetDependency<TResolvingInterface, TResolvingInterface, TGenericInterface>
(builder
, Container
, DepTypes
, sPosfix
, opts
);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sName"></param>
/// <returns></returns>
private static T GetServiceType <T>(string sName = "", EnumServiceTypes postFix = null)
where T : class, IFilter
{
T handler = default(T);
try
{
string typeNameResolve = typeof(T).Name.Substring(1);
//check if type is register
// if not then resolve thru type name
if (String.IsNullOrEmpty(sName))
{
if (EngineContext
.Current
.ContainerManager
.IsRegistered(typeof(T)))
{
handler = HandlerResolve.Resolve <T>(AllowNull: true);
}
}
else
{
typeNameResolve = CommonUtil.GetResolveName(typeof(T), sName, postFix);
handler = GetFilterByName <T>(typeNameResolve) as T;
}
if (handler == null)
{
throw new NullReferenceException("Unable to resolve type with service locator; type " + typeof(T).Name);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
return(handler as T);
}
//public static void SetResolveNameFlag(ResolveDepName resolveName)
//{
// if (resolveName == ResolveDepName.YES)
// ResolveDepencyName = true;
//}
// public static string ResolveRuleName(string prefix, Type t)
// {
// }
public static string GetResolveName(Type t
, string Name = ""
, EnumServiceTypes postFix = null
, IConfigOptions Opts = default(IConfigOptions))
{
string TypeName = t.Name;
if (!string.IsNullOrEmpty(Name))
{
TypeName = Name;
}
else
if (t.IsInterface)
{
TypeName = TypeName.Substring(1);
}
//if (!ResolveDepencyName && !(Opts != null
// && Opts
// .Contains(enumConfigOpts.ForceNameResolve))
// )
// return TypeName;
string name;
var temp = t.FullName.Split('.');
if (postFix != null)
{
name = temp.First();
}
else
{
name = string.Join(".", temp.Take(temp.Length - 1));
}
string sreturn = string.Empty;
var Typeprefix = String
.Join(".",
t.FullName.Split('.')
.DefaultIfEmpty(".")
.Take(2));
// return prefix + '.' + TypeName;
//need only dll base assm name & service type name
var compare = String.Join(".", name.Split('.').Take(2));
if (TypeName.Split('.').Length > 2)
{
sreturn = TypeName;
}
else
if (compare.Contains(Typeprefix))
{
sreturn = Typeprefix + '.' + TypeName;
}
else
{
sreturn = name + "." + (postFix == null ? "" : postFix + ".") + TypeName;
}
return(sreturn);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TNamedInterface"></typeparam>
/// <typeparam name="TResolvingInterface"></typeparam>
/// <typeparam name="TGenericInterface"></typeparam>
/// <param name="builder"></param>
/// <param name="Container"></param>
/// <param name="DepTypes"></param>
/// <param name="sPosfix"></param>
protected virtual void SetDependency<TNamedInterface
, TResolvingInterface
, TGenericInterface>
(
ContainerBuilder builder
, IContainer Container
, IList<Type> DepTypes
, EnumServiceTypes sPosfix
, IConfigOptions options
)
{
var assm = String.Join("|", IgnoreAssemblies) + "Unknown"; //needed for test ing
var regtype = DepTypes
.Where(t => (typeof(TResolvingInterface).IsAssignableFrom(t)
|| IsAssignableFrom(t, typeof(TNamedInterface)))
&& !(t.IsInterface
|| t.IsGenericType
|| t.IsAbstract
|| t.IsSealed
)
&& ! t.GetCustomAttributes(typeof(NoServiceResolveAtrribute), true)
.Any()
&& !Regex.IsMatch(t.Assembly.FullName, assm))
.ToList();
regtype.Select(map => new
{
target = map
,source = GetGenericInterfaceType<TGenericInterface>(map)
})
.ToList()
.ForEach(f => {
string infaceName = String.Empty;
var intfaceName = f
.target
.GetInterfaces()
.Where(g => g.Name.ToLower().Substring(1)
== f.target.Name.ToLower())
.FirstOrDefault();
if (intfaceName != null)
infaceName =intfaceName.Name.Substring(1);
var name = CommonUtil
.GetResolveName(f.target
, Name: infaceName
, postFix: sPosfix
, Opts: options);
#if DI_UNITY
if (!Container.IsRegistered<TNamedInterface>(name))
Container
.RegisterType(f.source,f.target, name);
#else
if (!Container.IsRegisteredWithName<TNamedInterface>(name))
BuildAndScope<TNamedInterface>(builder,f.target,name);
}
);
}
