private Configuration BuildConfig(DatabaseConfiguration databaseConfiguration, IConfiguration config)
{
string fileName = config.Attributes["fileName"];
Configuration cfg;
if (IsNewConfigurationRequired(fileName))
{
using (var fileStream = new FileStream(fileName, FileMode.OpenOrCreate))
{
var fluenty = Fluently.Configure()
.Database(GetDatabase(databaseConfiguration))
.Mappings(m =>
{
foreach (var mapper in kernel.ResolveAll <INHibernateMapper>())
{
mapper.Map(m, databaseConfiguration);
}
m.FluentMappings.Add(typeof(CultureFilter));
});
cfg = fluenty.ExposeConfiguration(ProcessConfiguration).BuildConfiguration().AddProperties(GetNHibernateProperties(databaseConfiguration));
WriteConfigurationToStream(fileStream, cfg);
}
}
else
{
using (var fileStream = new FileStream(fileName, FileMode.OpenOrCreate))
{
cfg = GetConfigurationFromStream(fileStream);
}
}
return(cfg);
}
public CommandPipelineContext Apply(string command,
DbAdvancedOptions options = null)
{
var pipelineFactory = _kernel
.ResolveAll <IPipelineFactory <CommandPipelineContext> >()
.FirstOrDefault(f => f.Aliases.Contains(command));
if (pipelineFactory == null)
{
return(null);
}
var context = new CommandPipelineContext
{
Options = options ?? _kernel.Resolve <DbAdvancedOptions>()
};
var pipeline = pipelineFactory.Create();
if (pipeline == null)
{
return(null);
}
pipelineFactory.Execute(pipeline, context);
return(context);
}
protected void RecordPipelineChannel <TChannel>()
where TChannel : class, IPipeline <T>
{
var pipeline = _kernel.ResolveAll <IPipeline>()
.FirstOrDefault(p => p.GetType() == typeof(TChannel))
as TChannel;
_pipelineChannels.Add(pipeline);
}
public IEnumerable <object> GetAllInstances(Type serviceType)
{
var x = _container.ResolveAll(serviceType, new {});
ArrayList result = new ArrayList();
foreach (var o in x)
{
result.Add(o);
}
return(result.ToArray());
}
private Configuration BuildConfig(DatabaseConfiguration databaseConfiguration)
{
var fluenty = Fluently.Configure()
.Database(GetDatabase(databaseConfiguration))
.Mappings(m =>
{
foreach (var mapper in kernel.ResolveAll <INHibernateMapper>())
{
mapper.Map(m, databaseConfiguration);
}
m.FluentMappings.Add(typeof(CultureFilter)).Conventions.Setup(x => x.Add(AutoImport.Never()));
});
return(fluenty.ExposeConfiguration(ProcessConfiguration).BuildConfiguration().AddProperties(GetNHibernateProperties(databaseConfiguration)));
}
public HouseKeeping(IKernel kernel, InternalConfiguration configuration, Action <string> output)
{
if (kernel == null)
{
throw new ArgumentNullException(nameof(kernel));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
_logger = kernel.Resolve <ILogger>();
_uptime = kernel.Resolve <IUptimeTextGenerator>();
_configuration = configuration;
_output = message => output($"[{this}]: {message}");
_cancellation = new CancellationTokenSource();
TaskScheduler scheduler = TaskScheduler.Current;
IBackgroundServer[] servers = kernel
.ResolveAll <IBackgroundWorker>()
.Select(worker => new BackgroundWorkerServer(worker, scheduler))
.Concat(kernel.ResolveAll <IBackgroundServer>())
.ToArray();
CancellationToken token = kernel.Resolve <IShutdown>().Token;
_heartbeatLogging = CreateHeartbeatLoggingServerHost(_configuration, scheduler, kernel);
_servers = servers
.Select(server => new BackgroundServerHost(server, scheduler, kernel, output))
.Concat(new[] { _heartbeatLogging })
.SkipNulls()
.ToArray();
// To keep track of which servers are actually running.
_isRunning = new HashSet <BackgroundServerHost>();
// Spin off the housekeeping background server
_task = Start(kernel, scheduler, token);
// Keep track of when Housekeeping was started.
_startedAt = Time.UtcNow;
}
public IPipeline Create()
{
var pipeline = _kernel.ResolveAll <IPipeline>()
.FirstOrDefault(p => p.GetType() == PipelineType);
return(pipeline);
}
public IEnumerable <object> GetServices(Type serviceType)
{
var enumerableServiceType = typeof(IEnumerable <>).MakeGenericType(serviceType);
var instance = _container.ResolveAll(enumerableServiceType);
return((IEnumerable <object>)instance);
}
public ScopedMediator(IKernel kernel)
{
_kernel = kernel;
_mediator = new Mediator(
t => kernel.Resolve(t),
t => (IEnumerable <object>)kernel.ResolveAll(t));
}
private void FireServiceBusAware(Action <IServiceBusAware> action)
{
foreach (var aware in kernel.ResolveAll <IServiceBusAware>())
{
action(aware);
}
}
public IEnumerable <IEntity> Read(Stream stream, object context, Func <IPlan, object, bool> filter)
{
var node = _hierarchy.Lookup(context);
var document = new XmlDocument();
document.Load(stream);
if (document.DocumentElement == null)
{
throw new InvalidOperationException("The level data doesn't contain a document element.");
}
// Find the <gameObjectFolder> node under the root element. This is
// the top of our hierarchy.
var gameObjectFolder =
document.DocumentElement.ChildNodes.OfType <XmlElement>()
.FirstOrDefault(x => x.LocalName == "gameObjectFolder");
if (gameObjectFolder == null)
{
throw new InvalidOperationException("No top level game folder found in ATF level.");
}
// Construct the plans for the level.
var plansList = new List <IPlan>();
foreach (var element in gameObjectFolder.ChildNodes.OfType <XmlElement>())
{
ProcessElementToPlan(node, null, element, plansList, 0, filter);
}
// Validate the level configuration.
var plans = plansList.ToArray();
IEnumerable <IEntity> entities = null;
bool isOkay = false;
try
{
_kernel.ValidateAll(plans);
// Resolve all the plans.
entities = _kernel.ResolveAll(plans).OfType <IEntity>();
isOkay = true;
return(entities);
}
finally
{
if (!isOkay)
{
_kernel.DiscardAll(plans);
foreach (var plan in plans)
{
// Also detach the child nodes that were appended to the root object.
_hierarchy.RemoveChildNode(node, (INode)plan);
}
}
}
}
public virtual object Resolve(CreationContext context,
ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
return(_kernel.ResolveAll(GetItemType(dependency.TargetItemType), null));
}
/// <summary>
/// Injects the dependencies.
/// </summary>
/// <param name="kernel">The container.</param>
/// <param name="object">The object to configure.</param>
public static void InjectDependencies(this IKernel kernel, object @object)
{
var resolveCollections = kernel.HasComponent(typeof(CollectionResolver));
foreach (var info in GetDependencyPropertiesFor(@object))
{
var o = info.GetValue(@object, null);
// skip the object is it already contains a value of any sort
if (o != null)
{
continue;
}
else if (resolveCollections && info.PropertyType.IsGenericCollection())
{
o = kernel.ResolveAll(info.PropertyType.GetGenericArguments()[0]);
}
else if ((info.PropertyType.IsInterface) || (info.PropertyType.IsClass))
{
// try to resolve the related type if the component knows it
if (kernel.HasComponent(info.PropertyType))
{
o = kernel.Resolve(info.PropertyType);
}
}
if (o != null)
{
info.SetValue(@object, o, null);
}
}
}
protected virtual ICommandHandler[] ResolveHandlers(ICommand command)
{
var handlerType = typeof(ICommandHandler <>).MakeGenericType(new[] { command.GetType() });
var handlers = _kernel.ResolveAll(handlerType).Cast <ICommandHandler>().ToArray();
return(handlers);
}
public object Resolve(CreationContext context, ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
Type t = dependency.TargetType.GetGenericArguments()[0];
return(kernel.ResolveAll(t, null));
}
public IEnumerable <object> GetServices(Type serviceType)
{
bool hasComponent = _kernel.HasComponent(serviceType);
return(hasComponent
? _kernel.ResolveAll(serviceType).OfType <object>()
: _currentResolverScope.GetServices(serviceType));
}
public ScopedMediator(IKernel kernel)
{
_kernel = kernel;
_mediator = new Mediator(
t => _kernel.Resolve(t),
t => (object[])_kernel.ResolveAll(t)
);
}
public IEnumerable <object> GetServices(Type serviceType)
{
var frameworkServices = DefaultMvcResolver.GetServices(serviceType);
var kernelServices = Kernel.ResolveAll(serviceType);
return((from s in kernelServices.Cast <object>() select s).Union(frameworkServices));
}
public MethodInfoResolver(IKernel container)
{
m_attributeResolverDictionary = new Dictionary <Type, IExistAttributeResolver>();
foreach (var resolver in container.ResolveAll <IExistAttributeResolver>())
{
m_attributeResolverDictionary.Add(resolver.ResolvingAttributeType(), resolver);
}
}
public object Resolve(CreationContext context, ISubDependencyResolver parentResolver, ComponentModel model,
DependencyModel dependency)
{
Type elementType = dependency.TargetType.GetElementType();
Array all = kernel.ResolveAll(elementType, new Hashtable());
return(all);
}
public IEnumerable <object> GetServices(Type serviceType)
{
parentResolver.OnBeforeControllerResolved(kernel, serviceType);
var instances = kernel.ResolveAll(serviceType).Cast <object>();
resolvedInstances.AddRange(instances);
return(instances.ToList());
}
public void Activar <T>(T evento) where T : IDomainEvent
{
var manejadores = _kernel.ResolveAll <IManejadorDeEvento <T> >();
foreach (var manejador in manejadores)
{
manejador.Ejecutar(evento);
}
}
private Array GetRegisteredHandler(Type handlerType)
{
if (!_castleRegisteredHandlers.TryGetValue(handlerType, out var array))
{
array = _kernel.ResolveAll(handlerType);
_castleRegisteredHandlers[handlerType] = array;
}
return(array);
}
public object Resolve(CreationContext context,
ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
var targetType = dependency.TargetType.GetElementType();
var resolved = _kernel.ResolveAll(targetType, null);
return(resolved);
}
/// <summary>
/// Intercepts the parameter for eveyr registered <see cref="IParameterInterceptor"/>
/// </summary>
/// <param name="paramInfo">The reflection info for the parameter</param>
/// <param name="paramValue">The raw parameter value</param>
private void InterceptParameter(ParameterInfo paramInfo, object paramValue)
{
foreach (var paramInterceptor in kernel.ResolveAll <IParameterInterceptor>())
{
if (paramInterceptor.Accept(paramInfo))
{
paramInterceptor.Intercept(paramInfo, paramValue);
}
}
}
public virtual object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
Array result = kernel.ResolveAll(GetItemType(dependency.TargetItemType), null);
if (_orderFunc != null)
{
Array.Sort(result, new GenericComparer(_orderFunc));
}
return(result);
}
public IEnumerable <object> GetServices(Type serviceType)
{
var resolveAll = _kernel.ResolveAll(serviceType);
foreach (var service in resolveAll)
{
_resolvedServices.Add(service);
}
return(resolveAll.Cast <object>());
}
internal static IRegistration RegisterComponentWithCollectionFor <TBase, TImplementation, TCollectionItemBase>(this IKernel containerKernel, bool asSingleton)
where TBase : class
where TImplementation : class, TBase
{
var ctorArgs = new object[]
{
containerKernel.ResolveAll <TCollectionItemBase>()
};
return(RegisterComponentForCore <TBase, TImplementation>(asSingleton, ctorArgs));
}
public IEnumerable <object> GetServices(Type serviceType)
{
IEnumerable <object> services = _defaultResolver.GetServices(serviceType);
if (services == null && _kernel.HasComponent(serviceType))
{
return(_kernel.ResolveAll(serviceType).OfType <object>());
}
return(services);
}
internal static bool TryResolveAll(this IKernel kernel, Type serviceType, out IEnumerable <object> result)
{
result = new object[0];
if (kernel.HasComponent(serviceType))
{
result = kernel.ResolveAll(serviceType).Cast <object>().ToArray();
}
return(result.Any());
}
public override object Resolve(IKernel kernel)
{
var service = GetCollectionItemType();
var result = kernel.ResolveAll(service, AdditionalArguments);
if (service == typeof(object))
{
return result;
}
var array = Array.CreateInstance(service, result.Length);
result.CopyTo(array, 0);
return array;
}
private static IConversationFactory CreateConversationFactory(IKernel kernel)
{
return new NHibernateConversationFactory(kernel.ResolveAll<ISessionFactory>());
}
public override object Resolve(IKernel kernel)
{
var service = GetCollectionItemType();
var result = kernel.ResolveAll(service, AdditionalArguments);
return result;
}
public override object Resolve(IKernel kernel)
{
var result = kernel.ResolveAll(ComponentType, AdditionalArguments);
return result;
}
