private StatusCodeResult(HttpStatusCode statusCode, IDependencyProvider dependencies)
{
Contract.Assert(dependencies != null);
_statusCode = statusCode;
_dependencies = dependencies;
}
private ReferencedExceptionResult(Exception exception, IDependencyProvider dependencies)
{
if (exception == null)
{
throw new ArgumentNullException("exception");
}
Contract.Assert(dependencies != null);
_exception = exception;
_dependencies = dependencies;
}
private ServiceUnavailableExceptionResult(
ServiceUnavailableException exception, IDependencyProvider dependencies)
{
if (exception == null)
{
throw new ArgumentNullException("exception");
}
Contract.Assert(dependencies != null);
_exception = exception;
_dependencies = dependencies;
}
private RedirectToRouteResult(string routeName, IDictionary<string, object> routeValues,
IDependencyProvider dependencies)
{
if (routeName == null)
{
throw new ArgumentNullException("routeName");
}
Contract.Assert(dependencies != null);
_routeName = routeName;
_routeValues = routeValues;
_dependencies = dependencies;
}
protected void TryCatchUnResolvable <T>(IDependencyProvider provider)
{
bool isResolved = false;
try
{
T service = provider.Resolve <T>();
isResolved = true;
}
catch (DependencyResolutionFailedException)
{ }
if (isResolved)
{
Assert.Fail("Should not be resolvable.");
}
}
private void EnsureResolved()
{
if (_resolvedDependencies == null)
{
HttpConfiguration configuration = _controller.Configuration;
if (configuration == null)
{
throw new InvalidOperationException(
SRResources.HttpControllerContext_ConfigurationMustNotBeNull
);
}
ServicesContainer services = configuration.Services;
Contract.Assert(services != null);
IContentNegotiator contentNegotiator = services.GetContentNegotiator();
if (contentNegotiator == null)
{
throw new InvalidOperationException(
Error.Format(
SRResources.HttpRequestMessageExtensions_NoContentNegotiator,
typeof(IContentNegotiator)
)
);
}
HttpRequestMessage request = _controller.Request;
if (request == null)
{
throw new InvalidOperationException(
SRResources.ApiController_RequestMustNotBeNull
);
}
IEnumerable <MediaTypeFormatter> formatters = configuration.Formatters;
Contract.Assert(formatters != null);
_resolvedDependencies = new DirectDependencyProvider(
contentNegotiator,
request,
formatters
);
}
}
public void GenericsTypeResolveTest()
{
_dependencyConfig.Register <IGenericInterface <ISimpleInterface>, GenericImplementation1 <ISimpleInterface> >();
_dependencyConfig.Register <IGenericInterface <ISimpleInterface>, GenericImplementation2 <ISimpleInterface> >();
_dependencyProvider = new DependencyProvider(_dependencyConfig);
var instances = _dependencyProvider.Resolve <IGenericInterface <ISimpleInterface> >();
Assert.AreEqual(2, instances.Count());
List <Type> expectedInstancesTypes = new List <Type>
{
typeof(GenericImplementation1 <ISimpleInterface>),
typeof(GenericImplementation2 <ISimpleInterface>)
};
CollectionAssert.AreEquivalent(expectedInstancesTypes,
instances.Select((instance) => instance.GetType()).ToList());
}
private RedirectToRouteResult(
string routeName,
IDictionary <string, object> routeValues,
IDependencyProvider dependencies
)
{
if (routeName == null)
{
throw new ArgumentNullException("routeName");
}
Contract.Assert(dependencies != null);
_routeName = routeName;
_routeValues = routeValues;
_dependencies = dependencies;
}
public void NonGenericTypeResolveTest()
{
config.Register <IMyInterface, MyImplementation1>();
config.Register <IMyInterface, MyImplementation2>();
provider = new DependencyProvider(config);
var instances = provider.Resolve <IMyInterface>();
Assert.AreEqual(2, instances.Count());
List <Type> expectedInstancesTypes = new List <Type>
{
typeof(MyImplementation1),
typeof(MyImplementation2)
};
CollectionAssert.AreEquivalent(expectedInstancesTypes,
instances.Select((instance) => instance.GetType()).ToList());
}
private void EnsureResolved()
{
if (_resolvedDependencies == null)
{
HttpRequestMessage request = _controller.Request;
if (request == null)
{
throw new InvalidOperationException(
SRResources.ApiController_RequestMustNotBeNull
);
}
UrlHelper urlFactory = _controller.Url ?? new UrlHelper(request);
_resolvedDependencies = new DirectDependencyProvider(urlFactory, request);
}
}
private CreatedAtRouteNegotiatedContentResult(
string routeName,
IDictionary <string, object> routeValues,
T content,
IDependencyProvider dependencies
)
{
if (routeName == null)
{
throw new ArgumentNullException("routeName");
}
Contract.Assert(dependencies != null);
_routeName = routeName;
_routeValues = routeValues;
_content = content;
_dependencies = dependencies;
}
public void Basic_Resolution()
{
IServiceCollection services = new ServiceCollection();
services.AddMvcCore();
services.AddXPikeDependencyInjection((options) => { })
.LoadPackage(new TestPackage());
IServiceProvider provider = services.BuildServiceProvider();
IApplicationBuilder app = new ApplicationBuilder(provider);
IDependencyProvider dependencyProvider = app.UseXPikeDependencyInjection((options) => { });
dependencyProvider.Verify();
var config = dependencyProvider.ResolveDependency <IFoo>();
Assert.IsInstanceOfType(config, typeof(Foo));
}
public static TinyIoCContainer.RegisterOptions RegisterWithProviderType(this TinyIoCContainer container,
Type targetType,
Type asProviderType,
IDependencyResolver resolver)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (targetType == null)
{
throw new ArgumentNullException(nameof(targetType));
}
if (asProviderType == null)
{
throw new ArgumentNullException(nameof(asProviderType));
}
if (resolver == null)
{
throw new ArgumentNullException(nameof(resolver));
}
return(container.Register(targetType, (c, p) =>
{
IDependencyProvider provider = Activator.CreateInstance(asProviderType)
as IDependencyProvider;
if (provider == null)
{
throw new InvalidOperationException($"{targetType} is not a valid provider instance");
}
return CreateoObjectWithProvider(targetType,
provider,
resolver);
}));
}
private void EnsureResolved()
{
if (_resolvedDependencies == null)
{
HttpRequestContext requestContext = _controller.RequestContext;
Contract.Assert(requestContext != null);
bool includeErrorDetail = requestContext.IncludeErrorDetail;
HttpConfiguration configuration = _controller.Configuration;
if (configuration == null)
{
throw new InvalidOperationException("HttpControllerContext.Configuration must not be null."
/*SRResources.HttpControllerContext_ConfigurationMustNotBeNull*/);
}
ServicesContainer services = configuration.Services;
Contract.Assert(services != null);
IContentNegotiator contentNegotiator = services.GetContentNegotiator();
if (contentNegotiator == null)
{
throw new InvalidOperationException(Error.Format("The provided configuration does not have an instance of the '{0}' service registered."
/*SRResources.HttpRequestMessageExtensions_NoContentNegotiator*/, typeof(IContentNegotiator)));
}
HttpRequestMessage request = _controller.Request;
if (request == null)
{
throw new InvalidOperationException("ApiController.Request must not be null." /*SRResources.ApiController_RequestMustNotBeNull*/);
}
IEnumerable <MediaTypeFormatter> formatters = configuration.Formatters;
Contract.Assert(formatters != null);
_resolvedDependencies = new DirectDependencyProvider(includeErrorDetail, contentNegotiator, request,
formatters);
}
}
/// <summary>
/// Retrieves dependencies from the module persistent state.
/// </summary>
/// <param name="module">Python module to restore analysis for.</param>
/// <param name="dp">Python module dependency provider.</param>
public bool TryRestoreDependencies(IPythonModule module, out IDependencyProvider dp)
{
dp = null;
if (GetCachingLevel() == AnalysisCachingLevel.None || !module.ModuleType.CanBeCached())
{
return(false);
}
if (_dependencies.TryGetValue(module.Name, out dp))
{
return(true);
}
if (FindModuleModel(module.Name, module.FilePath, module.ModuleType, out var model))
{
dp = new DependencyProvider(module, model);
_dependencies[module.Name] = dp;
return(true);
}
return(false);
}
/// <summary>
/// Creates a new instance of <see cref="DefaultComponentsStore"/>.
/// </summary>
/// <param name="dependencyProvider">Dependency provider.</param>
internal DefaultComponentsStore(IDependencyProvider dependencyProvider)
{
DependencyHolder = dependencyProvider.ToInstanceHolder();
AspectFinalizer = new InstanceComponentHolder <IAspectFinalizer>(new DisposeAspectFinalizer());
AspectSelector = new InstanceComponentHolder <IAspectSelector>(new AspectSelector());
AspectWeavePredicate = new InstanceComponentHolder <IAspectWeavePredicate>(
new DeclaringTypeWeavePredicate(AspectSelector));
AspectDeclarationCollector = new InstanceComponentHolder <IAspectDeclarationCollector>(
new DeclaringTypeAspectDeclarationCollector(AspectSelector));
PipelineFactory = new InstanceComponentHolder <IInvocationPipelineFactory>(
new AsyncDeterminingPipelineFactory(
MethodInfoCache.Instance, ConcurrentDictionaryCacheFactory.Default));
AspectOrderStrategy = new InstanceComponentHolder <IAspectOrderStrategy>(
new AspectOrderStrategy());
var aspectDependencySelectorHolder = new InstanceComponentHolder <IAspectDependencySelector>(
new CachedAspectDependencySelector(
new AspectDependencySelector(),
CacheDelegateFactory <ConcurrentDictionaryCacheFactory> .Instance));
AspectFactory = new InstanceComponentHolder <IAspectFactory>(
new AspectFactory(
AspectDeclarationCollector,
AspectOrderStrategy,
aspectDependencySelectorHolder,
AspectFinalizer));
AspectDependencyInjector = new LazyComponentHolder <IAspectDependencyInjector>(
() => new AspectDependencyInjector(DependencyHolder, aspectDependencySelectorHolder));
WeaveDataProviderFactory = new InstanceComponentHolder <IInvocationWeaveDataProviderFactory>(
new InvocationWeaveDataProviderFactory(
AspectWeavePredicate, AspectFactory, PipelineFactory,
ConcurrentDictionaryCacheFactory.Default));
}
public void Base()
{
IDependencyContainer root = new SimpleDependencyContainer();
IReflectionService reflectionService = ReflectionFactory.FromCurrentAppDomain();
using (ITypeExecutorService executorService = reflectionService.PrepareTypeExecutors())
{
executorService.AddDependencies(root);
}
root.Resolve <IOutputWriter>();
using (IDependencyProvider s1 = root.Scope("S1"))
{
s1.Resolve <Counter>();
s1.Resolve <Counter>();
s1.Resolve <Counter>();
Assert.AreEqual(1, Counter.count);
}
}
public void GetDependencyWithScope()
{
IDependencyCollection collection = new DependencyCollection();
collection.AddSingleton <DependencyWithScope, DependencyWithScope>();
using (ILifetimeScope scope = collection.CreateScope())
{
using (IDependencyProvider provider = scope.BuildProvider())
{
DependencyWithScope dependency = Should.NotThrow(provider.GetDependency <DependencyWithScope>);
dependency.ShouldNotBeNull();
dependency.Scope.ShouldNotBeNull();
}
}
using (IDependencyProvider provider = collection.BuildProvider())
{
Should.Throw <InvalidScopeException>(provider.GetDependency <DependencyWithScope>);
}
}
internal AutoDependencyBinder(IDependencyProvider dependencyProvider)
{
_dp = dependencyProvider;
Modules = TypesCache.AppDomainTypes
.Where(x => typeof(IDependencyModule).IsAssignableFrom(x) && x.IsNonDynamicallyGeneratedConcreteClass())
.Select(x => Activator.CreateInstance(x).DirectCastTo <IDependencyModule>())
.OrderBy(x => x.Priority)
.ToArray();
ScannedTypes = Modules.Select(x => x.GetType().Assembly).Distinct()
.SelectMany(x => x.GetTypes()).Union(typeof(AutoDependencyBinder).Assembly.GetTypes())
.Distinct().ToArray();
ExtraDependencyTypesAlwaysFresh = Modules.Where(x => x.ExtraDependencyTypesAlwaysFresh != null)
.SelectMany(x => x.ExtraDependencyTypesAlwaysFresh).Distinct().ToArray();
ExtraDependencyGenericTypesAlwaysFresh = Modules
.Where(x => x.ExtraDependencyGenericTypesAlwaysFresh != null)
.SelectMany(x => x.ExtraDependencyGenericTypesAlwaysFresh).Distinct().ToArray();
ExtraDependencyTypesPerRequest = Modules.Where(x => x.ExtraDependencyTypesPerRequest != null)
.SelectMany(x => x.ExtraDependencyTypesPerRequest).Distinct().ToArray();
ExtraDependencyGenericTypesPerRequest = Modules.Where(x => x.ExtraDependencyGenericTypesPerRequest != null)
.SelectMany(x => x.ExtraDependencyGenericTypesPerRequest).Distinct().ToArray();
ExtraDependencyTypesGlobalSingleton = Modules.Where(x => x.ExtraDependencyTypesGlobalSingleton != null)
.SelectMany(x => x.ExtraDependencyTypesGlobalSingleton).Distinct().ToArray();
ExtraDependencyGenericTypesGlobalSingleton = Modules
.Where(x => x.ExtraDependencyGenericTypesGlobalSingleton != null)
.SelectMany(x => x.ExtraDependencyGenericTypesGlobalSingleton).Distinct().ToArray();
ExtraTargetTypes = Modules.Where(x => x.ExtraTargetTypes != null)
.SelectMany(x => x.ExtraTargetTypes).Distinct().ToArray();
ExtraTargetGenericTypes = Modules.Where(x => x.ExtraTargetGenericTypes != null)
.SelectMany(x => x.ExtraTargetGenericTypes).Distinct().ToArray();
IgnoredTargetTypes = Modules.Where(x => x.IgnoredTargetTypes != null)
.SelectMany(x => x.IgnoredTargetTypes).Distinct().ToArray();
}
public void GetDependencyWithProvider()
{
IDependencyCollection collection = new DependencyCollection();
collection.AddScoped <DependencyWithProvider, DependencyWithProvider>();
using (IDependencyProvider provider = collection.BuildProvider())
{
DependencyWithProvider dependency = Should.NotThrow(provider.GetDependency <DependencyWithProvider>);
dependency.ShouldNotBeNull();
dependency.Provider.ShouldNotBeNull();
}
collection = new DependencyCollection();
collection.AddSingleton <DependencyWithProvider, DependencyWithProvider>();
using (IDependencyProvider provider = collection.BuildProvider())
{
Should.Throw <SingletonDependencyException>(provider.GetDependency <DependencyWithProvider>);
}
}
public void DependencyInTextScope()
{
IDependencyContainer root = CreateContainer();
root.Definitions
.AddTransient <IHelloService, HiService>()
.AddScoped <IMessageFormatter, StringMessageFormatter>("S1");
IHelloService helloService;
TryCatchUnResolvable <IHelloService>(root);
using (IDependencyProvider s1 = root.Scope("S1"))
{
TryCatchUnResolvable <IHelloService>(root);
helloService = s1.Resolve <IHelloService>();
Assert.IsTrue(s1.TryResolve <IHelloService>(out helloService));
}
TryCatchUnResolvable <IHelloService>(root);
Assert.IsFalse(root.TryResolve <IHelloService>(out helloService));
}
/// <summary>
/// Register callback and associate query result set with the command
/// </summary>
private void RegisterNotification()
{
try
{
string fullAssemblyName = "Alachisoft.NCache.NosDBCacheDependency, Version=" + ServiceConfiguration.NosDBDependencyProviderVersion + ", Culture=neutral, PublicKeyToken=cff5926ed6a53769, processorArchitecture=MSIL";
Assembly assembly = Assembly.Load(fullAssemblyName);
Type providerType = assembly.GetType("Alachisoft.NCache.NosDBCacheDependency.NosDBDependencyProvider");
if (providerType == null)
{
throw new Exception("Alachisoft.NCache.NosDBCacheDependency.NosDBDependencyProvider is not found in assembly Alachisoft.NCache.NosDBCacheDependency");
}
_dependencyProvider = Activator.CreateInstance(providerType) as IDependencyProvider;
if (_dependencyProvider != null)
{
_dependencyProvider.RegisterNotification(_connString, _queryString, _cmdParams, _timeout, this);
}
}
catch (Exception ex)
{
NCacheLog.Error("NosDBDependencyListener", ex.ToString());
throw ex;
}
}
/// <summary>
/// Tries to resolve <typeparamref name="T"/> from <paramref name="dependencyProvider"/>.
/// </summary>
/// <typeparam name="T">Type of service to resolved.</typeparam>
/// <param name="dependencyProvider">Resolution provider.</param>
/// <param name="instance">Obtained instance.</param>
/// <returns><c>true</c> when resolution was successful; <c>false</c> otherwise.</returns>
public static bool TryResolve <T>(this IDependencyProvider dependencyProvider, out T instance)
{
Ensure.NotNull(dependencyProvider, "dependencyProvider");
Type requiredType = typeof(T);
IDependencyDefinition definition;
if (dependencyProvider.Definitions.TryGet(requiredType, out definition))
{
if (definition.IsResolvable)
{
try
{
instance = (T)dependencyProvider.Resolve(requiredType);
return(true);
}
catch (DependencyResolutionFailedException)
{
// Catch DependencyResolutionException and let it return false.
}
}
}
else if (!requiredType.GetTypeInfo().IsAbstract&& !requiredType.GetTypeInfo().IsInterface)
{
try
{
instance = (T)dependencyProvider.Resolve(requiredType);
return(true);
}
catch (DependencyResolutionFailedException)
{
// Catch DependencyResolutionException and let it return false.
}
}
instance = default(T);
return(false);
}
private void EnsureResolved()
{
if (_resolvedDependencies == null)
{
HttpRequestContext requestContext = _controller.RequestContext;
Contract.Assert(requestContext != null);
bool includeErrorDetail = requestContext.IncludeErrorDetail;
HttpConfiguration configuration = _controller.Configuration;
if (configuration == null)
{
throw new InvalidOperationException("Configuration must not be null.");
}
ServicesContainer services = configuration.Services;
Contract.Assert(services != null);
IContentNegotiator contentNegotiator = services.GetContentNegotiator();
if (contentNegotiator == null)
{
throw new InvalidOperationException("ContentNegotiator must not be null.");
}
HttpRequestMessage request = _controller.Request;
if (request == null)
{
throw new InvalidOperationException("Request must not be null.");
}
IEnumerable <MediaTypeFormatter> formatters = configuration.Formatters;
Contract.Assert(formatters != null);
_resolvedDependencies = new DirectDependencyProvider(includeErrorDetail, contentNegotiator, request, formatters);
}
}
public ReferencedObjectTargets(
IDependencyProvider dependencyProvider,
IReadOnlyCollection <IRelationalDatabaseTable> tables,
IReadOnlyCollection <IDatabaseView> views,
IReadOnlyCollection <IDatabaseSequence> sequences,
IReadOnlyCollection <IDatabaseSynonym> synonyms,
IReadOnlyCollection <IDatabaseRoutine> routines
)
{
if (tables == null || tables.AnyNull())
{
throw new ArgumentNullException(nameof(tables));
}
if (views == null || views.AnyNull())
{
throw new ArgumentNullException(nameof(views));
}
if (sequences == null || sequences.AnyNull())
{
throw new ArgumentNullException(nameof(sequences));
}
if (synonyms == null || synonyms.AnyNull())
{
throw new ArgumentNullException(nameof(synonyms));
}
if (routines == null || routines.AnyNull())
{
throw new ArgumentNullException(nameof(routines));
}
DependencyProvider = dependencyProvider ?? throw new ArgumentNullException(nameof(dependencyProvider));
TableNames = tables.Select(t => t.Name).ToList();
ViewNames = views.Select(v => v.Name).ToList();
SequenceNames = sequences.Select(s => s.Name).ToList();
SynonymNames = synonyms.Select(s => s.Name).ToList();
RoutineNames = routines.Select(r => r.Name).ToList();
}
private void SetupViewModelLocator(IDependencyProvider dependencyProvider)
{
ViewModelLocator.SetLocator(new VacationsTrackerViewModelLocator(dependencyProvider));
}
//--- Methods ---
public EndGame(IDependencyProvider dependencyProvider, ILambdaLogLevelLogger logger)
{
_dependencyProvider = dependencyProvider;
_logger = logger;
}
//--- Methods ---
public GiveUpCard(IDependencyProvider dependencyProvider, ILambdaLogLevelLogger logger)
{
_dependencyProvider = dependencyProvider;
_logger = logger;
}
/// <summary>
/// Creates a new instance and a valid or invalid result is returned for missing handler.
/// </summary>
/// <param name="isMissingHandlerValid">Whether a missing handler should return valid result or invalid.</param>
public DependencyValidationDispatcher(IDependencyProvider dependencyProvider, bool isMissingHandlerValid)
: base(isMissingHandlerValid)
{
Ensure.NotNull(dependencyProvider, "dependencyProvider");
this.dependencyProvider = dependencyProvider;
}
/// <summary>
/// Creates new instance using <paramref name="dependencyProvider"/> for resolving validation handlers.
/// For missing handler an <see cref="MissingValidationHandlerException"/> is thrown.
/// </summary>
/// <param name="dependencyProvider">Resolver of validation handlers.</param>
public DependencyValidationDispatcher(IDependencyProvider dependencyProvider)
{
Ensure.NotNull(dependencyProvider, "dependencyProvider");
this.dependencyProvider = dependencyProvider;
}
private void EnsureResolved()
{
if (_resolvedDependencies == null)
{
HttpConfiguration configuration = _controller.Configuration;
if (configuration == null)
{
throw new InvalidOperationException(
SRResources.HttpControllerContext_ConfigurationMustNotBeNull);
}
HttpRequestMessage request = _controller.Request;
if (request == null)
{
throw new InvalidOperationException(SRResources.ApiController_RequestMustNotBeNull);
}
bool includeErrorDetail = request.ShouldIncludeErrorDetail();
ServicesContainer services = configuration.Services;
Contract.Assert(services != null);
IContentNegotiator contentNegotiator = services.GetContentNegotiator();
if (contentNegotiator == null)
{
throw new InvalidOperationException(Error.Format(
SRResources.HttpRequestMessageExtensions_NoContentNegotiator, typeof(IContentNegotiator)));
}
IEnumerable<MediaTypeFormatter> formatters = configuration.Formatters;
Contract.Assert(formatters != null);
_resolvedDependencies = new DirectDependencyProvider(includeErrorDetail, contentNegotiator, request,
formatters);
}
}
public void MapProvider(string extension, IDependencyProvider dependencyProvider)
{
_providers[extension] = dependencyProvider;
}
private void EnsureResolved()
{
if (_resolvedDependencies == null)
{
HttpRequestContext requestContext = _controller.RequestContext;
Contract.Assert(requestContext != null);
bool includeErrorDetail = requestContext.IncludeErrorDetail;
HttpConfiguration configuration = _controller.Configuration;
if (configuration == null)
{
throw new InvalidOperationException("Configuration must not be null.");
}
ServicesContainer services = configuration.Services;
Contract.Assert(services != null);
IContentNegotiator contentNegotiator = services.GetContentNegotiator();
if (contentNegotiator == null)
{
throw new InvalidOperationException("ContentNegotiator must not be null.");
}
HttpRequestMessage request = _controller.Request;
if (request == null)
{
throw new InvalidOperationException("Request must not be null.");
}
IEnumerable<MediaTypeFormatter> formatters = configuration.Formatters;
Contract.Assert(formatters != null);
_resolvedDependencies = new DirectDependencyProvider(includeErrorDetail, contentNegotiator, request, formatters);
}
}
public void GetAddedTransient()
{
TestDisposable disposableA;
TestDisposable disposableB;
TestDependency dependencyA;
IDependencyCollection collection = new DependencyCollection();
collection.AddTransient(() => new TestDisposable
{
IntValue = 171,
StringValue = "Hello World"
});
collection.AddTransient <TestDependency, TestDependency>();
collection.TryAddTransient(() => new TestDisposable()).ShouldBeFalse();
collection.TryAddTransient <TestDependency, TestDependency>().ShouldBeFalse();
collection.HasDependency <TestDisposable>().ShouldBeTrue();
collection.HasDependency <TestDependency>().ShouldBeTrue();
using (ILifetimeScope scope = collection.CreateScope())
{
using (IDependencyProvider provider = Should.NotThrow(scope.BuildProvider))
{
provider.TryGetDependency(out disposableA).ShouldBe(true);
provider.HasDependency <TestDisposable>().ShouldBeTrue();
disposableA = Should.NotThrow(provider.GetDependency <TestDisposable>);
disposableA.IsDisposed.ShouldBeFalse();
disposableA.IntValue.ShouldBe(171);
disposableA.StringValue.ShouldBe("Hello World");
disposableA.IntValue = 1024;
disposableA.StringValue = "No longer hello world";
disposableB = Should.NotThrow(provider.GetDependency <TestDisposable>);
disposableB.IsDisposed.ShouldBeFalse();
disposableB.IntValue.ShouldBe(171);
disposableB.StringValue.ShouldBe("Hello World");
dependencyA = Should.NotThrow(provider.GetDependency <TestDependency>);
dependencyA.TestDisposable.IsDisposed.ShouldBeFalse();
dependencyA.TestDisposable.IntValue.ShouldBe(171);
dependencyA.TestDisposable.StringValue.ShouldBe("Hello World");
}
disposableA.IsDisposed.ShouldBeTrue();
disposableB.IsDisposed.ShouldBeTrue();
using (IDependencyProvider provider = Should.NotThrow(scope.BuildProvider))
{
provider.HasDependency <TestDisposable>().ShouldBeTrue();
disposableA = Should.NotThrow(provider.GetDependency <TestDisposable>);
disposableA.IsDisposed.ShouldBeFalse();
disposableA.IntValue.ShouldBe(171);
disposableA.StringValue.ShouldBe("Hello World");
dependencyA = Should.NotThrow(provider.GetDependency <TestDependency>);
dependencyA.TestDisposable.IsDisposed.ShouldBeFalse();
dependencyA.TestDisposable.IntValue.ShouldBe(171);
dependencyA.TestDisposable.StringValue.ShouldBe("Hello World");
}
disposableA.IsDisposed.ShouldBeTrue();
disposableB.IsDisposed.ShouldBeTrue();
}
disposableA.IsDisposed.ShouldBeTrue();
disposableB.IsDisposed.ShouldBeTrue();
ILifetimeScope dependencyScope = collection.CreateScope();
IDependencyProvider dependencyProvider = dependencyScope.BuildProvider();
TestDisposable disposable = dependencyProvider.GetDependency <TestDisposable>();
disposable.IsDisposed.ShouldBeFalse();
dependencyScope.Dispose();
disposable.IsDisposed.ShouldBeTrue();
}
private void EnsureResolved()
{
if (_resolvedDependencies == null)
{
HttpRequestMessage request = _controller.Request;
if (request == null)
{
throw new InvalidOperationException(SRResources.ApiController_RequestMustNotBeNull);
}
UrlHelper urlFactory = _controller.Url ?? new UrlHelper(request);
_resolvedDependencies = new DirectDependencyProvider(urlFactory, request);
}
}
/// <summary>
/// Uses xPike dependency injection.
/// </summary>
/// <param name="app">The application.</param>
/// <param name="dependencyProvider">The dependency provider.</param>
/// <param name="applicationPackage">The application package.</param>
/// <returns>IAppBuilder.</returns>
public static IAppBuilder UseXPikeDependencyInjection(this IAppBuilder app, IDependencyProvider dependencyProvider, IDependencyPackage applicationPackage)
{
return(app.Use <XPikeDependencyInjectionMiddleware>(dependencyProvider, applicationPackage));
}
public LocalDependencyProvider(IDependencyProvider dependencyProvider)
{
_dependencyProvider = dependencyProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="XPikeDependencyInjectionMiddleware"/> class.
/// </summary>
/// <param name="next">The next middleware in the pipeline.</param>
/// <param name="dependencyProvider">The dependency provider instance.</param>
public XPikeDependencyInjectionMiddleware(OwinMiddleware next, IDependencyProvider dependencyProvider) : base(next)
{
this.dependencyProvider = dependencyProvider ?? throw new ArgumentNullException(nameof(dependencyProvider));
}
public void MapExtensionToDependencyProvider(string fileExtension, IDependencyProvider dependencyProvider)
{
_dependencyManager.MapProvider(fileExtension, dependencyProvider);
}
public LocalWalkProvider(IDependencyProvider dependencyProvider)
{
_dependencyProvider = dependencyProvider;
}
public static void Initialize(ApplicationHostContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
context.ProjectDirectory = context.Project?.ProjectDirectory ?? context.ProjectDirectory;
context.RootDirectory = context.RootDirectory ?? ProjectResolver.ResolveRootDirectory(context.ProjectDirectory);
var projectResolver = new ProjectResolver(context.ProjectDirectory, context.RootDirectory);
var frameworkReferenceResolver = context.FrameworkResolver ?? new FrameworkReferenceResolver();
context.PackagesDirectory = context.PackagesDirectory ?? PackageDependencyProvider.ResolveRepositoryPath(context.RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(frameworkReferenceResolver);
var gacDependencyResolver = new GacDependencyResolver();
var projectDependencyProvider = new ProjectReferenceDependencyProvider(projectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
IList<IDependencyProvider> dependencyProviders = null;
LockFileLookup lockFileLookup = null;
if (context.Project == null)
{
Project project;
if (Project.TryGetProject(context.ProjectDirectory, out project))
{
context.Project = project;
}
else
{
throw new InvalidOperationException($"Unable to resolve project from {context.ProjectDirectory}");
}
}
var projectLockJsonPath = Path.Combine(context.ProjectDirectory, LockFileReader.LockFileName);
var lockFileExists = File.Exists(projectLockJsonPath);
var validLockFile = false;
var skipLockFileValidation = context.SkipLockfileValidation;
string lockFileValidationMessage = null;
if (lockFileExists)
{
var lockFileReader = new LockFileReader();
var lockFile = lockFileReader.Read(projectLockJsonPath);
validLockFile = lockFile.IsValidForProject(context.Project, out lockFileValidationMessage);
// When the only invalid part of a lock file is version number,
// we shouldn't skip lock file validation because we want to leave all dependencies unresolved, so that
// VS can be aware of this version mismatch error and automatically do restore
skipLockFileValidation = context.SkipLockfileValidation && (lockFile.Version == Constants.LockFileVersion);
if (validLockFile || skipLockFileValidation)
{
lockFileLookup = new LockFileLookup(lockFile);
var packageDependencyProvider = new PackageDependencyProvider(context.PackagesDirectory, lockFileLookup);
dependencyProviders = new IDependencyProvider[] {
projectDependencyProvider,
packageDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
};
}
}
if ((!validLockFile && !skipLockFileValidation) || !lockFileExists)
{
// We don't add the PackageDependencyProvider to DependencyWalker
// It will leave all NuGet packages unresolved and give error message asking users to run "dnu restore"
dependencyProviders = new IDependencyProvider[] {
projectDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
};
}
var libraries = DependencyWalker.Walk(dependencyProviders, context.Project.Name, context.Project.Version, context.TargetFramework);
context.LibraryManager = new LibraryManager(context.Project.ProjectFilePath, context.TargetFramework, libraries);
if (!validLockFile)
{
context.LibraryManager.AddGlobalDiagnostics(new DiagnosticMessage(
$"{lockFileValidationMessage}. Please run \"dnu restore\" to generate a new lock file.",
Path.Combine(context.Project.ProjectDirectory, LockFileReader.LockFileName),
DiagnosticMessageSeverity.Error));
}
if (!lockFileExists)
{
context.LibraryManager.AddGlobalDiagnostics(new DiagnosticMessage(
$"The expected lock file doesn't exist. Please run \"dnu restore\" to generate a new lock file.",
Path.Combine(context.Project.ProjectDirectory, LockFileReader.LockFileName),
DiagnosticMessageSeverity.Error));
}
// Clear all the temporary memory aggressively here if we don't care about reuse
// e.g. runtime scenarios
lockFileLookup?.Clear();
projectResolver.Clear();
}
