public static void WireUp(UnityDependencyResolver dependencyResolver)
{
string groupBrushRedisHostname = CloudConfigurationManager.GetSetting("GroupBrushRedisHostname");
string groupBrushRedisPassword = CloudConfigurationManager.GetSetting("GroupBrushRedisPassword");
string strUseRedis = CloudConfigurationManager.GetSetting("UseRedis") ?? "false";
bool useRedis = bool.Parse(strUseRedis);
RedisConfiguration redisConfiguration = new RedisConfiguration(groupBrushRedisHostname, groupBrushRedisPassword, useRedis);
dependencyResolver.RegisterInstance<RedisConfiguration>(redisConfiguration);
string groupBrushSQLConnectionString = CloudConfigurationManager.GetSetting("GroupBrushDB");
dependencyResolver.RegisterType<IUserService, UserService>(new ContainerControlledLifetimeManager());
dependencyResolver.RegisterType<ICanvasService, CanvasService>();
dependencyResolver.RegisterType<ICanvasRoomService, CanvasRoomService>();
if (useRedis)
{
dependencyResolver.RegisterType<IMemStorage, RedisStorage>(new ContainerControlledLifetimeManager(), new InjectionConstructor(redisConfiguration));
}
else
{
dependencyResolver.RegisterType<IMemStorage, MemoryStorage>(new ContainerControlledLifetimeManager());
}
dependencyResolver.Register(typeof(IGetUserNameFromIdData), () => new GetUserNameFromIdData(groupBrushSQLConnectionString));
dependencyResolver.Register(typeof(IGetCanvasDescriptionData), () => new GetCanvasDescriptionData(groupBrushSQLConnectionString));
dependencyResolver.Register(typeof(ICreateUserData), () => new CreateUserData(groupBrushSQLConnectionString));
dependencyResolver.Register(typeof(IValidateUserData), () => new ValidateUserData(groupBrushSQLConnectionString));
dependencyResolver.Register(typeof(ICreateCanvasData), () => new CreateCanvasData(groupBrushSQLConnectionString));
dependencyResolver.Register(typeof(ILookUpCanvasData), () => new LookUpCanvasData(groupBrushSQLConnectionString));
}
public static void Initialise()
{
var container = BuildUnityContainer();
UnityDependencyResolver dr = new UnityDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = new ApiContainer();
DependencyResolver.SetResolver(dr);
}
public override void Setup()
{
IUnityContainer container = new UnityContainer()
.RegisterType<SimpleDependency, SimpleDependency>()
.RegisterType<IDependency, SimpleDependency>()
.RegisterType<NestedDependency, NestedDependency>();
_dependencyResolver = new UnityDependencyResolver(container);
}
/// <summary>
/// Integrates Unity when the application starts.
/// </summary>
public static void Start()
{
// Use UnityHierarchicalDependencyResolver if you want to use
// a new child container for each IHttpController resolution.
// var resolver = new UnityHierarchicalDependencyResolver(UnityConfig.Container);
var resolver = new UnityDependencyResolver(UnityConfig.Container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
public virtual void Start()
{
var logger = ConfigureSerilog(new LoggerConfiguration()).CreateLogger();
Log.Logger = logger;
System = ActorSystem.Create(ActorSystemName);
Resolver = new UnityDependencyResolver(Container, System);
CreateActors(System);
}
public void Configuration(IAppBuilder app)
{
string strUseRedis = CloudConfigurationManager.GetSetting("UseRedis") ?? "false";
bool useRedis = bool.Parse(strUseRedis);
var dependencyResolver = new UnityDependencyResolver();
UnityWireupConfiguration.WireUp(dependencyResolver);
GlobalHost.DependencyResolver = dependencyResolver;
var options = new CookieAuthenticationOptions()
{
AuthenticationType = CookieAuthenticationDefaults.AuthenticationType,
LoginPath = new PathString("/"),
LogoutPath = new PathString("/")
};
app.UseCookieAuthentication(options);
app.Use(async (context, next) =>
{
if (context.Request.Path.Value.Equals("/") ||
context.Request.Path.Value.StartsWith("/public", StringComparison.CurrentCultureIgnoreCase))
{
await next();
}
else if (context.Request.User == null || !context.Request.User.Identity.IsAuthenticated)
{
context.Response.StatusCode = 401;
}
else
{
await next();
}
});
HttpConfiguration webApiConfiguration = new HttpConfiguration();
webApiConfiguration.DependencyResolver = dependencyResolver;
webApiConfiguration.MapHttpAttributeRoutes();
app.UseWebApi(webApiConfiguration);
RedisConfiguration redisConfiguration = dependencyResolver.Resolve<RedisConfiguration>();
if (redisConfiguration.UseRedis)
{
GlobalHost.DependencyResolver.UseRedis(redisConfiguration.HostName, redisConfiguration.Port, redisConfiguration.Password, redisConfiguration.EventKey);
}
app.MapSignalR();
var sharedOptions = new SharedOptions()
{
RequestPath = new PathString(string.Empty),
FileSystem =
new PhysicalFileSystem(".//public//content")
};
app.UseDefaultFiles(new Microsoft.Owin.StaticFiles.DefaultFilesOptions(sharedOptions)
{
DefaultFileNames = new List<string>() { "index.html" }
});
app.UseStaticFiles("/public");
app.UseStaticFiles("/content");
app.UseStaticFiles("/scripts");
app.UseStaticFiles("/styles");
app.UseStaticFiles(new StaticFileOptions(sharedOptions));
}
/// <summary>Integrates Unity when the application starts.</summary>
public static void Start()
{
// Use UnityHierarchicalDependencyResolver if you want to use a new child container for each IHttpController resolution.
// var resolver = new UnityHierarchicalDependencyResolver(UnityConfig.GetConfiguredContainer());
var resolver = new UnityDependencyResolver(UnityConfig.GetConfiguredContainer());
GlobalConfiguration.Configuration.DependencyResolver = resolver;
//Microsoft.Web.Infrastructure.DynamicModuleHelper.DynamicModuleUtility.RegisterModule(typeof(UnityPerRequestHttpModule));
}
public static void InitializeDependencyConfig()
{
IUnityContainer container = BuildUnityContainer();
UnityDependencyResolver unityDependencyResolver = new UnityDependencyResolver(container);
DependencyResolver.SetResolver(unityDependencyResolver);
// Setting application wide services. This enables us to use the services in framework level.
ApplicationFoundation.SetDependencyResolver(unityDependencyResolver);
}
public void When_resolving_unregistered_type_then_returns_null()
{
using (var container = new UnityContainer())
{
using (var resolver = new UnityDependencyResolver(container))
{
Assert.IsNull(resolver.GetService(typeof(IFoo)));
}
}
}
public static void Configure()
{
IUnityContainer container = new UnityContainer();
Services.App_Start.UnityConfig.Configure(container);
UnityDependencyResolver resolver = new UnityDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
/// <summary>
/// Integrates Unity when the application starts.
/// </summary>
public static void Start()
{
// Use UnityHierarchicalDependencyResolver if you want to use
// a new child container for each IHttpController resolution.
// var resolver = new UnityHierarchicalDependencyResolver(UnityConfig.Container);
var resolver = new UnityDependencyResolver(UnityConfig.Container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
GlobalHost.DependencyResolver = new SignalRUnityDependencyResolver(UnityConfig.Container);//Ovo dodati u slucaju da je potreban dependency injection
}
public void IsRegistered_Should_Return_True()
{
var resolver = new UnityDependencyResolver();
resolver.RegisterType<IFace1, Class1>();
resolver.RegisterType<IFace1, Class2>();
resolver.RegisterInstance<IFace1>(new Class3());
var result = resolver.IsRegistered<IFace1>();
Assert.IsTrue(result);
}
private static void RegisterActorSystem()
{
//Warning:
//When the hosting inside of IIS the applicationpool the app lives in could be stopped and started at the whim of IIS.
//This in turn means your ActorSystem could be stopped at any given time.
//http://getakka.net/docs/deployment-scenarios/ASP%20NET
ActorSystem = ActorSystem.Create("ticketStore");
var resolver = new UnityDependencyResolver(UnityConfig.GetConfiguredContainer(), ActorSystem);
OrderProcessorActor = ActorSystem.ActorOf(ActorSystem.DI().Props<OrderProcessorActor>(), "OrderProcessor");
}
/// <summary>
/// Integrates Unity when the application starts.
/// </summary>
public static void Start()
{
// Use UnityHierarchicalDependencyResolver if you want to use
// a new child container for each IHttpController resolution.
// var resolver = new UnityHierarchicalDependencyResolver(UnityConfig.Container);
var resolver = new UnityDependencyResolver(UnityConfig.Container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
// GlobalConfiguration.Configuration.Filters.Add(
// (SprintActionFilter)resolver.GetService(typeof(SprintActionFilter)));
}
private void Application_Start(object sender, EventArgs e)
{
IUnityContainer container = new UnityContainer();
container.RegisterType <IUserService, UserService>();
container.RegisterType <IUserLogic, UserLogic>();
UnityDependencyResolver dependencyResolver = new UnityDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = dependencyResolver;
DependencyResolver.SetResolver(dependencyResolver);
}
protected void Application_Start()
{
IUnityContainer unityContainer = UnityContainerHelper.InitUnityContainer();
UnityDependencyResolver dependencyRcolver = new UnityDependencyResolver(unityContainer);
DependencyResolver.SetResolver(dependencyRcolver);
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
private static void RegisterActorSystem()
{
//Warning:
//When the hosting inside of IIS the applicationpool the app lives in could be stopped and started at the whim of IIS.
//This in turn means your ActorSystem could be stopped at any given time.
//http://getakka.net/docs/deployment-scenarios/ASP%20NET
ActorSystem = ActorSystem.Create("ticketStore");
var resolver = new UnityDependencyResolver(UnityConfig.GetConfiguredContainer(), ActorSystem);
OrderProcessorActor = ActorSystem.ActorOf(ActorSystem.DI().Props <OrderProcessorActor>(), "OrderProcessor");
}
public void Configuration(IAppBuilder app)
{
ConfigureAuth(app);
HttpConfiguration config = new HttpConfiguration();
var resolver = new UnityDependencyResolver(UnityConfig.GetConfiguredContainer());
config.DependencyResolver = resolver;
app.UseWebApi(config);
}
/// <summary>
/// Integrates Unity when the application starts.
/// </summary>
public static void Start()
{
// Use UnityHierarchicalDependencyResolver if you want to use
// a new child container for each IHttpController resolution.
// var resolver = new UnityHierarchicalDependencyResolver(UnityConfig.Container);
var resolver = new UnityDependencyResolver(UnityConfig.Container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
//For mvc controllers
System.Web.Mvc.DependencyResolver.SetResolver(new Unity.Mvc5.UnityDependencyResolver(UnityConfig.Container));
}
/// <summary>Integrates Unity when the application starts.</summary>
public static void Start()
{
// Use UnityHierarchicalDependencyResolver if you want to use a new child container for each IHttpController resolution.
// var resolver = new UnityHierarchicalDependencyResolver(UnityConfig.GetConfiguredContainer());
var resolver = new UnityDependencyResolver(UnityConfig.GetConfiguredContainer());
GlobalConfiguration.Configuration.DependencyResolver = resolver;
var reflector = UnityConfig.GetConfiguredContainer().Resolve(typeof(IReflector), null) as IReflector;
reflector.Reflect();
}
protected TestBase()
: base(
CreateSpecConfig("FullUri=file:memdb-" + Counter.IncrementAndGet() + ".db?mode=memory&cache=shared;"),
GetUniqueActorSystemName())
{
SqlitePersistence.Get(Sys);
Container = new UnityContainer();
Container.RegisterInstance(EventFilter);
_resolver = new UnityDependencyResolver(Container, Sys);
}
public void TestGetServiceFromDependencyResolver()
{
//arrange
IUnityContainer container = InitialUnityContainer();
IDependencyResolver dependencyResolver = new UnityDependencyResolver(container);
//act
var controllerActivator = dependencyResolver.GetService <IControllerActivator>();
//assert
Assert.NotNull(controllerActivator);
}
public static void Initialise()
{
var container = BuildUnityContainer();
IDependencyResolver resolver = DependencyResolver.Current;
DependencyResolver.SetResolver(new UnityDependencyResolver(container, resolver));
IDependencyResolver newResolver = new UnityDependencyResolver(container, resolver);
DependencyResolver.SetResolver(newResolver);
}
public void Init()
{
var resolver = new UnityDependencyResolver(_container);
// New instance on DI
_container.RegisterType <IProduct, Product>();
// Singleton
_container.RegisterType <IProduct, Product>(new ContainerControlledLifetimeManager());
_container.RegisterSingleton <IProduct, Product>();
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
var unityDependencyResolver = new UnityDependencyResolver();
unityDependencyResolver.SetupDependencies();
DependencyResolver.SetResolver(unityDependencyResolver);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
UnityDependencyResolver.RegisterTypes();
// Configures container for WebAPI
GlobalConfiguration.Configuration.DependencyResolver = new Unity.WebApi.UnityDependencyResolver(UnityDependencyResolver.container);
AutoMapperConfiguration.Configure();
}
public static void RegisterComponents(HttpConfiguration config)
{
UnityContainer container = new UnityContainer();
// register all your components with the container here
//container.RegisterType<IUserEmailService, SendGridService>();
container.RegisterType <IUserEmailService, MandrillService>();
container.RegisterType <IUserRegistrationReport, UserRegistrationReport>();
container.RegisterType <IJobsService, JobsService>();
container.RegisterType <IJobsWaypointService, JobsWaypointService>();
container.RegisterType <ITransactionLogService, TransactionLogService>();
/* Note to GitHub Viewers: Many lines of code have been taken out of this file, so
* I could showcase DI with Bringg Api */
container.RegisterType(typeof(IBringgTask <>), typeof(CreateUser <>), "CreateUser");
container.RegisterType(typeof(IBringgTask <>), typeof(UpdateUser <>), "UpdateUser");
container.RegisterType(typeof(IBringgTask <>), typeof(DeleteUser <>), "DeleteUser");
container.RegisterType(typeof(IBringgTask <>), typeof(CreateTask <>), "CreateTask");
container.RegisterType(typeof(IBringgTask <>), typeof(CreateTaskWithWaypoints <>), "CreateTaskWithWaypoints");
container.RegisterType(typeof(IBringgTask <>), typeof(CreateWaypoint <>), "CreateWaypoint");
container.RegisterType(typeof(IBringgTask <>), typeof(UpdateCustomerTask <>), "UpdateCustomerTask");
container.RegisterType(typeof(IBringgTask <>), typeof(UpdateTeamTask <>), "UpdateTeamTask");
container.RegisterType(typeof(IBringgTask <>), typeof(DeleteTeamTask <>), "DeleteTeamTask");
DependencyResolver.SetResolver(new UnityDependencyResolver(container));
// this line is needed so that the resolver can be used by api controllers
config.DependencyResolver = new Bringpro.Web.Core.Injection.UnityResolver(container);
var resolver = new UnityDependencyResolver(container);
//container.RegisterType<IOutputService, OutputService>();
DependencyResolver.SetResolver(resolver);
DependencyResolver.SetResolver(new UnityDependencyResolver(container));
// this line is needed so that the resolver can be used by api controllers
config.DependencyResolver = new UnityResolver(container);
// we have to make a custom filter injector to provide DI to our custom action filters.
// see http://michael-mckenna.com/blog/dependency-injection-for-asp-net-web-api-action-filters-in-3-easy-steps
//var providers = config.Services.GetFilterProviders().ToList();
//var defaultprovider = providers.Single(i => i is ActionDescriptorFilterProvider);
//config.Services.Remove(typeof(System.Web.Http.Filters.IFilterProvider), defaultprovider);
config.Services.Add(typeof(System.Web.Http.Filters.IFilterProvider), new UnityActionFilterProvider(container));
}
public void IsRegistered_Should_Return_False()
{
var resolver = new UnityDependencyResolver();
resolver.RegisterType <IFace1, Class1>();
resolver.RegisterType <IFace1, Class2>();
resolver.RegisterInstance <IFace1>(new Class3());
var result = resolver.IsRegistered <Class3>();
Assert.IsFalse(result);
}
public void UnityResolveSingleInstance()
{
var container = new UnityContainer();
var registered = new Registered();
container.RegisterInstance(registered);
var resolver = new UnityDependencyResolver(container);
var resolved = (Registered) resolver.GetInstance(typeof (Registered));
Assert.That(resolved, Is.EqualTo(registered));
}
public static void RegisterComponents()
{
var container = new UnityContainer();
RegisterTypes(container);
var resolver = new UnityDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
Core.REST.Resolver.DepResolver = resolver;
Core.REST.Resolver.Container = container;
}
public void When_resolving_unregistered_type_inside_scope_then_throws()
{
using (var container = new UnityContainer())
{
using (var resolver = new UnityDependencyResolver(container))
{
using (var scope = resolver.BeginScope())
{
AssertThrows <ResolutionFailedException>(() => scope.GetService(typeof(IFoo)));
}
}
}
}
private static void RegisterTypes()
{
_dependencyResolver = new UnityDependencyResolver();
_dependencyResolver.EnsureDependenciesRegistered();
if (_useParallel)
{
_dependencyResolver.Container.RegisterType <INumbersToTextFile, NumbersToTextFileAsync>();
}
else
{
_dependencyResolver.Container.RegisterType(typeof(INumbersToTextFile), typeof(NumbersToTextFile));
}
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
GlobalConfiguration.Configure(WebApiConfig.Register);
var globalConfig = GlobalConfiguration.Configuration;
var dependencyResolver = new UnityDependencyResolver(UnityConfig.Container);
globalConfig.DependencyResolver = dependencyResolver;
}
public void When_resolving_type_with_container_controlled_lifetime_then_returns_same_instance_every_time()
{
using (var container = new UnityContainer())
{
container.RegisterType <IFoo, Foo>(new ContainerControlledLifetimeManager());
var resolver = new UnityDependencyResolver(container);
IFoo resolve1 = (IFoo)resolver.GetService(typeof(IFoo));
IFoo resolve2 = (IFoo)resolver.GetService(typeof(IFoo));
Assert.IsNotNull(resolve1);
Assert.AreSame(resolve1, resolve2);
}
}
public void Array_Injector_Should_Inject_All_Registed_Types()
{
var resolver = new UnityDependencyResolver();
resolver.RegisterType<IFace1, Class1>();
resolver.RegisterType<IFace1, Class2>();
resolver.RegisterInstance<IFace1>(new Class3());
var resolve = resolver.Resolve<Class4>();
Assert.AreEqual(3, resolve.Ifaces.Count());
Assert.IsTrue(resolve.Ifaces.OfType<Class1>().Any());
Assert.IsTrue(resolve.Ifaces.OfType<Class2>().Any());
Assert.IsTrue(resolve.Ifaces.OfType<Class3>().Any());
}
/// <summary>Integrates Unity when the application starts.</summary>
public static void Start()
{
// Use UnityHierarchicalDependencyResolver if you want to use a new child container for each IHttpController resolution.
// var resolver = new UnityHierarchicalDependencyResolver(UnityConfig.GetConfiguredContainer());
var container = UnityConfig.GetConfiguredContainer();
var resolver = new UnityDependencyResolver(container);
//Set resolver for MVC
DependencyResolver.SetResolver(new Unity.Mvc5.UnityDependencyResolver(container));
//Set resolver for Web API
GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
/// <summary>
/// Integrates Unity when the application starts.
/// </summary>
public static void Start()
{
// Use UnityHierarchicalDependencyResolver if you want to use
// a new child container for each IHttpController resolution.
// var resolver = new UnityHierarchicalDependencyResolver(new UnityContainer());
IUnityContainer container = new UnityContainer();
//container.RegisterType<IRepository, EmployeeRepository>();
var resolver = new UnityDependencyResolver(container);
GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
public void ResolveAll_Should_Return_All_Registed_Types()
{
var resolver = new UnityDependencyResolver();
resolver.RegisterType<IFace1, Class1>();
resolver.RegisterType<IFace1, Class2>();
resolver.RegisterInstance<IFace1>(new Class3());
var resolveAll = resolver.ResolveAll<IFace1>();
Assert.Equal(3, resolveAll.Count());
Assert.True(resolveAll.OfType<Class1>().Any());
Assert.True(resolveAll.OfType<Class2>().Any());
Assert.True(resolveAll.OfType<Class3>().Any());
}
public void UnityResolveSingleInstance()
{
var container = new UnityContainer();
var registered = new Registered();
container.RegisterInstance(registered);
var resolver = new UnityDependencyResolver(container);
var resolved = (Registered)resolver.GetInstance(typeof(Registered));
Assert.That(resolved, Is.EqualTo(registered));
}
public void When_resolving_concrete_controller_then_returns_injected_instance()
{
using (var container = new UnityContainer())
{
container.RegisterInstance <IFoo>(new Foo {
TestProperty = "value"
});
var resolver = new UnityDependencyResolver(container);
var actual = (TestController)resolver.GetService(typeof(TestController));
Assert.AreEqual("value", actual.Foo.TestProperty);
}
}
public void When_disposing_resolver_then_disposes_container()
{
using (var container = new UnityContainer())
{
container.RegisterInstance <IFoo>(new Foo {
TestProperty = "value"
});
var resolver = new UnityDependencyResolver(container);
resolver.Dispose();
// ObjectDisposedException?
AssertThrows <ResolutionFailedException>(() => container.Resolve(typeof(IFoo)));
}
}
public void When_resolving_then_returns_registered_instance()
{
using (var container = new UnityContainer())
{
container.RegisterInstance <IFoo>(new Foo {
TestProperty = "value"
});
using (var resolver = new UnityDependencyResolver(container))
{
var actual = (IFoo)resolver.GetService(typeof(IFoo));
Assert.AreEqual("value", actual.TestProperty);
}
}
}
static Bootstrapper()
{
// Create our root container including the TypeTracker extension which OpenRasta
// requires. The extension doesn't change any behaviour for this container, but it
// enables OpenRastas child container to do what it needs.
Container = new UnityContainer();
Container.AddNewExtension<TypeTracker>();
// This is where you register all your normal application services that are designed to
// work with Unity and its default injection policies.
Container.RegisterType<IInfoProvider, InfoProvider>();
// Create the resolver that OpenRasta will use for all dependencies. This actually
// creates a child container so it doesn't intefere with our application level
// behaviour.
Resolver = new UnityDependencyResolver(Container);
}
private static void WithHashPool()
{
IUnityContainer container = new UnityContainer();
container.RegisterType<TypedWorker>();
using (var system = ActorSystem.Create("MySystem"))
{
var propsResolver =
new UnityDependencyResolver(container, system);
var router = system.ActorOf(system.DI().Props<TypedWorker>().WithRouter(FromConfig.Instance), "router1");
Task.Delay(500).Wait();
Console.WriteLine("Sending Messages");
for (var i = 0; i < 5; i++)
{
for (var j = 0; j < 7; j++)
{
var msg = new TypedActorMessage { Id = j, Name = Guid.NewGuid().ToString() };
var ms = new AnotherMessage { Id = j, Name = msg.Name };
var envelope = new ConsistentHashableEnvelope(ms, msg.Id);
router.Tell(msg);
router.Tell(envelope);
}
}
Console.WriteLine("Hit Enter to exit");
Console.ReadLine();
}
}
private void RegisterDependencyResolver(UnityDependencyResolver dependencyResolver)
{
DependencyResolver.SetResolver(dependencyResolver);
GlobalConfiguration.Configuration.DependencyResolver = dependencyResolver;
}
public void ForCoverage()
{
IUnityContainer container = new UnityDependencyResolver().Container;
}
public WebApiUnityDependencyResolver(UnityDependencyResolver resolver)
{
Resolver = resolver;
}
public void Unresolveable_Should_Return_Null()
{
var resolver = new UnityDependencyResolver();
var result = resolver.Resolve<IFace1>();
Assert.IsNull(result);
}