public override object Resolve(CreationContext context)
{
HttpContext current = HttpContext.Current;
if (current == null)
throw new InvalidOperationException(
"HttpContext.Current is null. PerWebRequestLifestyle can only be used in ASP.Net");
if (current.Items[PerRequestObjectID] == null)
{
if (!PerWebRequestLifestyleModule.Initialized)
{
string message = "Looks like you forgot to register the http module " +
typeof(PerWebRequestLifestyleModule).FullName +
"\r\nAdd '<add name=\"PerRequestLifestyle\" type=\"Castle.MicroKernel.Lifestyle.PerWebRequestLifestyleModule, Castle.MicroKernel\" />' " +
"to the <httpModules> section on your web.config";
throw new ConfigurationErrorsException(message);
}
object instance = base.Resolve(context);
current.Items[PerRequestObjectID] = instance;
PerWebRequestLifestyleModule.RegisterForEviction(this, instance);
}
return current.Items[PerRequestObjectID];
}
public object Resolve(CreationContext context,
ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
return _kernel.ResolveAll(dependency.TargetType.GetElementType(), null);
}
protected IHandler GetSubHandler(CreationContext context, Type genericType)
{
lock(type2SubHandler)
{
IHandler handler;
if (type2SubHandler.ContainsKey(genericType))
{
handler = type2SubHandler[genericType];
}
else
{
Type service = ComponentModel.Service.MakeGenericType(context.GenericArguments);
ComponentModel newModel = Kernel.ComponentModelBuilder.BuildModel(
ComponentModel.Name, service, genericType, null);
newModel.ExtendedProperties[ComponentModel.SkipRegistration] = true;
Kernel.AddCustomComponent(newModel);
handler = Kernel.HandlerFactory.Create(newModel);
type2SubHandler[genericType] = handler;
}
return handler;
}
}
protected override object Instantiate(CreationContext context)
{
String factoryId = (String)Model.ExtendedProperties["factoryId"];
String factoryCreate = (String)Model.ExtendedProperties["factoryCreate"];
if (!Kernel.HasComponent(factoryId))
{
String message = String.Format("You have specified a factory ('{2}') " +
"for the component '{0}' {1} but the kernel does not have this " +
"factory registered",
Model.Name, Model.Implementation.FullName, factoryId);
throw new FacilityException(message);
}
IHandler factoryHandler = Kernel.GetHandler(factoryId);
// Let's find out whether the create method is a static or instance method
Type factoryType = factoryHandler.ComponentModel.Implementation;
MethodInfo staticCreateMethod =
factoryType.GetMethod(factoryCreate,
BindingFlags.Public | BindingFlags.Static);
if (staticCreateMethod != null)
{
return Create(null, factoryId, staticCreateMethod, factoryCreate, context);
}
else
{
object factoryInstance = Kernel[factoryId];
MethodInfo instanceCreateMethod =
factoryInstance.GetType().GetMethod(factoryCreate,
BindingFlags.Public | BindingFlags.Instance);
if (instanceCreateMethod == null)
{
factoryInstance = ProxyUtil.GetUnproxiedInstance(factoryInstance);
instanceCreateMethod =
factoryInstance.GetType().GetMethod(factoryCreate,
BindingFlags.Public | BindingFlags.Instance);
}
if (instanceCreateMethod != null)
{
return Create(factoryInstance, factoryId, instanceCreateMethod, factoryCreate, context);
}
else
{
String message = String.Format("You have specified a factory " +
"('{2}' - method to be called: {3}) " +
"for the component '{0}' {1} but we couldn't find the creation method" +
"(neither instance or static method with the name '{3}')",
Model.Name, Model.Implementation.FullName, factoryId, factoryCreate);
throw new FacilityException(message);
}
}
}
public override object Resolve(CreationContext context)
{
var current = HttpContext.Current;
if (current == null)
throw new InvalidOperationException(
"HttpContext.Current is null. PerWebRequestLifestyle can only be used in ASP.Net");
if (current.Items[PerRequestObjectID] == null)
{
if (!PerWebRequestLifestyleModule.Initialized)
{
var message =
string.Format(
"Looks like you forgot to register the http module {0}{1}Add '<add name=\"PerRequestLifestyle\" type=\"Castle.MicroKernel.Lifestyle.PerWebRequestLifestyleModule, Castle.Windsor\" />' to the <httpModules> section on your web.config",
typeof(PerWebRequestLifestyleModule).FullName, Environment.NewLine);
throw new Exception(message);
}
var instance = base.Resolve(context);
current.Items[PerRequestObjectID] = instance;
PerWebRequestLifestyleModule.RegisterForEviction(this, instance);
}
return current.Items[PerRequestObjectID];
}
/// <inheritdoc />
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, Castle.Core.ComponentModel model, DependencyModel dependency)
{
if (dependency.TargetType == null)
{
return false;
}
Type genericArgument = null;
if ((dependency.TargetType.IsGenericType) && (dependency.TargetType.GetGenericTypeDefinition() == typeof(IEnumerable<>)))
{
genericArgument = dependency.TargetType.GetGenericArguments()[0];
}
else
{
dependency.TargetType.GetInterfaces().Any(implemented => (implemented.IsGenericType) && (implemented.GetGenericTypeDefinition() == typeof(IEnumerable<>)) &&
((genericArgument = implemented.GetGenericArguments()[0]) != null));
}
if ((genericArgument == null) || (!_kernel.HasComponent(genericArgument)))
{
return false;
}
return true;
}
protected override object Instantiate(CreationContext context)
{
String accessor = (String)Model.ExtendedProperties["instance.accessor"];
PropertyInfo pi = Model.Implementation.GetProperty(
accessor, BindingFlags.Public | BindingFlags.Static);
if (pi == null)
{
String message = String.Format("You have specified an instance accessor " +
"for the component '{0}' {1} which could not be found (no public " +
"static property has this name)", Model.Name, Model.Implementation.FullName);
throw new FacilityException(message);
}
if (!pi.CanRead)
{
String message = String.Format("You have specified an instance accessor " +
"for the component '{0}' {1} which is write-only",
Model.Name, Model.Implementation.FullName);
throw new FacilityException(message);
}
try
{
return pi.GetValue(null, new object[0]);
}
catch (Exception ex)
{
String message = String.Format("The instance accessor " +
"invocation failed for '{0}' {1}",
Model.Name, Model.Implementation.FullName);
throw new FacilityException(message, ex);
}
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
return dependency.TargetType == typeof(IBookStore) && contextHandlerResolver.CanResolve(context, contextHandlerResolver, model,
new DependencyModel(typeof(IBookStore).FullName,
typeof(IBookStore), false));
}
public override object Resolve(CreationContext context)
{
var store = GetStore();
var instance = base.Resolve(context);
if (instance == null)
{
if (context.Handler.ComponentModel.ExtendedProperties[Constants.REG_IS_INSTANCE_KEY] != null)
{
throw new DependencyResolutionException("Cannot find the instance in the context store.");
}
}
else if (store[Model.Name] == null)
{
store[Model.Name] = instance;
store.GetContextInstances().Add(new ContextStoreDependency(Model.Name, instance, this));
_isRegisteredForCleanup = true;
}
if (!_isRegisteredForCleanup)
{
store.GetContextInstances().Add(new ContextStoreDependency(Model.Name, instance, this));
_isRegisteredForCleanup = true;
}
return store[Model.Name];
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
string componentName = null;
if (!_knownDependencies.ContainsKey(dependency))
componentName = dependency.DependencyKey;
return _kernel.Resolve(componentName, dependency.TargetType);
}
private static IMicrosoftStorageConfig GetAzureServiceConfig(IKernel k, ComponentModel cm, CreationContext cc)
{
var serviceConfig = new DefaultAzureServiceConfigurationProvider(k.Resolve<IAppConfigSettings>()).GetConfigRaw();
var webConfig = serviceConfig["Web"];
return new DictionaryAdapterFactory().GetAdapter<IMicrosoftStorageConfig>(webConfig);
}
/// <summary>
/// Creates the <see cref="ISessionFactory"/> from the configuration
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override object Create(CreationContext context)
{
RaiseCreatingSessionFactory();
var configuration = Model.ExtendedProperties[Constants.SessionFactoryConfiguration]
as Configuration;
return configuration.BuildSessionFactory();
}
/// <summary>
/// Source: http://www.symbolsource.org/Public/Metadata/NuGet/Project/Castle.Windsor/3.0.0.3001/Release/.NETFramework,Version%3Dv4.0,Profile%3DClient/Castle.Windsor/Castle.Windsor/MicroKernel/ComponentActivator/DefaultComponentActivator.cs?ImageName=Castle.Windsor
/// </summary>
/// <param name="instance"></param>
/// <param name="context"></param>
protected override void SetUpProperties(object instance, CreationContext context)
{
instance = ProxyUtil.GetUnproxiedInstance(instance);
var resolver = Kernel.Resolver;
foreach (var property in Model.Properties)
{
var value = ObtainPropertyValue(context, property, resolver);
if (value == null)
{
continue;
}
var setMethod = property.Property.GetSetMethod();
try
{
setMethod.Invoke(instance, new[] { value });
}
catch (Exception ex)
{
var message =
String.Format(
"Error setting property {1}.{0} in component {2}. See inner exception for more information. If you don't want Windsor to set this property you can do it by either decorating it with {3} or via registration API.",
property.Property.Name, instance.GetType().Name, Model.Name, typeof(DoNotWireAttribute).Name);
throw new ComponentActivatorException(message, ex, Model);
}
}
}
protected override object CreateInstance(CreationContext context, ConstructorCandidate constructor, object[] arguments)
{
var commandHandler = base.CreateInstance(context, constructor, arguments);
var result = chainBuilder.BuildChain(commandHandler);
return result;
}
public virtual object Request(CreationContext context)
{
object instance;
using(rwlock.ForWriting())
{
if (available.Count != 0)
{
instance = available.Pop();
if (instance == null)
{
throw new PoolException("Invalid instance on the pool stack");
}
}
else
{
instance = componentActivator.Create(context);
if (instance == null)
{
throw new PoolException("Activator didn't return a valid instance");
}
}
inUse.Add(instance);
}
return instance;
}
public override object Resolve(CreationContext context)
{
lock(slot)
{
Hashtable map = (Hashtable) Thread.GetData( slot );
if (map == null)
{
map = new Hashtable();
Thread.SetData( slot, map );
}
Object instance = map[ ComponentActivator ];
if ( instance == null )
{
instance = base.Resolve(context);
map.Add( ComponentActivator, instance );
instances.Add( instance );
}
return instance;
}
}
public override object Resolve(CreationContext context)
{
lock(slot)
{
var map = (Dictionary<IComponentActivator, object>)Thread.GetData(slot);
if (map == null)
{
map = new Dictionary<IComponentActivator, object>();
Thread.SetData( slot, map );
}
Object instance;
if (!map.TryGetValue(ComponentActivator, out instance))
{
instance = base.Resolve(context);
map.Add(ComponentActivator, instance);
instances.Add(instance);
}
return instance;
}
}
public object Resolve(
CreationContext context,
ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
MockingStrategy strategy = _relatedRepository.GetStrategyFor(dependency);
if (strategy.Instance != null)
return strategy.Instance;
if (strategy.Mock == MockingStrategyType.Mock)
{
//if a dependencywas already registered in the main controller, go and use it
var registration = this._relatedRepository.Kernel.GetHandler(dependency.TargetType);
object resolvedDependencyObject;
if (registration == null)
{
resolvedDependencyObject = MockRepository.GenerateStub(dependency.TargetType);
}
else
{
resolvedDependencyObject = _relatedRepository.Resolve(dependency.TargetType);
}
_relatedRepository.OnMockCreated(resolvedDependencyObject, dependency.DependencyKey);
return resolvedDependencyObject;
}
if (strategy.Mock == MockingStrategyType.Resolve)
return _relatedRepository.Resolve(dependency.TargetType);
return null;
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
return contextHandlerResolver.Resolve(context, contextHandlerResolver, model,
new DependencyModel(DependencyType.Service, typeof(IBookStore).FullName,
typeof(IBookStore), false));
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return dependency.TargetType != null &&
dependency.TargetType.IsArray &&
dependency.TargetType.GetElementType().IsInterface &&
!model.Parameters.Contains(dependency.DependencyKey);
}
protected IHandler GetSubHandler(CreationContext context, Type genericType)
{
lock (type2SubHandler)
{
IHandler handler;
if (type2SubHandler.ContainsKey(genericType))
{
handler = type2SubHandler[genericType];
}
else
{
Type service = ComponentModel.Service.MakeGenericType(context.GenericArguments);
ComponentModel newModel = Kernel.ComponentModelBuilder.BuildModel(
ComponentModel.Name, service, genericType, null);
newModel.ExtendedProperties[ComponentModel.SkipRegistration] = true;
CloneParentProperties(newModel);
// Create the handler and add to type2SubHandler before we add to the kernel.
// Adding to the kernel could satisfy other dependencies and cause this method
// to be called again which would result in extra instances being created.
handler = Kernel.HandlerFactory.Create(newModel);
type2SubHandler[genericType] = handler;
Kernel.AddCustomComponent(newModel);
}
return handler;
}
}
/// <summary>
/// Obtains the interceptors associated with the component.
/// </summary>
/// <param name="kernel">The kernel instance</param>
/// <param name="model">The component model</param>
/// <param name="context">The creation context</param>
/// <returns>interceptors array</returns>
protected IInterceptor[] ObtainInterceptors(IKernel kernel, ComponentModel model, CreationContext context)
{
var interceptors = new List<IInterceptor>();
foreach (IReference<IInterceptor> interceptorRef in GetInterceptorsFor(model))
{
try
{
var interceptor = interceptorRef.Resolve(kernel, context);
SetOnBehalfAware(interceptor as IOnBehalfAware, model);
interceptors.Add(interceptor);
}
catch (Exception e)
{
foreach (var interceptor in interceptors)
{
kernel.ReleaseComponent(interceptor);
}
if(e is InvalidCastException)
{
var message = String.Format(
"An interceptor registered for {0} doesn't implement the {1} interface",
model.Name, typeof(IInterceptor).Name);
throw new DependencyResolverException(message);
}
throw;
}
}
return interceptors.ToArray();
}
public override object Create(IKernel kernel, object instance, ComponentModel model,
CreationContext context, params object[] constructorArguments)
{
var channelHolder = instance as IWcfChannelHolder;
if (channelHolder == null)
{
throw new ArgumentException(string.Format("Given instance is not an {0}", typeof(IWcfChannelHolder)), "instance");
}
if (channelHolder.RealProxy == null)
{
return channelHolder.Channel;
}
if (model.Services.Count() > 1)
{
throw new ArgumentException(string.Format(
"Component {0}, which was designated as a WCF proxy exposes {1} services. The facility currently only supports single-service components.",
model.Name, model.Services.Count()));
}
var isDuplex = IsDuplex(channelHolder.RealProxy);
var proxyOptions = model.ObtainProxyOptions();
var serviceContract = model.GetServiceContract();
var generationOptions = CreateProxyGenerationOptions(serviceContract, proxyOptions, kernel, context);
var additionalInterfaces = GetInterfaces(model.Services, proxyOptions, isDuplex);
var interceptors = GetInterceptors(kernel, model, serviceContract, channelHolder, context);
return generator.CreateInterfaceProxyWithTarget(typeof(IWcfChannelHolder),
additionalInterfaces, channelHolder, generationOptions, interceptors);
}
private bool CanResolvePendingDependencies(CreationContext context)
{
// detect circular dependencies
if (IsBeingResolvedInContext(context))
return false;
foreach (var dependency in DependenciesByService.Values.ToArray())
{
// a self-dependency is not allowed
var handler = Kernel.GetHandler(dependency.TargetType);
if (handler == this)
return false;
// ask the kernel
if (Kernel.HasComponent(dependency.TargetType)) continue;
// let's try to lazy load the dependency...
if (!LazyLoadComponent(dependency.DependencyKey, dependency.TargetType))
return false;
// and see if we can have it this time around
// if the previous call returned true we always should
if (!Kernel.HasComponent(dependency.TargetType))
return false;
}
return DependenciesByKey.Count == 0;
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver,
ComponentModel model,
DependencyModel dependency)
{
return dependency.TargetType != null &&
dependency.TargetType.IsArray &&
kernel.HasComponent(dependency.TargetType.GetElementType());
}
public virtual object Create(CreationContext context)
{
object instance = InternalCreate(context);
onCreation(model, instance);
return instance;
}
protected override object Instantiate(CreationContext context)
{
var instance = base.Instantiate(context);
Marshal(instance, Model);
return instance;
}
public void CanConstructObjectWithoutParameters()
{
var context = new CreationContext {ConcreteType = typeof (ClassWithNoDependencies)};
IComponentActivator activator = new ComponentActivator();
var instance = activator.CreateInstance(context);
Assert.IsType(typeof (ClassWithNoDependencies), instance);
}
protected override object Instantiate(CreationContext context)
{
String url = (String) Model.ExtendedProperties["remoting.uri"];
// return Activator.GetObject(Model.Service, url);
return RemotingServices.Connect( Model.Service, url );
}
public bool CanResolve(CreationContext context, ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
return dependency.TargetType != null &&
dependency.TargetType.IsArray &&
dependency.TargetType.GetElementType().IsInterface;
}
/// <summary>
/// Initialize <see cref="id"/> properties using values from the attribute bag.
/// </summary>
/// <param name="ve">The object to initialize.</param>
/// <param name="bag">The attribute bag.</param>
/// <param name="cc">The creation context; unused.</param>
public override void Init(VisualElement ve, IUxmlAttributes bag, CreationContext cc)
{
base.Init(ve, bag, cc);
((ButtonGroup)ve).value = m_ActiveIndex.GetValueFromBag(bag, cc);
}
public override void Init(VisualElement ve, IUxmlAttributes bag, CreationContext cc)
{
base.Init(ve, bag, cc);
((Hyperlink)ve).Link = m_Link.GetValueFromBag(bag, cc);
}
public abstract object Create(IProxyFactoryExtension customFactory, IKernel kernel, ComponentModel model,
CreationContext context, params object[] constructorArguments);
/// <summary>
/// Check if dependency is of type ILog
/// </summary>
/// <param name="context"></param>
/// <param name="contextHandlerResolver"></param>
/// <param name="model"></param>
/// <param name="dependency"></param>
/// <returns></returns>
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(dependency.TargetType == typeof(ILog));
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
return(new SatiWatcher());
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(Result.Value);
}
public override void Init(VisualElement ve, IUxmlAttributes bag, CreationContext cc)
{
base.Init(ve, bag, cc);
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
ThrowIfServiceProviderIsNull();
return(serviceProvider.GetService(dependency.TargetType));
}
public abstract object Create(IKernel kernel, object instance, ComponentModel model, CreationContext context,
params object[] constructorArguments);
private object CreateOnWinformsUIThread(CreationContextDelegate performCreation, CreationContext context)
{
if (marshalingControl.InvokeRequired)
{
return(marshalingControl.Invoke((CreateOnUIThreadDelegate)CreateOnWinformsUIThread, performCreation, context));
}
var component = performCreation(context);
var control = (Control)GetUnproxiedInstance(component);
if (control.Handle == IntPtr.Zero)
{
throw new InvalidOperationException("The WinForms control handle could not be obtained");
}
return(component);
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(_kernel.Resolve(dependency.TargetType));
}
protected override PackageSampleList DoCreate(IUxmlAttributes bag, CreationContext cc)
{
return(new PackageSampleList());
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(dependency.TargetType.GetTypeInfo().IsGenericType&& dependency.TargetType.GetGenericTypeDefinition() == typeof(IOptions <>));
}
private bool InvokeInSynchronizationContext(IInvocation invocation)
{
if (metaInfo != null)
{
IHandler handler = null;
SynchronizationContext syncContext = null;
SynchronizationContext prevSyncContext = null;
var methodInfo = invocation.MethodInvocationTarget;
var syncContextRef = metaInfo.GetSynchronizedContextFor(methodInfo);
if (syncContextRef != null)
{
switch (syncContextRef.ReferenceType)
{
case SynchronizeContextReferenceType.Key:
handler = kernel.GetHandler(syncContextRef.ComponentKey);
break;
case SynchronizeContextReferenceType.Interface:
handler = kernel.GetHandler(syncContextRef.ServiceType);
break;
}
if (handler == null)
{
throw new ApplicationException("The synchronization context could not be resolved. Did you forget to register it in the container?");
}
syncContext = handler.Resolve(CreationContext.CreateEmpty()) as SynchronizationContext;
if (syncContext == null)
{
throw new ApplicationException(string.Format("{0} does not implement {1}", syncContextRef, typeof(SynchronizationContext).FullName));
}
prevSyncContext = SynchronizationContext.Current;
}
else
{
syncContext = SynchronizationContext.Current;
}
if (syncContext != activeSyncContext)
{
try
{
var result = CreateResult(invocation);
if (prevSyncContext != null)
{
SynchronizationContext.SetSynchronizationContext(syncContext);
}
if (syncContext.GetType() == typeof(SynchronizationContext))
{
InvokeSynchronously(invocation, result);
}
else
{
syncContext.Send(state =>
{
activeSyncContext = syncContext;
try
{
InvokeSafely(invocation, result);
}
finally
{
activeSyncContext = null;
}
}, null);
}
}
finally
{
if (prevSyncContext != null)
{
SynchronizationContext.SetSynchronizationContext(prevSyncContext);
}
}
}
else
{
InvokeSynchronously(invocation, null);
}
return(true);
}
return(false);
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(Result != null);
}
/// <summary>
/// Obtains the interceptors associated with the component.
/// </summary>
/// <param name="kernel">The kernel instance</param>
/// <param name="model">The component model</param>
/// <param name="context">The creation context</param>
/// <returns>interceptors array</returns>
protected IInterceptor[] ObtainInterceptors(IKernel kernel, ComponentModel model, CreationContext context)
{
var interceptors = new List <IInterceptor>();
foreach (IReference <IInterceptor> interceptorRef in GetInterceptorsFor(model))
{
try
{
var interceptor = interceptorRef.Resolve(kernel, context);
SetOnBehalfAware(interceptor as IOnBehalfAware, model);
interceptors.Add(interceptor);
}
catch (Exception e)
{
foreach (var interceptor in interceptors)
{
kernel.ReleaseComponent(interceptor);
}
if (e is InvalidCastException)
{
var message = String.Format(
"An interceptor registered for {0} doesn't implement the {1} interface",
model.Name, typeof(IInterceptor).Name);
throw new DependencyResolverException(message);
}
throw;
}
}
return(interceptors.ToArray());
}
private ICache Create(IKernel kernel, CreationContext context)
{
return(new AppFabricCache("default"));
}
private void ProcessWaitList()
{
foreach (var pair in m_WaitList.ToArray().Where(pair => pair.Key.CurrentState == HandlerState.Valid && pair.Key.TryResolve(CreationContext.CreateEmpty()) != null))
{
pair.Value(pair.Key);
m_WaitList.Remove(pair.Key);
}
}
public object Resolve(CreationContext context, ISubDependencyResolver parentResolver,
ComponentModel model,
DependencyModel dependency)
{
return(kernel.ResolveAll(dependency.TargetType.GetElementType(), null));
}
protected override PackageManagerToolbar DoCreate(IUxmlAttributes bag, CreationContext cc)
{
return(new PackageManagerToolbar());
}
protected override PackageDetails DoCreate(IUxmlAttributes bag, CreationContext cc)
{
return(new PackageDetails());
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model,
DependencyModel dependency)
{
// We will never actually resolve the component, but always use the standard SubDependencyResolver, as Can resolve always returns false;
return(null);
}
private static ComponentReleasingDelegate BindSessionFactoryParameter(IKernel kernel, CreationContext creationContext, IDictionary parameters)
{
parameters["sessionFactory"] = kernel.Resolve <ISessionFactory>();
return(r => { });
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(model.ComponentName.Name.EndsWith(AppSettingsInstaller.AppSettingsModelpostfix) &&
DontInjectProperties(dependency) && (dependency.TargetType == typeof(int) ||
dependency.TargetType == typeof(bool) || dependency.TargetType == typeof(string) || dependency.TargetType == typeof(double)));
}
protected virtual void Intitialize(Func <CreationContext, Burden> createCallback, CreationContext c)
{
initialized = true;
for (var i = 0; i < initialSize; i++)
{
var burden = createCallback(c);
available.Push(burden);
}
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(this.kernel.Resolve(dependency.DependencyKey, typeof(DirectoryInfo)));
}
public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return(HasMatchingType(dependency.TargetType));
}
public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
return((
from step in this._stepNames
select this._kernel.Resolve <IStep <TWorkItem> >(step)).ToArray <IStep <TWorkItem> >());
}
private static object CreateOnDispatcherUIThread(CreationContextDelegate performCreation, CreationContext context)
{
var application = Application.Current;
if (application != null && application.CheckAccess() == false)
{
return(application.Dispatcher.Invoke((CreateOnUIThreadDelegate)CreateOnDispatcherUIThread, performCreation, context));
}
return(performCreation(context));
}
protected override PackageStatusBar DoCreate(IUxmlAttributes bag, CreationContext cc)
{
return(new PackageStatusBar());
}
