Stashbox by Peter Csajtai

<PackageReference Include="Stashbox" Version="5.15.0" />

---

API Diff between 5.15.0 and 2.9.0-preview-524

522 Additions 223 Removals

Stashbox

• public static class CollectionRegistratorExtensions
  • public static IStashboxContainer RegisterAssemblies(this IDependencyCollectionRegistrator registrator, IEnumerable<Assembly> assemblies, Func<Type, bool> selector = null, Action<RegistrationConfigurator> configurator = null)
  • public static IStashboxContainer RegisterAssembly(this IDependencyCollectionRegistrator registrator, Assembly assembly, Func<Type, bool> selector = null, Action<RegistrationConfigurator> configurator = null)
  • public static IStashboxContainer RegisterAssemblyContaining<TFrom>(this IDependencyCollectionRegistrator registrator, Func<Type, bool> selector = null, Action<RegistrationConfigurator> configurator = null)
  • public static IStashboxContainer RegisterAssemblyContaining(this IDependencyCollectionRegistrator registrator, Type typeFrom, Func<Type, bool> selector = null, Action<RegistrationConfigurator> configurator = null)
  • public static IStashboxContainer RegisterAssemblies(this IDependencyCollectionRegistrator registrator, IEnumerable<Assembly> assemblies, Func<Type, bool> selector = null, Func<Type, Type, bool> serviceTypeSelector = null, bool registerSelf = true, Action<RegistrationConfigurator> configurator = null)
  • public static IStashboxContainer RegisterAssembly(this IDependencyCollectionRegistrator registrator, Assembly assembly, Func<Type, bool> selector = null, Func<Type, Type, bool> serviceTypeSelector = null, bool registerSelf = true, Action<RegistrationConfigurator> configurator = null)
  • public static IStashboxContainer RegisterAssemblyContaining<TFrom>(this IDependencyCollectionRegistrator registrator, Func<Type, bool> selector = null, Func<Type, Type, bool> serviceTypeSelector = null, bool registerSelf = true, Action<RegistrationConfigurator> configurator = null)
  • public static IStashboxContainer RegisterAssemblyContaining(this IDependencyCollectionRegistrator registrator, Type typeFrom, Func<Type, bool> selector = null, Func<Type, Type, bool> serviceTypeSelector = null, bool registerSelf = true, Action<RegistrationConfigurator> configurator = null)
• public class ContainerContext : IContainerContext
• public static class DecoratorRegistratorExtensions
• public static class DependencyRegistratorExtensions
  • public static IStashboxContainer Register<TFrom, TTo>(this IDependencyRegistrator registrator, object name = null) where TTo : TFrom
  • public static IStashboxContainer RegisterInstance(this IDependencyRegistrator registrator, object instance, object name = null, bool withoutDisposalTracking = false)
  • public static IStashboxContainer RegisterInstancesAs<TFrom>(this IDependencyRegistrator registrator, IEnumerable<TFrom> instances, bool withoutDisposalTracking = false)
  • public static IStashboxContainer RegisterInstancesAs<TFrom>(this IDependencyRegistrator registrator, TFrom[] instances)
  • public static IStashboxContainer RegisterScoped<TFrom, TTo>(this IDependencyRegistrator registrator, object name = null) where TTo : TFrom
  • public static IStashboxContainer RegisterScoped(this IDependencyRegistrator registrator, Type typeFrom, Type typeTo, object name = null)
  • public static IStashboxContainer RegisterScoped<TTo>(this IDependencyRegistrator registrator, object name = null)
  • public static IStashboxContainer RegisterSingleton<TFrom, TTo>(this IDependencyRegistrator registrator, object name = null) where TTo : TFrom
  • public static IStashboxContainer RegisterSingleton<TTo>(this IDependencyRegistrator registrator, object name = null)
  • public static IStashboxContainer RegisterSingleton(this IDependencyRegistrator registrator, Type typeFrom, Type typeTo, object name = null)
  • public static IStashboxContainer WireUp(this IDependencyRegistrator registrator, object instance, object name = null, bool withoutDisposalTracking = false)
  • public static IStashboxContainer RegisterInstances<TFrom>(this IDependencyRegistrator registrator, IEnumerable<TFrom> instances, bool withoutDisposalTracking = false)
  • public static IStashboxContainer RegisterInstances<TFrom>(this IDependencyRegistrator registrator, TFrom[] instances)
• public static class DependencyReMapperExtensions
  • public static IStashboxContainer ReMapDecorator<TFrom, TTo>(this IDependencyReMapper reMapper, Action<DecoratorConfigurator> configurator = null) where TTo : TFrom
  • public static IStashboxContainer ReMapDecorator<TFrom>(this IDependencyReMapper reMapper, Type typeTo, Action<DecoratorConfigurator> configurator = null)
• public static class DependencyResolverExtensions
  • public static IDependencyResolver PutInstanceInScope<TFrom>(this IDependencyResolver resolver, TFrom instance, bool withoutDisposalTracking = false, object name = null)
  • public static TKey Resolve<TKey>(this IDependencyResolver resolver, bool nullResultAllowed = false, object[] dependencyOverrides = null)
  • public static TKey Resolve<TKey>(this IDependencyResolver resolver, object name, bool nullResultAllowed = false, object[] dependencyOverrides = null)
  • public static Func<TService> ResolveFactory<TService>(this IDependencyResolver resolver, object name = null, bool nullResultAllowed = false)
  • public static Func<T1, TService> ResolveFactory<T1, TService>(this IDependencyResolver resolver, object name = null, bool nullResultAllowed = false)
  • public static Func<T1, T2, TService> ResolveFactory<T1, T2, TService>(this IDependencyResolver resolver, object name = null, bool nullResultAllowed = false)
  • public static Func<T1, T2, T3, TService> ResolveFactory<T1, T2, T3, TService>(this IDependencyResolver resolver, object name = null, bool nullResultAllowed = false)
  • public static Func<T1, T2, T3, T4, TService> ResolveFactory<T1, T2, T3, T4, TService>(this IDependencyResolver resolver, object name = null, bool nullResultAllowed = false)
  • public static object Activate(this IDependencyResolver resolver, Type type, object[] arguments)
  • public static TTo Activate<TTo>(this IDependencyResolver resolver, ResolutionBehavior resolutionBehavior, object[] arguments)
  • public static bool CanResolve<TFrom>(this IDependencyResolver resolver, object name = null, ResolutionBehavior resolutionBehavior = 3)
  • public static void PutInstanceInScope<TFrom>(this IDependencyResolver resolver, TFrom instance, bool withoutDisposalTracking = false, object name = null)
  • public static TKey Resolve<TKey>(this IDependencyResolver resolver)
  • public static TKey Resolve<TKey>(this IDependencyResolver resolver, ResolutionBehavior resolutionBehavior)
  • public static TKey Resolve<TKey>(this IDependencyResolver resolver, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public static TKey Resolve<TKey>(this IDependencyResolver resolver, object name, ResolutionBehavior resolutionBehavior = 3)
  • public static TKey Resolve<TKey>(this IDependencyResolver resolver, object name, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public static object Resolve(this IDependencyResolver resolver, Type typeFrom, ResolutionBehavior resolutionBehavior)
  • public static object Resolve(this IDependencyResolver resolver, Type typeFrom, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public static object Resolve(this IDependencyResolver resolver, Type typeFrom, object name, ResolutionBehavior resolutionBehavior = 3)
  • public static IEnumerable<TKey> ResolveAll<TKey>(this IDependencyResolver resolver)
  • public static IEnumerable<TKey> ResolveAll<TKey>(this IDependencyResolver resolver, ResolutionBehavior resolutionBehavior)
  • public static IEnumerable<TKey> ResolveAll<TKey>(this IDependencyResolver resolver, object name, ResolutionBehavior resolutionBehavior = 3)
  • public static IEnumerable<TKey> ResolveAll<TKey>(this IDependencyResolver resolver, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public static IEnumerable<TKey> ResolveAll<TKey>(this IDependencyResolver resolver, object name, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public static IEnumerable<object> ResolveAll(this IDependencyResolver resolver, Type typeFrom)
  • public static IEnumerable<object> ResolveAll(this IDependencyResolver resolver, Type typeFrom, ResolutionBehavior resolutionBehavior)
  • public static IEnumerable<object> ResolveAll(this IDependencyResolver resolver, Type typeFrom, object name, ResolutionBehavior resolutionBehavior = 3)
  • public static IEnumerable<object> ResolveAll(this IDependencyResolver resolver, Type typeFrom, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public static IEnumerable<object> ResolveAll(this IDependencyResolver resolver, Type typeFrom, object name, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public static TKey ResolveOrDefault<TKey>(this IDependencyResolver resolver, object name, ResolutionBehavior resolutionBehavior = 3)
  • public static TKey ResolveOrDefault<TKey>(this IDependencyResolver resolver, object name, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public static TKey ResolveOrDefault<TKey>(this IDependencyResolver resolver)
  • public static TKey ResolveOrDefault<TKey>(this IDependencyResolver resolver, ResolutionBehavior resolutionBehavior)
  • public static TKey ResolveOrDefault<TKey>(this IDependencyResolver resolver, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public static object ResolveOrDefault(this IDependencyResolver resolver, Type typeFrom, ResolutionBehavior resolutionBehavior)
  • public static object ResolveOrDefault(this IDependencyResolver resolver, Type typeFrom, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public static object ResolveOrDefault(this IDependencyResolver resolver, Type typeFrom, object name, ResolutionBehavior resolutionBehavior = 3)
• public interface IContainerConfigurator
• public interface IContainerContext
  • IStashboxContainer Container { get; }
  • IContainerContext ParentContext { get; }
  • IResolutionStrategy ResolutionStrategy { get; }
  • IResolutionScope RootScope { get; }
• public interface IDecoratorRegistrator
  • IStashboxContainer RegisterDecorator<TFrom, TTo>(Action<DecoratorConfigurator<TFrom, TTo>> configurator = null) where TTo : TFrom
  • IStashboxContainer RegisterDecorator(Type typeTo, Action<DecoratorConfigurator> configurator = null)
  • IStashboxContainer RegisterDecorator<TTo>(Action<DecoratorConfigurator<TTo, TTo>> configurator = null)
  • IStashboxContainer RegisterDecorator<TFrom>(Type typeTo, Action<DecoratorConfigurator<TFrom, TFrom>> configurator = null)
• public interface IDependencyCollectionRegistrator
  • IStashboxContainer RegisterTypes(IEnumerable<Type> types, Func<Type, bool> selector = null, Action<RegistrationConfigurator> configurator = null)
  • IStashboxContainer RegisterTypes(IEnumerable<Type> types, Func<Type, bool> selector = null, Func<Type, Type, bool> serviceTypeSelector = null, bool registerSelf = true, Action<RegistrationConfigurator> configurator = null)
• public interface IDependencyRegistrator
  • IStashboxContainer Register<TFrom, TTo>(Action<RegistrationConfigurator<TTo>> configurator = null) where TTo : TFrom
  • IStashboxContainer Register<TFrom>(Type typeTo, Action<RegistrationConfigurator<TFrom>> configurator = null)
  • IStashboxContainer Register<TFrom, TTo>(Action<RegistrationConfigurator<TFrom, TTo>> configurator) where TTo : TFrom
  • IStashboxContainer Register<TFrom, TTo>(object name = null) where TTo : TFrom
  • IStashboxContainer Register<TFrom>(Type typeTo, Action<RegistrationConfigurator<TFrom, TFrom>> configurator = null)
  • IStashboxContainer Register<TTo>(Action<RegistrationConfigurator<TTo>> configurator = null)
  • IStashboxContainer Register<TTo>(Action<RegistrationConfigurator<TTo, TTo>> configurator)
  • IStashboxContainer Register<TTo>(object name = null)
  • IStashboxContainer RegisterInstance(Type serviceType, object instance, object name = null, bool withoutDisposalTracking = false)
  • IStashboxContainer RegisterInstanceAs<TFrom>(TFrom instance, object name = null, bool withoutDisposalTracking = false, Action<TFrom> finalizerDelegate = null)
  • IStashboxContainer WireUp(Type serviceType, object instance, object name = null, bool withoutDisposalTracking = false)
  • IStashboxContainer WireUpAs<TFrom>(TFrom instance, object name = null, bool withoutDisposalTracking = false, Action<TFrom> finalizerDelegate = null)
  • IStashboxContainer RegisterInstance<TInstance>(TInstance instance, object name = null, bool withoutDisposalTracking = false, Action<TInstance> finalizerDelegate = null)
  • IStashboxContainer RegisterInstance(object instance, Type serviceType, object name = null, bool withoutDisposalTracking = false)
  • IStashboxContainer RegisterScoped<TFrom, TTo>(object name = null) where TTo : TFrom
  • IStashboxContainer RegisterScoped(Type typeFrom, Type typeTo, object name = null)
  • IStashboxContainer RegisterScoped<TTo>(object name = null)
  • IStashboxContainer RegisterSingleton<TFrom, TTo>(object name = null) where TTo : TFrom
  • IStashboxContainer RegisterSingleton<TTo>(object name = null)
  • IStashboxContainer RegisterSingleton(Type typeFrom, Type typeTo, object name = null)
  • IStashboxContainer WireUp<TInstance>(TInstance instance, object name = null, bool withoutDisposalTracking = false, Action<TInstance> finalizerDelegate = null)
  • IStashboxContainer WireUp(object instance, Type serviceType, object name = null, bool withoutDisposalTracking = false)
• public interface IDependencyReMapper
  • IStashboxContainer ReMap<TFrom, TTo>(Action<RegistrationConfigurator<TTo>> configurator = null) where TTo : TFrom
  • IStashboxContainer ReMap<TFrom>(Type typeTo, Action<RegistrationConfigurator<TFrom>> configurator = null)
  • IStashboxContainer ReMap<TFrom, TTo>(Action<RegistrationConfigurator<TFrom, TTo>> configurator = null) where TTo : TFrom
  • IStashboxContainer ReMap<TFrom>(Type typeTo, Action<RegistrationConfigurator<TFrom, TFrom>> configurator = null)
  • IStashboxContainer ReMap<TTo>(Action<RegistrationConfigurator<TTo>> configurator = null)
  • IStashboxContainer ReMap<TTo>(Action<RegistrationConfigurator<TTo, TTo>> configurator = null)
  • IStashboxContainer ReMapDecorator<TFrom, TTo>(Action<DecoratorConfigurator<TFrom, TTo>> configurator = null) where TTo : TFrom
  • IStashboxContainer ReMapDecorator<TFrom>(Type typeTo, Action<DecoratorConfigurator<TFrom, TFrom>> configurator = null)
• public interface IDependencyResolver : IServiceProvider, IAsyncDisposable, IDisposable
  • object Activate(Type type, object[] arguments)
  • object Activate(Type type, ResolutionBehavior resolutionBehavior, object[] arguments)
  • TTo BuildUp<TTo>(TTo instance)
  • IDependencyResolver PutInstanceInScope(Type typeFrom, object instance, bool withoutDisposalTracking = false, object name = null)
  • object Resolve(Type typeFrom, bool nullResultAllowed = false, object[] dependencyOverrides = null)
  • object Resolve(Type typeFrom, object name, bool nullResultAllowed = false, object[] dependencyOverrides = null)
  • IEnumerable<TKey> ResolveAll<TKey>(object[] dependencyOverrides = null)
  • IEnumerable<object> ResolveAll(Type typeFrom, object[] dependencyOverrides = null)
  • Delegate ResolveFactory(Type typeFrom, object name = null, bool nullResultAllowed = false, Type[] parameterTypes)
  • TTo BuildUp<TTo>(TTo instance, ResolutionBehavior resolutionBehavior = 3)
  • bool CanResolve(Type typeFrom, object name = null, ResolutionBehavior resolutionBehavior = 3)
  • IEnumerable<DelegateCacheEntry> GetDelegateCacheEntries()
  • ValueTask InvokeAsyncInitializers(CancellationToken token = default)
  • void PutInstanceInScope(Type typeFrom, object instance, bool withoutDisposalTracking = false, object name = null)
  • object Resolve(Type typeFrom)
  • object Resolve(Type typeFrom, object name, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • Delegate ResolveFactory(Type typeFrom, object name = null, ResolutionBehavior resolutionBehavior = 3, Type[] parameterTypes)
  • Delegate ResolveFactoryOrDefault(Type typeFrom, object name = null, ResolutionBehavior resolutionBehavior = 3, Type[] parameterTypes)
  • object ResolveOrDefault(Type typeFrom)
  • object ResolveOrDefault(Type typeFrom, object name, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
• public interface IFuncRegistrator
  • IStashboxContainer RegisterFunc<TService>(Func<IDependencyResolver, TService> factory, string name = null)
  • IStashboxContainer RegisterFunc<T1, TService>(Func<T1, IDependencyResolver, TService> factory, string name = null)
  • IStashboxContainer RegisterFunc<T1, T2, TService>(Func<T1, T2, IDependencyResolver, TService> factory, string name = null)
  • IStashboxContainer RegisterFunc<T1, T2, T3, TService>(Func<T1, T2, T3, IDependencyResolver, TService> factory, string name = null)
  • IStashboxContainer RegisterFunc<T1, T2, T3, T4, TService>(Func<T1, T2, T3, T4, IDependencyResolver, TService> factory, string name = null)
  • IStashboxContainer RegisterFunc<TService>(Func<IDependencyResolver, TService> factory, object name = null)
  • IStashboxContainer RegisterFunc<T1, TService>(Func<T1, IDependencyResolver, TService> factory, object name = null)
  • IStashboxContainer RegisterFunc<T1, T2, TService>(Func<T1, T2, IDependencyResolver, TService> factory, object name = null)
  • IStashboxContainer RegisterFunc<T1, T2, T3, TService>(Func<T1, T2, T3, IDependencyResolver, TService> factory, object name = null)
  • IStashboxContainer RegisterFunc<T1, T2, T3, T4, TService>(Func<T1, T2, T3, T4, IDependencyResolver, TService> factory, object name = null)
• public interface IResolutionScope : IDependencyResolver, IServiceProvider, IAsyncDisposable, IDisposable
  • bool HasScopedInstances { get; }
  • TDisposable AddDisposableTracking<TDisposable>(TDisposable disposable) where TDisposable : IDisposable
  • void AddScopedInstance(Type key, object value, object name = null)
  • TService AddWithFinalizer<TService>(TService finalizable, Action<TService> finalizer)
  • void CheckRuntimeCircularDependencyBarrier(int key, Type type)
  • List<object> GetActiveScopeNames()
  • object GetOrAddScopedItem(int key, object sync, Func<IResolutionScope, object> factory)
  • object GetScopedInstanceOrDefault(Type key, object name = null)
  • object AddDisposableTracking(object disposable)
  • object AddRequestContextAwareDisposableTracking(object disposable, IRequestContext requestContext)
  • object AddWithAsyncInitializer(object initializable, Func<object, IDependencyResolver, CancellationToken, Task> initializer)
  • object AddWithFinalizer(object finalizable, Action<object> finalizer)
  • IEnumerable<object> GetActiveScopeNames()
  • object GetOrAddScopedObject(int key, Func<IResolutionScope, IRequestContext, object> factory, IRequestContext requestContext, Type serviceType)
  • void ResetRuntimeCircularDependencyBarrier(int key)
• public interface IStashboxContainer : IDependencyRegistrator, IDependencyResolver, IServiceProvider, IAsyncDisposable, IDisposable, IDependencyReMapper, IDependencyCollectionRegistrator, IDecoratorRegistrator, IFuncRegistrator
  • IEnumerable<ReadOnlyKeyValue<object, IStashboxContainer>> ChildContainers { get; }
  • IStashboxContainer ParentContainer { get; }
  • IResolutionScope RootScope { get; }
  • bool CanResolve<TFrom>(object name = null)
  • bool CanResolve(Type typeFrom, object name = null)
  • void Configure(Action<IContainerConfigurator> config)
  • IStashboxContainer CreateChildContainer()
  • IEnumerable<KeyValuePair<Type, IServiceRegistration>> GetRegistrationMappings()
  • void Configure(Action<ContainerConfigurator> config)
  • IStashboxContainer CreateChildContainer(Action<ContainerConfigurator> config = null, bool attachToParent = true)
  • IStashboxContainer CreateChildContainer(object identifier, Action<IStashboxContainer> config = null, bool attachToParent = true)
  • IStashboxContainer GetChildContainer(object identifier)
  • IEnumerable<RegistrationDiagnosticsInfo> GetRegistrationDiagnostics()
  • IEnumerable<KeyValuePair<Type, ServiceRegistration>> GetRegistrationMappings()
  • void RegisterExtension(IContainerExtension containerExtension)
• public sealed class Metadata<TService, TMeta>
  • public readonly TMeta Data
  • public readonly TService Service
  • public Metadata(TService service, TMeta data)
• public struct ReadOnlyKeyValue<TKey, TValue>
  • public readonly TKey Key
  • public readonly TValue Value
  • public ReadOnlyKeyValue(TKey key, TValue value)
• public sealed class StashboxContainer : IStashboxContainer, IDependencyRegistrator, IDependencyResolver, IServiceProvider, IAsyncDisposable, IDisposable, IDependencyReMapper, IDependencyCollectionRegistrator, IDecoratorRegistrator, IFuncRegistrator
  • public IEnumerable<ReadOnlyKeyValue<object, IStashboxContainer>> ChildContainers { get; }
  • public IStashboxContainer ParentContainer { get; }
  • public IResolutionScope RootScope { get; }
  • public StashboxContainer(Action<IContainerConfigurator> config = null)
  • public object Activate(Type type, object[] arguments)
  • public StashboxContainer(Action<ContainerConfigurator> config = null)
  • public object Activate(Type type, ResolutionBehavior resolutionBehavior, object[] arguments)
  • public TTo BuildUp<TTo>(TTo instance)
  • public bool CanResolve<TFrom>(object name = null)
  • public bool CanResolve(Type typeFrom, object name = null)
  • public TTo BuildUp<TTo>(TTo instance, ResolutionBehavior resolutionBehavior = 3)
  • public bool CanResolve(Type typeFrom, object name = null, ResolutionBehavior resolutionBehavior = 3)
  • public void Configure(Action<IContainerConfigurator> config)
  • public IStashboxContainer CreateChildContainer()
  • public void Configure(Action<ContainerConfigurator> config)
  • public IStashboxContainer CreateChildContainer(Action<ContainerConfigurator> config = null, bool attachToParent = true)
  • public IStashboxContainer CreateChildContainer(object identifier, Action<IStashboxContainer> config = null, bool attachToParent = true)
  • public IEnumerable<KeyValuePair<Type, IServiceRegistration>> GetRegistrationMappings()
  • public ValueTask DisposeAsync()
  • public IStashboxContainer GetChildContainer(object identifier)
  • public IEnumerable<DelegateCacheEntry> GetDelegateCacheEntries()
  • public IEnumerable<RegistrationDiagnosticsInfo> GetRegistrationDiagnostics()
  • public IEnumerable<KeyValuePair<Type, ServiceRegistration>> GetRegistrationMappings()
  • public ValueTask InvokeAsyncInitializers(CancellationToken token = default)
  • public IDependencyResolver PutInstanceInScope(Type typeFrom, object instance, bool withoutDisposalTracking = false, object name = null)
  • public IStashboxContainer Register<TFrom, TTo>(Action<RegistrationConfigurator<TTo>> configurator = null) where TTo : TFrom
  • public IStashboxContainer Register<TFrom>(Type typeTo, Action<RegistrationConfigurator<TFrom>> configurator = null)
  • public void PutInstanceInScope(Type typeFrom, object instance, bool withoutDisposalTracking = false, object name = null)
  • public IStashboxContainer Register<TFrom, TTo>(Action<RegistrationConfigurator<TFrom, TTo>> configurator) where TTo : TFrom
  • public IStashboxContainer Register<TFrom, TTo>(object name = null) where TTo : TFrom
  • public IStashboxContainer Register<TFrom>(Type typeTo, Action<RegistrationConfigurator<TFrom, TFrom>> configurator = null)
  • public IStashboxContainer Register<TTo>(Action<RegistrationConfigurator<TTo>> configurator = null)
  • public IStashboxContainer Register<TTo>(Action<RegistrationConfigurator<TTo, TTo>> configurator)
  • public IStashboxContainer Register<TTo>(object name = null)
  • public void RegisterExtension(IContainerExtension containerExtension)
  • public IStashboxContainer RegisterFunc<TService>(Func<IDependencyResolver, TService> factory, string name = null)
  • public IStashboxContainer RegisterFunc<T1, TService>(Func<T1, IDependencyResolver, TService> factory, string name = null)
  • public IStashboxContainer RegisterFunc<T1, T2, TService>(Func<T1, T2, IDependencyResolver, TService> factory, string name = null)
  • public IStashboxContainer RegisterFunc<T1, T2, T3, TService>(Func<T1, T2, T3, IDependencyResolver, TService> factory, string name = null)
  • public IStashboxContainer RegisterFunc<T1, T2, T3, T4, TService>(Func<T1, T2, T3, T4, IDependencyResolver, TService> factory, string name = null)
  • public IStashboxContainer RegisterInstance(Type serviceType, object instance, object name = null, bool withoutDisposalTracking = false)
  • public IStashboxContainer RegisterInstanceAs<TFrom>(TFrom instance, object name = null, bool withoutDisposalTracking = false, Action<TFrom> finalizerDelegate = null)
  • public IStashboxContainer RegisterDecorator<TFrom, TTo>(Action<DecoratorConfigurator<TFrom, TTo>> configurator = null) where TTo : TFrom
  • public IStashboxContainer RegisterDecorator(Type typeTo, Action<DecoratorConfigurator> configurator = null)
  • public IStashboxContainer RegisterDecorator<TTo>(Action<DecoratorConfigurator<TTo, TTo>> configurator = null)
  • public IStashboxContainer RegisterDecorator<TFrom>(Type typeTo, Action<DecoratorConfigurator<TFrom, TFrom>> configurator = null)
  • public IStashboxContainer RegisterFunc<TService>(Func<IDependencyResolver, TService> factory, object name = null)
  • public IStashboxContainer RegisterFunc<T1, TService>(Func<T1, IDependencyResolver, TService> factory, object name = null)
  • public IStashboxContainer RegisterFunc<T1, T2, TService>(Func<T1, T2, IDependencyResolver, TService> factory, object name = null)
  • public IStashboxContainer RegisterFunc<T1, T2, T3, TService>(Func<T1, T2, T3, IDependencyResolver, TService> factory, object name = null)
  • public IStashboxContainer RegisterFunc<T1, T2, T3, T4, TService>(Func<T1, T2, T3, T4, IDependencyResolver, TService> factory, object name = null)
  • public IStashboxContainer RegisterInstance<TInstance>(TInstance instance, object name = null, bool withoutDisposalTracking = false, Action<TInstance> finalizerDelegate = null)
  • public IStashboxContainer RegisterInstance(object instance, Type serviceType, object name = null, bool withoutDisposalTracking = false)
  • public IStashboxContainer RegisterTypes(IEnumerable<Type> types, Func<Type, bool> selector = null, Action<RegistrationConfigurator> configurator = null)
  • public IStashboxContainer RegisterScoped<TFrom, TTo>(object name = null) where TTo : TFrom
  • public IStashboxContainer RegisterScoped(Type typeFrom, Type typeTo, object name = null)
  • public IStashboxContainer RegisterScoped<TTo>(object name = null)
  • public IStashboxContainer RegisterSingleton<TFrom, TTo>(object name = null) where TTo : TFrom
  • public IStashboxContainer RegisterSingleton<TTo>(object name = null)
  • public IStashboxContainer RegisterSingleton(Type typeFrom, Type typeTo, object name = null)
  • public IStashboxContainer RegisterTypes(IEnumerable<Type> types, Func<Type, bool> selector = null, Func<Type, Type, bool> serviceTypeSelector = null, bool registerSelf = true, Action<RegistrationConfigurator> configurator = null)
  • public IStashboxContainer ReMap<TFrom, TTo>(Action<RegistrationConfigurator<TTo>> configurator = null) where TTo : TFrom
  • public IStashboxContainer ReMap<TFrom>(Type typeTo, Action<RegistrationConfigurator<TFrom>> configurator = null)
  • public IStashboxContainer ReMap<TFrom, TTo>(Action<RegistrationConfigurator<TFrom, TTo>> configurator = null) where TTo : TFrom
  • public IStashboxContainer ReMap<TFrom>(Type typeTo, Action<RegistrationConfigurator<TFrom, TFrom>> configurator = null)
  • public IStashboxContainer ReMap<TTo>(Action<RegistrationConfigurator<TTo>> configurator = null)
  • public IStashboxContainer ReMap<TTo>(Action<RegistrationConfigurator<TTo, TTo>> configurator = null)
  • public object Resolve(Type typeFrom, bool nullResultAllowed = false, object[] dependencyOverrides = null)
  • public object Resolve(Type typeFrom, object name, bool nullResultAllowed = false, object[] dependencyOverrides = null)
  • public IEnumerable<TKey> ResolveAll<TKey>(object[] dependencyOverrides = null)
  • public IEnumerable<object> ResolveAll(Type typeFrom, object[] dependencyOverrides = null)
  • public Delegate ResolveFactory(Type typeFrom, object name = null, bool nullResultAllowed = false, Type[] parameterTypes)
  • public IStashboxContainer ReMapDecorator<TFrom, TTo>(Action<DecoratorConfigurator<TFrom, TTo>> configurator = null) where TTo : TFrom
  • public IStashboxContainer ReMapDecorator<TFrom>(Type typeTo, Action<DecoratorConfigurator<TFrom, TFrom>> configurator = null)
  • public object Resolve(Type typeFrom)
  • public object Resolve(Type typeFrom, object name, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public Delegate ResolveFactory(Type typeFrom, object name = null, ResolutionBehavior resolutionBehavior = 3, Type[] parameterTypes)
  • public Delegate ResolveFactoryOrDefault(Type typeFrom, object name = null, ResolutionBehavior resolutionBehavior = 3, Type[] parameterTypes)
  • public object ResolveOrDefault(Type typeFrom)
  • public object ResolveOrDefault(Type typeFrom, object name, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public IStashboxContainer WireUp(Type serviceType, object instance, object name = null, bool withoutDisposalTracking = false)
  • public IStashboxContainer WireUpAs<TFrom>(TFrom instance, object name = null, bool withoutDisposalTracking = false, Action<TFrom> finalizerDelegate = null)
  • public IStashboxContainer WireUp<TInstance>(TInstance instance, object name = null, bool withoutDisposalTracking = false, Action<TInstance> finalizerDelegate = null)
  • public IStashboxContainer WireUp(object instance, Type serviceType, object name = null, bool withoutDisposalTracking = false)

Stashbox.Attributes

• public class DependencyAttribute : Attribute
  • public string Name { get; set; }
  • public DependencyAttribute(string name = null)
  • public object Name { get; set; }
  • public DependencyAttribute(object name = null)
• public class DependencyNameAttribute : Attribute
  • public DependencyNameAttribute()

Stashbox.BuildUp

• public interface IObjectBuilder

Stashbox.Configuration

• public class ContainerConfiguration
  • public bool CircularDependenciesWithLazyEnabled { get; }
  • public bool CircularDependencyTrackingEnabled { get; }
  • public bool AutoMemberInjectionEnabled { get; }
  • public Func<MemberInfo, bool> AutoMemberInjectionFilter { get; }
  • public AutoMemberInjectionRules AutoMemberInjectionRule { get; }
  • public Func<IEnumerable<ConstructorInformation>, IEnumerable<ConstructorInformation>> ConstructorSelectionRule { get; }
  • public ILifetime DefaultLifetime { get; }
  • public bool ForceUseMicrosoftExpressionCompiler { get; }
  • public Func<TypeInformation, bool> MemberInjectionFilter { get; }
  • public bool MemberInjectionWithoutAnnotationEnabled { get; }
  • public AutoMemberInjectionRules MemberInjectionWithoutAnnotationRule { get; }
  • public Func<IEnumerable<ConstructorInfo>, IEnumerable<ConstructorInfo>> ConstructorSelectionRule { get; }
  • public LifetimeDescriptor DefaultLifetime { get; }
  • public bool DefaultValueInjectionEnabled { get; }
  • public Func<LambdaExpression, Delegate> ExternalExpressionCompiler { get; }
  • public bool LifetimeValidationEnabled { get; }
  • public bool OptionalAndDefaultValueInjectionEnabled { get; }
  • public bool RuntimeCircularDependencyTrackingEnabled { get; }
  • public bool SetUniqueRegistrationNames { get; }
  • public bool ReBuildSingletonsInChildContainerEnabled { get; }
  • public RegistrationBehavior RegistrationBehavior { get; }
  • public bool RequiredMemberInjectionEnabled { get; }
  • public Action<RegistrationConfigurator> UnknownTypeConfigurator { get; }
  • public Action<UnknownRegistrationConfigurator> UnknownTypeConfigurator { get; }
  • public bool VariantGenericTypesEnabled { get; }
• public class ContainerConfigurator
  • public IContainerConfigurator OnContainerConfigurationChanged(Action<ContainerConfiguration> configurationChanged)
  • public IContainerConfigurator TreatParameterAndMemberNameAsDependencyName()
  • public IContainerConfigurator WithCircularDependencyTracking(bool runtimeTrackingEnabled = false)
  • public IContainerConfigurator WithCircularDependencyWithLazy()
  • public IContainerConfigurator WithConstructorSelectionRule(Func<IEnumerable<ConstructorInformation>, IEnumerable<ConstructorInformation>> selectionRule)
  • public IContainerConfigurator WithDefaultLifetime(ILifetime lifetime)
  • public IContainerConfigurator WithDisposableTransientTracking()
  • public IContainerConfigurator WithMemberInjectionWithoutAnnotation(AutoMemberInjectionRules rule = 4, Func<TypeInformation, bool> filter = null)
  • public IContainerConfigurator WithMicrosoftExpressionCompiler()
  • public IContainerConfigurator WithNamedDependencyResolutionForUnNamedRequests()
  • public IContainerConfigurator WithOptionalAndDefaultValueInjection()
  • public IContainerConfigurator WithUniqueRegistrationIdentifiers()
  • public IContainerConfigurator WithUnknownTypeResolution(Action<RegistrationConfigurator> configurator = null)
  • public ContainerConfigurator OnContainerConfigurationChanged(Action<ContainerConfiguration> configurationChanged)
  • public ContainerConfigurator TreatParameterAndMemberNameAsDependencyName(bool enabled = true)
  • public ContainerConfigurator WithAdditionalDependencyAttribute<TAttribute>() where TAttribute : Attribute
  • public ContainerConfigurator WithAdditionalDependencyNameAttribute<TAttribute>() where TAttribute : Attribute
  • public ContainerConfigurator WithAutoMemberInjection(AutoMemberInjectionRules rule = 4, Func<MemberInfo, bool> filter = null, bool enabled = true)
  • public ContainerConfigurator WithConstructorSelectionRule(Func<IEnumerable<ConstructorInfo>, IEnumerable<ConstructorInfo>> selectionRule)
  • public ContainerConfigurator WithDefaultLifetime(LifetimeDescriptor lifetime)
  • public ContainerConfigurator WithDefaultValueInjection(bool enabled = true)
  • public ContainerConfigurator WithDisposableTransientTracking(bool enabled = true)
  • public ContainerConfigurator WithExpressionCompiler(Func<LambdaExpression, Delegate> compilerDelegate)
  • public ContainerConfigurator WithLifetimeValidation(bool enabled = true)
  • public ContainerConfigurator WithNamedDependencyResolutionForUnNamedRequests(bool enabled = true)
  • public ContainerConfigurator WithReBuildSingletonsInChildContainer(bool enabled = true)
  • public ContainerConfigurator WithRegistrationBehavior(RegistrationBehavior registrationBehavior)
  • public ContainerConfigurator WithRequiredMemberInjection(bool enabled = true)
  • public ContainerConfigurator WithUniversalName(object name)
  • public ContainerConfigurator WithUnknownTypeResolution(Action<UnknownRegistrationConfigurator> configurator = null, bool enabled = true)
  • public ContainerConfigurator WithVariantGenericTypes(bool enabled = true)
• public static class Rules
  • public static class ExpressionCompilers
  • public enum RegistrationBehavior
  • public static class ServiceRegistrationFilters

Stashbox.ContainerExtension

• public interface IContainerExtension
• public interface IPostBuildExtension : IContainerExtension
• public interface IRegistrationExtension : IContainerExtension

Stashbox.Entity

• public class ConstructorInformation
• public class InjectionParameter
• public class KeyValue<TKey, TValue>
• public class MemberInformation
• public enum MemberType
• public class MethodInformation
• public class TypeInformation

Stashbox.Entity.Resolution

• public class ResolutionConstructor
• public class ResolutionMember
• public class ResolutionMethod

Stashbox.Exceptions

• public class CircularDependencyException : Exception
  • public Type Type { get; }
  • protected CircularDependencyException(SerializationInfo info, StreamingContext context)
• public class CompositionRootNotFoundException : Exception
  • public Assembly Assembly { get; }
  • protected CompositionRootNotFoundException(SerializationInfo info, StreamingContext context)
• public class ConstructorNotFoundException : Exception
  • protected ConstructorNotFoundException(SerializationInfo info, StreamingContext context)
• public class ExceptionBaseException : Exception
• public class InvalidRegistrationException : Exception
  • public Type Type { get; }
  • public InvalidRegistrationException(Type type, string message, Exception innerException = null)
  • protected InvalidRegistrationException(SerializationInfo info, StreamingContext context)
• public class LifetimeValidationFailedException : Exception
  • public Type Type { get; }
  • public LifetimeValidationFailedException(Type type, string message)
  • protected LifetimeValidationFailedException(SerializationInfo info, StreamingContext context)
• public class ResolutionFailedException : Exception
  • public ResolutionFailedException(Type type, string message = "service not registered or unresolvable type requested.", Exception innerException = null)
  • public Type Type { get; }
  • public ResolutionFailedException(Type type, object name = null, string message = "Service is not registered properly or unresolvable type requested.", Exception innerException = null)
  • protected ResolutionFailedException(SerializationInfo info, StreamingContext context)
• public class ServiceAlreadyRegisteredException : Exception
  • public Type Type { get; }
  • public ServiceAlreadyRegisteredException(Type type, Exception innerException = null)
  • protected ServiceAlreadyRegisteredException(SerializationInfo info, StreamingContext context)

Stashbox.Lifetime

• public interface ILifetime
• public abstract class LifetimeBase : ILifetime
• public abstract class ExpressionLifetimeDescriptor : LifetimeDescriptor
  • protected ExpressionLifetimeDescriptor()
  • protected abstract Expression ApplyLifetime(Expression expression, ServiceRegistration serviceRegistration, ResolutionContext resolutionContext, TypeInformation typeInformation)
• public abstract class FactoryLifetimeDescriptor : LifetimeDescriptor
  • protected FactoryLifetimeDescriptor()
  • protected abstract Expression ApplyLifetime(Func<IResolutionScope, IRequestContext, object> factory, ServiceRegistration serviceRegistration, ResolutionContext resolutionContext, TypeInformation typeInformation)
• public abstract class LifetimeDescriptor
  • protected string Name { get; }
  • protected LifetimeDescriptor()
• public static class Lifetimes
  • public static readonly LifetimeDescriptor PerRequest
  • public static readonly LifetimeDescriptor PerScopedRequest
  • public static readonly LifetimeDescriptor Scoped
  • public static readonly LifetimeDescriptor Singleton
  • public static readonly LifetimeDescriptor Transient
  • public static LifetimeDescriptor Auto(LifetimeDescriptor boundaryLifetime)
  • public static LifetimeDescriptor NamedScope(object name)
• public class NamedScopeLifetime : FactoryLifetimeDescriptor
  • public object ScopeName { get; }
  • public readonly object ScopeName
• public class ResolutionRequestLifetime : ScopedLifetimeBase
• public class PerRequestLifetime : FactoryLifetimeDescriptor
  • public PerRequestLifetime()
• public class PerScopedRequestLifetime : TransientLifetime
  • public PerScopedRequestLifetime()
• public abstract class ScopedLifetimeBase : LifetimeBase
• public class TransientLifetime : ExpressionLifetimeDescriptor
  • public TransientLifetime()

Stashbox.Multitenant

• public interface ITenantDistributor : IStashboxContainer, IDependencyRegistrator, IDependencyResolver, IServiceProvider, IAsyncDisposable, IDisposable, IDependencyReMapper, IDependencyCollectionRegistrator, IDecoratorRegistrator, IFuncRegistrator
  • void ConfigureTenant(object tenantId, Action<IStashboxContainer> tenantConfig, bool attachTenantToRoot = true)
  • IDependencyResolver GetTenant(object tenantId)
• public sealed class TenantDistributor : ITenantDistributor, IStashboxContainer, IDependencyRegistrator, IDependencyResolver, IServiceProvider, IAsyncDisposable, IDisposable, IDependencyReMapper, IDependencyCollectionRegistrator, IDecoratorRegistrator, IFuncRegistrator
  • public IEnumerable<ReadOnlyKeyValue<object, IStashboxContainer>> ChildContainers { get; }
  • public IContainerContext ContainerContext { get; }
  • public TenantDistributor(IStashboxContainer rootContainer = null)
  • public object Activate(Type type, ResolutionBehavior resolutionBehavior, object[] arguments)
  • public IDependencyResolver BeginScope(object name = null, bool attachToParent = false)
  • public TTo BuildUp<TTo>(TTo instance, ResolutionBehavior resolutionBehavior = 3)
  • public bool CanResolve(Type typeFrom, object name = null, ResolutionBehavior resolutionBehavior = 3)
  • public IStashboxContainer ComposeBy(Type compositionRootType, object[] compositionRootArguments)
  • public IStashboxContainer ComposeBy(ICompositionRoot compositionRoot)
  • public void Configure(Action<ContainerConfigurator> config)
  • public void ConfigureTenant(object tenantId, Action<IStashboxContainer> tenantConfig, bool attachTenantToRoot = true)
  • public IStashboxContainer CreateChildContainer(Action<ContainerConfigurator> config = null, bool attachToParent = true)
  • public IStashboxContainer CreateChildContainer(object identifier, Action<IStashboxContainer> config = null, bool attachToParent = true)
  • public void Dispose()
  • public ValueTask DisposeAsync()
  • public IStashboxContainer GetChildContainer(object identifier)
  • public IEnumerable<DelegateCacheEntry> GetDelegateCacheEntries()
  • public IEnumerable<RegistrationDiagnosticsInfo> GetRegistrationDiagnostics()
  • public IEnumerable<KeyValuePair<Type, ServiceRegistration>> GetRegistrationMappings()
  • public object GetService(Type serviceType)
  • public IDependencyResolver GetTenant(object tenantId)
  • public ValueTask InvokeAsyncInitializers(CancellationToken token = default)
  • public bool IsRegistered<TFrom>(object name = null)
  • public bool IsRegistered(Type typeFrom, object name = null)
  • public void PutInstanceInScope(Type typeFrom, object instance, bool withoutDisposalTracking = false, object name = null)
  • public IStashboxContainer Register<TFrom, TTo>(Action<RegistrationConfigurator<TFrom, TTo>> configurator) where TTo : TFrom
  • public IStashboxContainer Register<TFrom, TTo>(object name = null) where TTo : TFrom
  • public IStashboxContainer Register<TFrom>(Type typeTo, Action<RegistrationConfigurator<TFrom, TFrom>> configurator = null)
  • public IStashboxContainer Register(Type typeFrom, Type typeTo, Action<RegistrationConfigurator> configurator = null)
  • public IStashboxContainer Register<TTo>(Action<RegistrationConfigurator<TTo, TTo>> configurator)
  • public IStashboxContainer Register<TTo>(object name = null)
  • public IStashboxContainer Register(Type typeTo, Action<RegistrationConfigurator> configurator = null)
  • public IStashboxContainer RegisterDecorator(Type typeFrom, Type typeTo, Action<DecoratorConfigurator> configurator = null)
  • public IStashboxContainer RegisterDecorator<TFrom, TTo>(Action<DecoratorConfigurator<TFrom, TTo>> configurator = null) where TTo : TFrom
  • public IStashboxContainer RegisterDecorator(Type typeTo, Action<DecoratorConfigurator> configurator = null)
  • public IStashboxContainer RegisterDecorator<TTo>(Action<DecoratorConfigurator<TTo, TTo>> configurator = null)
  • public IStashboxContainer RegisterDecorator<TFrom>(Type typeTo, Action<DecoratorConfigurator<TFrom, TFrom>> configurator = null)
  • public IStashboxContainer RegisterFunc<TService>(Func<IDependencyResolver, TService> factory, object name = null)
  • public IStashboxContainer RegisterFunc<T1, TService>(Func<T1, IDependencyResolver, TService> factory, object name = null)
  • public IStashboxContainer RegisterFunc<T1, T2, TService>(Func<T1, T2, IDependencyResolver, TService> factory, object name = null)
  • public IStashboxContainer RegisterFunc<T1, T2, T3, TService>(Func<T1, T2, T3, IDependencyResolver, TService> factory, object name = null)
  • public IStashboxContainer RegisterFunc<T1, T2, T3, T4, TService>(Func<T1, T2, T3, T4, IDependencyResolver, TService> factory, object name = null)
  • public IStashboxContainer RegisterInstance<TInstance>(TInstance instance, object name = null, bool withoutDisposalTracking = false, Action<TInstance> finalizerDelegate = null)
  • public IStashboxContainer RegisterInstance(object instance, Type serviceType, object name = null, bool withoutDisposalTracking = false)
  • public void RegisterResolver(IResolver resolver)
  • public IStashboxContainer RegisterScoped<TFrom, TTo>(object name = null) where TTo : TFrom
  • public IStashboxContainer RegisterScoped(Type typeFrom, Type typeTo, object name = null)
  • public IStashboxContainer RegisterScoped<TTo>(object name = null)
  • public IStashboxContainer RegisterSingleton<TFrom, TTo>(object name = null) where TTo : TFrom
  • public IStashboxContainer RegisterSingleton<TTo>(object name = null)
  • public IStashboxContainer RegisterSingleton(Type typeFrom, Type typeTo, object name = null)
  • public IStashboxContainer RegisterTypes(IEnumerable<Type> types, Func<Type, bool> selector = null, Func<Type, Type, bool> serviceTypeSelector = null, bool registerSelf = true, Action<RegistrationConfigurator> configurator = null)
  • public IStashboxContainer RegisterTypesAs(Type typeFrom, IEnumerable<Type> types, Func<Type, bool> selector = null, Action<RegistrationConfigurator> configurator = null)
  • public IStashboxContainer ReMap<TFrom, TTo>(Action<RegistrationConfigurator<TFrom, TTo>> configurator = null) where TTo : TFrom
  • public IStashboxContainer ReMap<TFrom>(Type typeTo, Action<RegistrationConfigurator<TFrom, TFrom>> configurator = null)
  • public IStashboxContainer ReMap(Type typeFrom, Type typeTo, Action<RegistrationConfigurator> configurator = null)
  • public IStashboxContainer ReMap<TTo>(Action<RegistrationConfigurator<TTo, TTo>> configurator = null)
  • public IStashboxContainer ReMapDecorator(Type typeFrom, Type typeTo, Action<DecoratorConfigurator> configurator = null)
  • public IStashboxContainer ReMapDecorator<TFrom, TTo>(Action<DecoratorConfigurator<TFrom, TTo>> configurator = null) where TTo : TFrom
  • public IStashboxContainer ReMapDecorator<TFrom>(Type typeTo, Action<DecoratorConfigurator<TFrom, TFrom>> configurator = null)
  • public object Resolve(Type typeFrom)
  • public object Resolve(Type typeFrom, object name, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public Delegate ResolveFactory(Type typeFrom, object name = null, ResolutionBehavior resolutionBehavior = 3, Type[] parameterTypes)
  • public Delegate ResolveFactoryOrDefault(Type typeFrom, object name = null, ResolutionBehavior resolutionBehavior = 3, Type[] parameterTypes)
  • public object ResolveOrDefault(Type typeFrom)
  • public object ResolveOrDefault(Type typeFrom, object name, object[] dependencyOverrides, ResolutionBehavior resolutionBehavior = 3)
  • public void Validate()
  • public IStashboxContainer WireUp<TInstance>(TInstance instance, object name = null, bool withoutDisposalTracking = false, Action<TInstance> finalizerDelegate = null)
  • public IStashboxContainer WireUp(object instance, Type serviceType, object name = null, bool withoutDisposalTracking = false)

Stashbox.Registration

• public class AutoMemberOptions
  • public readonly Func<MemberInfo, bool> AutoMemberInjectionFilter
  • public readonly AutoMemberInjectionRules AutoMemberInjectionRule
• public class ConstructorOptions
  • public readonly object[] ConstructorArguments
  • public readonly ConstructorInfo SelectedConstructor
• public class FactoryOptions
  • public readonly Delegate Factory
  • public readonly Type[] FactoryParameters
  • public readonly bool IsFactoryDelegateACompiledLambda
• public interface IDecoratorRepository
  • void AddDecorator(Type type, IServiceRegistration serviceRegistration, bool remap, bool replace)
  • KeyValue<Type, IServiceRegistration>[] GetDecoratorsOrDefault(Type type)
  • void AddDecorator(Type type, ServiceRegistration serviceRegistration, bool remap)
  • IEnumerable<ServiceRegistration> GetDecoratorsOrDefault(Type implementationTypeToDecorate, TypeInformation typeInformation, ResolutionContext resolutionContext)
  • IEnumerable<KeyValuePair<Type, ServiceRegistration>> GetRegistrationMappings()
• public class InstanceOptions
  • public readonly object ExistingInstance
  • public readonly bool IsWireUp
• public interface IRegistrationRepository
  • void AddOrUpdateRegistration(IServiceRegistration registration, Type serviceType, bool remap, bool replace)
  • bool ContainsRegistration(Type type, object name)
  • IEnumerable<KeyValuePair<Type, IServiceRegistration>> GetRegistrationMappings()
  • IServiceRegistration GetRegistrationOrDefault(Type type, ResolutionContext resolutionContext, object name = null)
  • IServiceRegistration GetRegistrationOrDefault(TypeInformation typeInfo, ResolutionContext resolutionContext)
  • IEnumerable<IServiceRegistration> GetRegistrationsOrDefault(TypeInformation typeInfo, ResolutionContext resolutionContext)
  • bool AddOrReMapRegistration(ServiceRegistration registration, Type serviceType)
  • bool AddOrUpdateRegistration(ServiceRegistration registration, Type serviceType)
  • bool ContainsRegistration(Type type, object name, bool includeOpenGenerics = true)
  • IEnumerable<KeyValuePair<Type, ServiceRegistration>> GetRegistrationMappings()
  • ServiceRegistration GetRegistrationOrDefault(TypeInformation typeInfo, ResolutionContext resolutionContext)
  • IEnumerable<ServiceRegistration> GetRegistrationsOrDefault(TypeInformation typeInfo, ResolutionContext resolutionContext)
• public interface IServiceRegistration
• public class RegistrationContext
• public class OpenGenericRegistration : ServiceRegistration
• public struct RegistrationDiagnosticsInfo
  • public readonly Type ImplementationType
  • public readonly object Name
  • public readonly Type ServiceType
  • public RegistrationDiagnosticsInfo(Type serviceType, Type implementationType, object name)
• public enum RegistrationOption
  • AdditionalServiceTypes = 13
  • AsyncInitializer = 6
  • AutoMemberOptions = 2
  • ConditionOptions = 15
  • ConstructorOptions = 1
  • ConstructorSelectionRule = 9
  • DefinedScopeName = 8
  • DependencyBindings = 3
  • Finalizer = 4
  • Initializer = 5
  • InjectionParameters = 14
  • IsLifetimeExternallyOwned = 7
  • IsResolutionCallRequired = 0
  • Metadata = 10
  • RegistrationTypeOptions = 16
  • ReplaceExistingRegistration = 11
  • ReplaceExistingRegistrationOnlyIfExists = 12
  • RequiredMemberInjectionEnabled = 17
• public class ServiceRegistration
  • public ConstructorInformation[] Constructors { get; }
  • public bool HasCondition { get; }
  • public bool HasScopeName { get; }
  • public readonly bool IsDecorator
  • public readonly int RegistrationId
  • public MemberInformation[] InjectionMembers { get; }
  • public MethodInformation[] InjectionMethods { get; }
  • public bool IsDecorator { get; }
  • public bool IsResolvableByUnnamedRequest { get; }
  • public RegistrationContext RegistrationContext { get; }
  • public int RegistrationId { get; }
  • public object RegistrationName { get; }
  • public ConstructorInformation SelectedConstructor { get; }
  • public bool ShouldHandleDisposal { get; }
  • public bool CanInjectIntoNamedScope(IEnumerable<object> scopeNames)
  • public IServiceRegistration Clone(Type implementationType, IObjectBuilder objectBuilder)
  • public Expression GetExpression(IContainerContext containerContext, ResolutionContext resolutionContext, Type resolveType)
  • public void InheritIdFrom(IServiceRegistration serviceRegistration)
  • public bool IsUsableForCurrentContext(TypeInformation typeInfo)
  • public bool ValidateGenericConstraints(Type type)
  • public LifetimeDescriptor Lifetime { get; }
  • public object Name { get; }
  • public IReadOnlyDictionary<RegistrationOption, object> RegistrationOptions { get; }
  • public int RegistrationOrder { get; }
  • public int GetDiscriminator(TypeInformation typeInformation, ContainerConfiguration containerConfiguration)

Stashbox.Registration.Fluent

• public class BaseDecoratorConfigurator<TConfigurator> : BaseFluentConfigurator<TConfigurator> where TConfigurator : BaseDecoratorConfigurator<TConfigurator>
  • public TConfigurator WhenDecoratedServiceHas<TAttribute>() where TAttribute : Attribute
  • public TConfigurator WhenDecoratedServiceHas(Type attributeType)
  • public TConfigurator WhenDecoratedServiceIs<TTarget>()
  • public TConfigurator WhenDecoratedServiceIs(Type targetType)
  • public TConfigurator WhenDecoratedServiceIs(object name)
• public class BaseFluentConfigurator<TConfigurator> : ServiceRegistration where TConfigurator : BaseFluentConfigurator<TConfigurator>
  • public TConfigurator InjectMember(string memberName, object dependencyName = null)
  • public Type ServiceType { get; }
  • public TConfigurator AsImplementedTypes()
  • public TConfigurator AsServiceAlso<TAdditionalService>()
  • public TConfigurator AsServiceAlso(Type serviceType)
  • public bool HasServiceType<TService>()
  • public bool HasServiceType(Type serviceType)
  • public TConfigurator InNamedScope(object scopeName)
  • public TConfigurator InScopeDefinedBy(Type type)
  • public TConfigurator InScopeDefinedBy<TScopeDefiner>()
  • public TConfigurator WithAutoMemberInjection(AutoMemberInjectionRules rule = 4, Func<TypeInformation, bool> filter = null)
  • public TConfigurator ReplaceOnlyIfExists()
  • public TConfigurator When(Func<TypeInformation, bool> resolutionCondition)
  • public TConfigurator WhenDependantIs<TTarget>(object name = null)
  • public TConfigurator WhenDependantIs(Type targetType, object name = null)
  • public TConfigurator WhenHas<TAttribute>(object name = null) where TAttribute : Attribute
  • public TConfigurator WhenHas(Type attributeType)
  • public TConfigurator WhenInResolutionPathOf<TTarget>(object name = null)
  • public TConfigurator WhenInResolutionPathOf(Type targetType, object name = null)
  • public TConfigurator WhenResolutionPathHas<TAttribute>(object name = null) where TAttribute : Attribute
  • public TConfigurator WhenResolutionPathHas(Type attributeType, object name = null)
  • public TConfigurator WithAutoLifetime(LifetimeDescriptor boundaryLifetime)
  • public TConfigurator WithAutoMemberInjection(AutoMemberInjectionRules rule = 4, Func<MemberInfo, bool> filter = null)
  • public TConfigurator WithConstructorSelectionRule(Func<IEnumerable<ConstructorInformation>, IEnumerable<ConstructorInformation>> rule)
  • public TConfigurator WithConstructorSelectionRule(Func<IEnumerable<ConstructorInfo>, IEnumerable<ConstructorInfo>> rule)
  • public TConfigurator WithDependencyBinding<TDependency>(object dependencyName = null)
  • public TConfigurator WithInjectionParameters(InjectionParameter[] injectionParameters)
  • public TConfigurator WithInjectionParameters(KeyValuePair<string, object>[] injectionParameters)
  • public TConfigurator WithLifetime(LifetimeDescriptor lifetime)
  • public TConfigurator WithoutFactoryCache()
  • public TConfigurator WithPerRequestLifetime()
  • public TConfigurator WithPerScopedRequestLifetime()
  • public TConfigurator WithRequiredMemberInjection(bool enabled = true)
  • public TConfigurator WithScopedLifetime()
  • public TConfigurator WithSingletonLifetime()
  • public TConfigurator WithTransientLifetime()
• public class DecoratorConfigurator : BaseDecoratorConfigurator<DecoratorConfigurator>
  • public DecoratorConfigurator WithFactory(Func<IDependencyResolver, object> factory, bool isCompiledLambda = false)
  • public DecoratorConfigurator WithFactory(Func<object> factory, bool isCompiledLambda = false)
  • public DecoratorConfigurator WithFactory<T1>(Func<T1, object> factory, bool isCompiledLambda = false)
  • public DecoratorConfigurator WithFactory<T1, T2>(Func<T1, T2, object> factory, bool isCompiledLambda = false)
  • public DecoratorConfigurator WithFactory<T1, T2, T3>(Func<T1, T2, T3, object> factory, bool isCompiledLambda = false)
  • public DecoratorConfigurator WithFactory<T1, T2, T3, T4>(Func<T1, T2, T3, T4, object> factory, bool isCompiledLambda = false)
  • public DecoratorConfigurator WithFactory<T1, T2, T3, T4, T5>(Func<T1, T2, T3, T4, T5, object> factory, bool isCompiledLambda = false)
• public class DecoratorConfigurator<TService, TImplementation> : BaseDecoratorConfigurator<DecoratorConfigurator<TService, TImplementation>> where TImplementation : TService
  • public DecoratorConfigurator<TService, TImplementation> WithAsyncInitializer(Func<TImplementation, IDependencyResolver, CancellationToken, Task> initializer)
  • public DecoratorConfigurator<TService, TImplementation> WithDependencyBinding<TResult>(Expression<Func<TImplementation, TResult>> expression, object dependencyName = null)
  • public DecoratorConfigurator<TService, TImplementation> WithFactory(Func<TImplementation> factory, bool isCompiledLambda = false)
  • public DecoratorConfigurator<TService, TImplementation> WithFactory(Func<IDependencyResolver, TImplementation> factory, bool isCompiledLambda = false)
  • public DecoratorConfigurator<TService, TImplementation> WithFactory<T1>(Func<T1, TImplementation> factory, bool isCompiledLambda = false)
  • public DecoratorConfigurator<TService, TImplementation> WithFactory<T1, T2>(Func<T1, T2, TImplementation> factory, bool isCompiledLambda = false)
  • public DecoratorConfigurator<TService, TImplementation> WithFactory<T1, T2, T3>(Func<T1, T2, T3, TImplementation> factory, bool isCompiledLambda = false)
  • public DecoratorConfigurator<TService, TImplementation> WithFactory<T1, T2, T3, T4>(Func<T1, T2, T3, T4, TImplementation> factory, bool isCompiledLambda = false)
  • public DecoratorConfigurator<TService, TImplementation> WithFactory<T1, T2, T3, T4, T5>(Func<T1, T2, T3, T4, T5, TImplementation> factory, bool isCompiledLambda = false)
  • public DecoratorConfigurator<TService, TImplementation> WithFinalizer(Action<TImplementation> finalizer)
  • public DecoratorConfigurator<TService, TImplementation> WithInitializer(Action<TImplementation, IDependencyResolver> initializer)
• public class FluentServiceConfigurator<TConfigurator> : BaseFluentConfigurator<TConfigurator> where TConfigurator : FluentServiceConfigurator<TConfigurator>
  • public TConfigurator AsImplementedTypes()
  • public TConfigurator AsServiceAlso(Type serviceType)
  • public TConfigurator InNamedScope(object scopeName)
  • public TConfigurator InScopeDefinedBy(Type type)
  • public TConfigurator InScopeDefinedBy<TScopeDefiner>()
  • public TConfigurator When(Func<TypeInformation, bool> resolutionCondition)
  • public TConfigurator WhenDependantIs<TTarget>()
  • public TConfigurator WhenDependantIs(Type targetType)
  • public TConfigurator WhenHas<TAttribute>() where TAttribute : Attribute
  • public TConfigurator WhenHas(Type attributeType)
  • public TConfigurator WithDynamicResolution()
  • public TConfigurator WithInstance(object instance, bool wireUp = false)
  • public TConfigurator WithLifetime(ILifetime lifetime)
  • public TConfigurator WithFactory<T1>(Func<T1, object> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFactory<T1, T2>(Func<T1, T2, object> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFactory<T1, T2, T3>(Func<T1, T2, T3, object> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFactory<T1, T2, T3, T4>(Func<T1, T2, T3, T4, object> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFactory<T1, T2, T3, T4, T5>(Func<T1, T2, T3, T4, T5, object> factory, bool isCompiledLambda = false)
  • public TConfigurator WithMetadata(object metadata)
  • public TConfigurator WithPerResolutionRequestLifetime()
  • public TConfigurator WithScopedLifetime()
  • public TConfigurator WithSingletonLifetime()
• public class FluentServiceConfigurator<TService, TConfigurator> : FluentServiceConfigurator<TConfigurator>, IFluentServiceConfigurator<TService, TConfigurator>, IFluentServiceConfigurator<TConfigurator>, IBaseFluentConfigurator<TConfigurator> where TConfigurator : FluentServiceConfigurator<TService, TConfigurator>
• public interface IBaseFluentConfigurator<TFluentConfigurator> where TFluentConfigurator : IBaseFluentConfigurator<TFluentConfigurator>
• public interface IFluentServiceConfigurator<TConfigurator> : IBaseFluentConfigurator<TConfigurator> where TConfigurator : IFluentServiceConfigurator<TConfigurator>
• public interface IFluentServiceConfigurator<TService, TConfigurator> : IFluentServiceConfigurator<TConfigurator>, IBaseFluentConfigurator<TConfigurator> where TConfigurator : IFluentServiceConfigurator<TService, TConfigurator>
• public class RegistrationConfiguration
• public class FluentServiceConfigurator<TService, TImplementation, TConfigurator> : FluentServiceConfigurator<TConfigurator> where TImplementation : TService where TConfigurator : FluentServiceConfigurator<TService, TImplementation, TConfigurator>
  • public TConfigurator WithAsyncInitializer(Func<TImplementation, IDependencyResolver, CancellationToken, Task> initializer)
  • public TConfigurator WithDependencyBinding<TResult>(Expression<Func<TImplementation, TResult>> expression, object dependencyName = null)
  • public TConfigurator WithFactory(Func<TImplementation> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFactory<TImpl>(Func<TImpl> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFactory(Func<IDependencyResolver, TImplementation> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFactory<TImpl>(Func<IDependencyResolver, TImpl> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFactory<T1>(Func<T1, TImplementation> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFactory<T1, TImpl>(Func<T1, TImpl> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFactory<T1, T2>(Func<T1, T2, TImplementation> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFactory<T1, T2, T3>(Func<T1, T2, T3, TImplementation> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFactory<T1, T2, T3, T4>(Func<T1, T2, T3, T4, TImplementation> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFactory<T1, T2, T3, T4, T5>(Func<T1, T2, T3, T4, T5, TImplementation> factory, bool isCompiledLambda = false)
  • public TConfigurator WithFinalizer(Action<TImplementation> finalizer)
  • public TConfigurator WithInitializer(Action<TImplementation, IDependencyResolver> initializer)
• public class RegistrationConfigurator : FluentServiceConfigurator<RegistrationConfigurator>
  • public RegistrationConfigurator WithInstance(object instance, bool wireUp = false)
• public class RegistrationConfigurator<TService> : FluentServiceConfigurator<TService, RegistrationConfigurator<TService>>
• public class RegistrationConfigurator<TService, TImplementation> : FluentServiceConfigurator<TService, TImplementation, RegistrationConfigurator<TService, TImplementation>> where TImplementation : TService
  • public RegistrationConfigurator<TService, TImplementation> WithInstance(TService instance, bool wireUp = false)
• public class UnknownRegistrationConfigurator : RegistrationConfigurator
  • public UnknownRegistrationConfigurator SetImplementationType(Type implementationType)
  • public UnknownRegistrationConfigurator Skip()

Stashbox.Resolution

• public interface IMultiServiceResolver : IResolver
• public struct DelegateCacheEntry
  • public readonly Func<IResolutionScope, IRequestContext, object> CachedDelegate
  • public readonly IEnumerable<NamedCacheEntry> NamedCacheEntries
  • public readonly ResolutionBehavior ResolutionBehavior
  • public readonly Type ServiceType
  • public DelegateCacheEntry(Type serviceType, Func<IResolutionScope, IRequestContext, object> cachedDelegate, IEnumerable<NamedCacheEntry> namedCacheEntries, ResolutionBehavior resolutionBehavior)
• public interface IEnumerableSupportedResolver : IServiceResolver, IResolver
  • IEnumerable<ServiceContext> GetExpressionsForEnumerableRequest(IResolutionStrategy resolutionStrategy, TypeInformation typeInfo, ResolutionContext resolutionContext)
• public interface IEnumerableWrapper : IResolver
  • bool TryUnWrap(Type type, out Type unWrappedType)
  • Expression WrapExpression(TypeInformation originalTypeInformation, TypeInformation wrappedTypeInformation, IEnumerable<ServiceContext> serviceContexts)
• public interface IMetadataWrapper : IResolver
  • bool TryUnWrap(Type type, out Type unWrappedType, out Type metadataType)
  • Expression WrapExpression(TypeInformation originalTypeInformation, TypeInformation wrappedTypeInformation, ServiceContext serviceContext)
• public interface IParameterizedWrapper : IResolver
  • bool TryUnWrap(Type type, out Type unWrappedType, out IEnumerable parameterTypes)
  • Expression WrapExpression(TypeInformation originalTypeInformation, TypeInformation wrappedTypeInformation, ServiceContext serviceContext, IEnumerable<ParameterExpression> parameterExpressions)
• public interface IRequestContext
  • TInstance ExcludeFromTracking<TInstance>(TInstance value)
  • object GetDependencyOverrideOrDefault(Type dependencyType)
  • TResult GetDependencyOverrideOrDefault<TResult>()
  • object[] GetOverrides()
• public interface IResolutionStrategy
  • Expression[] BuildAllResolutionExpressions(IContainerContext containerContext, ResolutionContext resolutionContext, TypeInformation typeInformation)
  • Expression BuildResolutionExpression(IContainerContext containerContext, ResolutionContext resolutionContext, TypeInformation typeInformation, IEnumerable<InjectionParameter> injectionParameters = null, bool forceSkipUnknownTypeCheck = false)
  • ServiceContext BuildExpressionForRegistration(ServiceRegistration serviceRegistration, ResolutionContext resolutionContext, TypeInformation typeInformation)
  • ServiceContext BuildExpressionForType(ResolutionContext resolutionContext, TypeInformation typeInformation)
  • IEnumerable<ServiceContext> BuildExpressionsForEnumerableRequest(ResolutionContext resolutionContext, TypeInformation typeInformation)
  • bool IsTypeResolvable(ResolutionContext resolutionContext, TypeInformation typeInformation)
  • void RegisterResolver(IResolver resolver)
• public interface IResolver
  • bool CanUseForResolution(IContainerContext containerContext, TypeInformation typeInfo, ResolutionContext resolutionContext)
  • Expression GetExpression(IContainerContext containerContext, IResolutionStrategy resolutionStrategy, TypeInformation typeInfo, ResolutionContext resolutionContext)
• public interface IServiceResolver : IResolver
  • bool CanUseForResolution(TypeInformation typeInfo, ResolutionContext resolutionContext)
  • ServiceContext GetExpression(IResolutionStrategy resolutionStrategy, TypeInformation typeInfo, ResolutionContext resolutionContext)
• public interface IServiceWrapper : IResolver
  • bool TryUnWrap(Type type, out Type unWrappedType)
  • Expression WrapExpression(TypeInformation originalTypeInformation, TypeInformation wrappedTypeInformation, ServiceContext serviceContext)
• public struct NamedCacheEntry
  • public readonly Func<IResolutionScope, IRequestContext, object> CachedDelegate
  • public readonly object Name
  • public NamedCacheEntry(object name, Func<IResolutionScope, IRequestContext, object> cachedDelegate)
• public enum ResolutionBehavior
  • Current = 2
  • Default = 3
  • Parent = 1
  • ParentDependency = 4
• public class ResolutionContext
  • public ParameterExpression CurrentScopeParameter { get; }
  • public bool NullResultAllowed { get; }
  • public static ResolutionContext New(IResolutionScope scope, bool nullResultAllowed = false, object[] dependencyOverrides = null)
  • public void AddDefinedVariable(object key, ParameterExpression parameter)
  • public readonly IContainerContext CurrentContainerContext
  • public readonly ParameterExpression CurrentScopeParameter
  • public readonly bool IsRequestedFromRoot
  • public readonly bool NullResultAllowed
  • public readonly ParameterExpression RequestContextParameter
  • public readonly ResolutionBehavior ResolutionBehavior
  • public void AddDefinedVariable(int key, ParameterExpression parameter)
  • public ParameterExpression GetKnownVariableOrDefault(object key)
• public struct ServiceContext
  • public readonly Expression ServiceExpression
  • public readonly ServiceRegistration ServiceRegistration
  • public ServiceContext(Expression serviceExpression, ServiceRegistration serviceRegistration)
• public class TypeInformation
  • public readonly IEnumerable<Attribute> CustomAttributes
  • public readonly object DefaultValue
  • public readonly object DependencyName
  • public readonly bool HasDefaultValue
  • public readonly Type MetadataType
  • public readonly string ParameterOrMemberName
  • public readonly TypeInformation Parent
  • public readonly Type ParentType
  • public readonly Type Type
  • public bool HasDependencyNameAttribute { get; set; }
  • public TypeInformation Clone(Type type, object dependencyName = null, Type metadataType = null)

Stashbox.Utils

• public static class Shield
  • public static void EnsureNotNull<T>(Expression<Func<T>> memberExpression)
  • public static void EnsureNotNull<T>(Expression<Func<T>> memberExpression, string message)
  • public static void EnsureNotNullOrEmpty(Expression<Func<string>> memberExpression)

System.Linq.Expressions

• public static class ExpressionExtensions
  • public static BlockExpression AsBlock(this IList<Expression> expressions, ParameterExpression[] variables)
  • public static BlockExpression AsBlock(this IEnumerable<Expression> expressions, ParameterExpression[] variables)
  • public static LambdaExpression AsLambda(this Expression expression, Type delegateType, IEnumerable<ParameterExpression> parameters)
  • public static ServiceContext AsServiceContext(this Expression expression, ServiceRegistration serviceRegistration = null)
  • public static MethodCallExpression CallMethod(this Expression target, MethodInfo methodInfo, IEnumerable<Expression> parameters)
  • public static MethodCallExpression CallMethod(this MethodInfo methodInfo, Expression target, IEnumerable<Expression> parameters)
  • public static Func<IResolutionScope, object> CompileDelegate(this Expression expression, ResolutionContext resolutionContext, ContainerConfiguration containerConfiguration)
  • public static MethodCallExpression CallStaticMethod(this MethodInfo methodInfo, IEnumerable<Expression> parameters)
  • public static Func<IResolutionScope, IRequestContext, object> CompileDelegate(this Expression expression, ResolutionContext resolutionContext, ContainerConfiguration containerConfiguration)
  • public static Func<IResolutionScope, Delegate> CompileDynamicDelegate(this Expression expression, ResolutionContext resolutionContext, ContainerConfiguration containerConfiguration)
  • public static Func<IResolutionScope, IRequestContext, Delegate> CompileDynamicDelegate(this Expression expression, ResolutionContext resolutionContext, ContainerConfiguration containerConfiguration)
  • public static MemberInitExpression InitMembers(this Expression expression, IList<MemberBinding> bindings)
  • public static MemberInitExpression InitMembers(this Expression expression, IEnumerable<MemberBinding> bindings)
  • public static MemberInitExpression InitMembers(this Expression expression, MemberBinding[] bindings)
  • public static NewArrayExpression InitNewArray(this Type type, IEnumerable<Expression> initializerExpressions)
  • public static InvocationExpression InvokeDelegate(this Delegate delegate, IEnumerable<Expression> parameters)