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()); }