/// <summary>
/// 根据泛型T进行依赖解析
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="regName"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public T Resolve <T>(string regName = null, params KeyValuePair <string, object>[] parameters)
where T : class
{
Autofac.ILifetimeScope scope = this._lifetimeScop.GetScope(this._container);
if (null != parameters && parameters.Length > 0)
{
List <Autofac.Core.Parameter> paramList = new List <Autofac.Core.Parameter>();
foreach (var item in parameters)
{
paramList.Add(new NamedParameter(item.Key, item.Value));
}
if (string.IsNullOrEmpty(regName))
{
return(scope.Resolve <T>(paramList));
}
else
{
return(scope.ResolveNamed <T>(regName, paramList));
}
}
else
{
if (string.IsNullOrEmpty(regName))
{
return(scope.Resolve <T>());
}
else
{
return(scope.ResolveNamed <T>(regName));
}
}
}
/// <summary>
/// 解析未注册的类型
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public object ResolveUnregistered(Type type)
{
Autofac.ILifetimeScope scope = this._lifetimeScop.GetScope(this._container);
var constructors = type.GetConstructors();
foreach (var constructor in constructors)
{
try
{
var parameters = constructor.GetParameters();
var parameterInstances = new List <object>();
foreach (var parameter in parameters)
{
var service = scope.Resolve(parameter.ParameterType);
if (service == null)
{
throw new Exception(string.Format("未知的参数类型{0}",
parameter.ParameterType));
}
parameterInstances.Add(service);
}
return(Activator.CreateInstance(type, parameterInstances.ToArray()));
}
catch
{
continue;
}
}
throw new Exception("未发现满足依赖解析的构造函数");
}
static void Main(string[] args)
{
using (Autofac.ILifetimeScope scope = Ioc.ObjectFactory.Container.BeginLifetimeScope())
{
var credential = scope.Resolve <ICredentialHandler>();
consoleMessage();
var key = Console.ReadKey();
while (key.Key != ConsoleKey.Escape)
{
switch (key.KeyChar)
{
case 'u':
case 'U':
generatePassword(credential);
goto default;
case 'v':
case 'V':
validatePassword(credential);
break;
default:
consoleMessage();
break;
}
key = Console.ReadKey();
}
}
}
/// <summary>
/// 根据泛型T进行依赖解析
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="parameters"></param>
/// <returns></returns>
public T[] ResolveAll <T>(params KeyValuePair <string, object>[] parameters)
{
Autofac.ILifetimeScope scope = this._lifetimeScop.GetScope(this._container);
if (null != parameters && parameters.Length > 0)
{
List <Autofac.Core.Parameter> paramList = new List <Autofac.Core.Parameter>();
foreach (var item in parameters)
{
paramList.Add(new NamedParameter(item.Key, item.Value));
}
return(scope.Resolve <IEnumerable <T> >(paramList).ToArray());
}
else
{
return(scope.Resolve <IEnumerable <T> >().ToArray());
}
}
public SmallCrmFixture()
{
Container = ServiceRegistrator.GetContainer().BeginLifetimeScope();
DbContext = Container.Resolve <SmallCrmDbContext>();
}
public TModelFactory CreateViewModel <TModelFactory>(Type t) where TModelFactory : class
{
var cacheKey = new VMCacheKey(t, typeof(TModelFactory));
if (_viewModelFactoryCache.ContainsKey(cacheKey))
{
return((TModelFactory)_viewModelFactoryCache[cacheKey]);
}
if (t == null)
{
throw new ArgumentNullException("t");
}
// try to resolve factory if t is not such a factory
if (!typeof(Delegate).IsAssignableFrom(t))
{
t = ResolveFactory(t);
// throw an exception if t is still not a factory
if (t == null || !typeof(Delegate).IsAssignableFrom(t))
{
throw new ArgumentOutOfRangeException("t", "Parameter must be a Delegate. CreateViewModel uses Autofac's Factory pattern");
}
}
try
{
if ((++_resolveCounter % 100) == 0)
{
Logging.Log.WarnFormat("CreateViewModel was called {0} times", _resolveCounter);
}
var factory = Container.Resolve(t);
if (t != typeof(TModelFactory))
{
if ((++_resolveCompileCounter % 100) == 0)
{
Logging.Log.WarnFormat("CreateViewModel with compiling a lambda was called {0} times", _resolveCompileCounter);
}
// Wrap delegate. This will implement inheritance
Delegate factoryDelegate = (Delegate)factory;
// Get Parameter of both, src and dest delegate
var parameter_factory = factoryDelegate.Method.GetParameters().Skip(1).ToArray();
var parameter = typeof(TModelFactory).GetMethod("Invoke").GetParameters()
.Select(p => Expression.Parameter(p.ParameterType, p.Name)).ToArray();
// create cast expressions. Sometimes a UpCast is needed.
// TModelFactory == DataTypeViewModel
// typeof(factory) == ObjectClassViewModel
// TODO: check that the parameter types can match at all
// this is necessary to create proper errors when Factory delegates
// are out of sync
var invoke = Expression.Invoke(Expression.Constant(factoryDelegate),
parameter.Select(
(p, idx) => Expression.Convert(p, parameter_factory[idx].ParameterType)
).ToArray()
);
var l = Expression.Lambda(typeof(TModelFactory), invoke, parameter);
factory = l.Compile() as TModelFactory;
}
_viewModelFactoryCache[cacheKey] = factory;
return((TModelFactory)factory);
}
catch (Exception ex)
{
Logging.Log.Error(string.Format("Unable to create type {0}", t.FullName), ex);
throw;
}
}
protected override void RequestStartup(Autofac.ILifetimeScope container, Nancy.Bootstrapper.IPipelines pipelines, NancyContext context)
{
TokenAuthentication.Enable(pipelines, new TokenAuthenticationConfiguration(container.Resolve<ITokenizer>()));
pipelines.AfterRequest.AddItemToEndOfPipeline(AddCorsHeaders());
pipelines.OnError.AddItemToEndOfPipeline((ctx, err) =>
HandleExceptions(err, ctx)
);
base.RequestStartup(container, pipelines, context);
}
