public void CanAddExtensionWithNonDefaultConstructor()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<ContainerExtensionWithNonDefaultConstructor>();
var extension = container.Configure(typeof (ContainerExtensionWithNonDefaultConstructor));
Assert.IsNotNull(extension);
}
public void CanUseContainerToResolveFactoryParameters()
{
bool factoryWasCalled = false;
string connectionString = "Northwind";
IUnityContainer container = new UnityContainer();
container.AddNewExtension<StaticFactoryExtension>()
.Configure<IStaticFactoryConfiguration>()
.RegisterFactory<MockDatabase>(c =>
{
Assert.AreSame(container, c);
factoryWasCalled = true;
string cs = c.Resolve<string>("connectionString");
return MockDatabase.Create(cs);
})
.Container
.RegisterInstance<string>("connectionString", connectionString);
MockDatabase db = container.Resolve<MockDatabase>();
Assert.IsTrue(factoryWasCalled);
Assert.IsNotNull(db);
Assert.AreEqual(connectionString, db.ConnectionString);
}
public void CanConfigureRemotingInterceptionOnInterface()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container.Configure<Interception>().SetInterceptorFor<Interface>(new TransparentProxyInterceptor());
}
public void CanSetUpAPolicyWithExternallyConfiguredRulesAndHandlers()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container
.Configure<Interception>()
.AddPolicy("policy1")
.AddMatchingRule("rule1")
.AddCallHandler("handler1")
.AddCallHandler("handler2").Interception.Container
.RegisterType<IMatchingRule, AlwaysMatchingRule>("rule1")
.RegisterType<ICallHandler, GlobalCountCallHandler>(
"handler1",
new InjectionConstructor("handler1"))
.RegisterType<ICallHandler, GlobalCountCallHandler>(
"handler2",
new InjectionConstructor("handler2"),
new InjectionProperty("Order", 10));
GlobalCountCallHandler.Calls.Clear();
container
.Configure<Interception>()
.SetInterceptorFor<Wrappable>("wrappable", new VirtualMethodInterceptor());
Wrappable wrappable1 = container.Resolve<Wrappable>("wrappable");
wrappable1.Method2();
Assert.AreEqual(1, GlobalCountCallHandler.Calls["handler1"]);
Assert.AreEqual(1, GlobalCountCallHandler.Calls["handler2"]);
}
public void CanConfigureDefaultRemotingInterceptionOnMBRO()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container.Configure<Interception>()
.SetDefaultInterceptorFor<Wrappable>(new TransparentProxyInterceptor());
}
public void CanInterceptGenericMethodWithHandlerAttributeThroughInterface()
{
var container = new UnityContainer();
container.AddNewExtension<Interception>();
container.RegisterType<IInterfaceWithGenericMethod, ClassWithGenericMethod>(
new Interceptor(new TransparentProxyInterceptor()));
var instance = container.Resolve<IInterfaceWithGenericMethod>();
var result = instance.DoSomething<int>();
Assert.AreEqual(0, result);
}
public void CanInterceptGenericMethodWithHandlerAttributeThroughInterface()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension <Interception>();
container.RegisterType <IInterfaceWithGenericMethod, ClassWithGenericMethod>(
new Interceptor(new TransparentProxyInterceptor()));
var instance = container.Resolve <IInterfaceWithGenericMethod>();
var result = instance.DoSomething <int>();
Assert.AreEqual(0, result);
}
public void ChildContainerLazyEnumerable()
{
using (var root = new UnityContainer())
{
root.AddNewExtension <EnumerableExtension>();
RegisterEnumerable(root, true);
using (var child = root.CreateChildContainer())
{
AssertEnumerable(child, true, true);
}
}
}
/// <summary>
/// 虚方法代理，这个方法不会生成代理类，而是生成派生类
/// </summary>
static void VirtualMethodInterception()
{
var container = new UnityContainer();
container.AddNewExtension <Interception>();
container.RegisterType <ICar, Ford>(
new Interceptor <VirtualMethodInterceptor>(),
new InterceptionBehavior <LoggingInterceptionBehavior>());
var driver = container.Resolve <Driver>();
driver.RunCar();
driver.RunCar2(); // 虚方法代理生成的是派生类，所以可以通过 as Ford 转型。
driver.RunCar3();
}
static void Main(string[] args)
{
var current = new UnityContainer();
current.AddNewExtension <Interception>();
current.RegisterType <IOrderService, OrderService>()
.Configure <Interception>()
.SetInterceptorFor <IOrderService>(new InterfaceInterceptor());
var orderService = current.Resolve <IOrderService>();
Console.WriteLine(orderService.GetOrder());
Console.WriteLine(orderService.GetOrderDetail());
Console.ReadKey();
}
public void UnityCanResolveCompositionContainerTest()
{
// Setup
var unityContainer = new UnityContainer();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// Add composition support for unity
unityContainer.AddNewExtension <CompositionIntegration>();
unityContainer.Configure <CompositionIntegration>().Catalogs.Add(assemblyCatalog);
var compositionContainer = unityContainer.Resolve <CompositionContainer>();
Assert.That(compositionContainer, Is.Not.Null);
}
public void ConfigureContainerReturnEmptyIfNoInterception()
{
ICallHandler myHandler1 = new CallCountHandler();
IMatchingRule myMatchingRule1 = new AlwaysMatchingRule();
IUnityContainer container = new UnityContainer();
container.AddNewExtension <Interception>();
container.Configure <Interception>().
AddPolicy("myRDP").
AddCallHandler(myHandler1).
AddMatchingRule(myMatchingRule1);
Assert.AreEqual(0, ((CallCountHandler)myHandler1).CallCount);
}
public void SettingUpRuleWithEmptyNameThrows()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
try
{
container.Configure<Interception>().AddPolicy(string.Empty);
Assert.Fail("should have thrown");
}
catch (ArgumentException)
{
}
}
/// <summary>
/// Inject
/// </summary>
/// <returns></returns>
private static IUnityContainer BuildUnityContainer(UnityContainer container)
{
// register all your components with the container here
// it is NOT necessary to register your controllers
// Database context, one per request, ensure it is disposed
container.BindInRequestScope <IMvcForumContext, MvcForumContext>();
// Quartz
container.AddNewExtension <QuartzUnityExtension>();
//Bind the various domain model services and repositories that e.g. our controllers require
container.BindInRequestScope <IRoleService, RoleService>();
container.BindInRequestScope <ICategoryService, CategoryService>();
container.BindInRequestScope <IMembershipService, MembershipService>();
container.BindInRequestScope <IPermissionService, PermissionService>();
container.BindInRequestScope <ISettingsService, SettingsService>();
container.BindInRequestScope <ITopicService, TopicService>();
container.BindInRequestScope <ITopicTagService, TopicTagService>();
container.BindInRequestScope <IPostService, PostService>();
container.BindInRequestScope <ILocalizationService, LocalizationService>();
container.BindInRequestScope <IVoteService, VoteService>();
container.BindInRequestScope <IBadgeService, BadgeService>();
container.BindInRequestScope <IMembershipUserPointsService, MembershipUserPointsService>();
container.BindInRequestScope <ICategoryPermissionForRoleService, CategoryPermissionForRoleService>();
container.BindInRequestScope <ICategoryNotificationService, CategoryNotificationService>();
container.BindInRequestScope <ITopicNotificationService, TopicNotificationService>();
container.BindInRequestScope <IPrivateMessageService, PrivateMessageService>();
container.BindInRequestScope <ILoggingService, LoggingService>();
container.BindInRequestScope <IEmailService, EmailService>();
container.BindInRequestScope <IReportService, ReportService>();
container.BindInRequestScope <IActivityService, ActivityService>();
container.BindInRequestScope <IPollService, PollService>();
container.BindInRequestScope <IPollVoteService, PollVoteService>();
container.BindInRequestScope <IPollAnswerService, PollAnswerService>();
container.BindInRequestScope <IBannedEmailService, BannedEmailService>();
container.BindInRequestScope <IBannedWordService, BannedWordService>();
container.BindInRequestScope <IUploadedFileService, UploadedFileService>();
container.BindInRequestScope <IFavouriteService, FavouriteService>();
container.BindInRequestScope <IGlobalPermissionForRoleService, GlobalPermissionForRoleService>();
container.BindInRequestScope <ICacheService, CacheService>();
container.BindInRequestScope <ITagNotificationService, TagNotificationService>();
container.BindInRequestScope <IReflectionService, ReflectionService>();
container.BindInRequestScope <IBlockService, BlockService>();
container.BindInRequestScope <IConfigService, ConfigService>();
container.BindInRequestScope <IPostEditService, PostEditService>();
return(container);
}
public static void RegisterComponents()
{
var container = new UnityContainer();
// register all your components with the container here
// it is NOT necessary to register your controllers
// e.g. container.RegisterType<ITestService, TestService>();
container.RegisterType <ICustomerManager, CustomerManager>();
container.RegisterType <IMechanicmanager, MechanicManager>();
container.RegisterType <IDealerManager, DealerManager>();
container.RegisterType <IVehicleManager, VehicleManager>();
container.AddNewExtension <UnityHelperRepository>();
DependencyResolver.SetResolver(new UnityDependencyResolver(container));
}
public void UnityCannotResolveMultipleMefInstancesTest()
{
// Setup
var unityContainer = new UnityContainer();
var assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
// Add composition support for unity
unityContainer.AddNewExtension <CompositionIntegration>();
unityContainer.Configure <CompositionIntegration>().Catalogs.Add(assemblyCatalog);
Assert.That(delegate
{
unityContainer.Resolve <IMultipleMefComponent>();
}, Throws.TypeOf <ResolutionFailedException>());
}
public void BaseInterceptionBehaviorInvokeTest()
{
//Arrange
var container = new UnityContainer();
container.AddNewExtension <unity.Interception>();
container.RegisterType <IInterceptionBehavior, BaseInterceptionBehavior>("BaseInterceptionBehavior",
new Interceptor <InterfaceInterceptor>(), new InterceptionBehavior <BaseInterceptionBehavior>());
//Act
var target = container.Resolve <IInterceptionBehavior>("BaseInterceptionBehavior");
//Assert
Assert.IsTrue(target.WillExecute);
}
static void InterfaceInterception()
{
var container = new UnityContainer();
container.AddNewExtension <Interception>(); //
container.RegisterType <ICar, Ford>(
new Interceptor <InterfaceInterceptor>(),
new InterceptionBehavior <LoggingInterceptionBehavior>()
/*,new InterceptionBehavior<CacheInterceptionBehavior>()*/); // 可以添加多个拦截器
var driver = container.Resolve <Driver>();
driver.RunCar(); // 这里打印出来的类名会是生成的代理类
driver.RunCar2(); // 接口代理生成的代理类不是派生类，所以不能通过 as Ford 转型
driver.RunCar3();
}
public void SettingUpRuleWithEmptyNameThrows()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension <Interception>();
try
{
container.Configure <Interception>().AddPolicy(string.Empty);
Assert.Fail("should have thrown");
}
catch (ArgumentException)
{
}
}
static void Main(string[] args)
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension <Interception>();
container.RegisterType <ValidationHandler>(new ContainerControlledLifetimeManager());
container.RegisterType <TransactionHandler>(new ContainerControlledLifetimeManager());
container.RegisterType <NotifyHandler>(new ContainerControlledLifetimeManager());
container.RegisterType <TestClass>(
new InterceptionBehavior <PolicyInjectionBehavior>(),
new Interceptor <VirtualMethodInterceptor>());
var testClass = container.Resolve <TestClass>();
testClass.TestProperty = 5;
}
public static void RegisterComponents()
{
var container = new UnityContainer();
// register all your components with the container here
// it is NOT necessary to register your controllers
// e.g. container.RegisterType<ITestService, TestService>();
container.RegisterType <IHotelManager, HotelManager>();
container.RegisterType <IBookingManager, BookingManager>();
container.RegisterType <IRoomManager, RoomManager>();
container.AddNewExtension <BLL.Helper.UnityRepositoryHelper>();
GlobalConfiguration.Configuration.DependencyResolver = new Unity.WebApi.UnityDependencyResolver(container);
}
private void InitializeContainer()
{
if (AppArguments.Instance.IsDebugMode)
{
container.RegisterType <IConfigProvider, PoeEyeConfigProviderInMemory>();
}
else
{
container.RegisterType <IConfigProvider, ConfigProviderFromFile>();
}
container.AddNewExtension <Diagnostic>();
container.AddNewExtension <CommonRegistrations>();
container.AddNewExtension <NativeRegistrations>();
container.AddNewExtension <WpfCommonRegistrations>();
container.AddNewExtension <UpdaterRegistrations>();
container.RegisterType <IMicrophoneControllerEx, ComplexMicrophoneController>();
container.RegisterSingleton <IMicrophoneProvider, MicrophoneProvider>();
container.RegisterSingleton <IMicSwitchOverlayViewModel, MicSwitchOverlayViewModel>();
container.RegisterSingleton <IComplexHotkeyTracker, ComplexHotkeyTracker>();
container.RegisterSingleton <IMainWindowViewModel, MainWindowViewModel>();
container.RegisterSingleton <IImageProvider, ImageProvider>();
}
public void TraceIdentityBehaviorInvokeWithExceptionTest()
{
//Arrange
var container = new UnityContainer();
container.AddNewExtension <Microsoft.Practices.Unity.InterceptionExtension.Interception>();
container.RegisterInstance(typeof(ILogger), _logger);
container.RegisterType <ITestService, TestServiceMock>(
new Interceptor <InterfaceInterceptor>(), new InterceptionBehavior <TraceIdentityBehavior>());
//Act
var target = container.Resolve <ITestService>();
target.GetWithException();
}
public void Defaults()
{
// Setup
var container = new UnityContainer();
// Act
container.AddNewExtension <DefaultLifetime>();
var config = container.Configure <DefaultLifetime>();
// Validate
Assert.IsNotNull(config);
Assert.IsInstanceOfType(config.TypeDefaultLifetime, typeof(TransientLifetimeManager));
Assert.IsInstanceOfType(config.InstanceDefaultLifetime, typeof(ContainerControlledLifetimeManager));
Assert.IsInstanceOfType(config.FactoryDefaultLifetime, typeof(TransientLifetimeManager));
}
public static void RegisterComponents()
{
var container = new UnityContainer();
container.RegisterType <IUser, UserManager>();
container.RegisterType <IVehicle, VehicleManager>();
container.RegisterType <IService, ServiceManager>();
container.RegisterType <IDealer, DealerManager>();
container.RegisterType <IMechanic, MechanicManager>();
container.RegisterType <ICustomer, CustomerManager>();
container.RegisterType <IBooking, BookingManager>();
container.AddNewExtension <UnityRepositoryHelper>();
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
}
public static void Show()
{
IUnityContainer container = new UnityContainer();
container.RegisterType <IUserProcessor, UserProcessor>();//声明UnityContainer并注册IUserProcessor
container.AddNewExtension <Interception>().Configure <Interception>().SetInterceptorFor <IUserProcessor>(new InterfaceInterceptor());
User user = new User()
{
Id = 12, Name = "wangjie", Password = "******"
};
IUserProcessor userprocessor = container.Resolve <IUserProcessor>();
userprocessor.RegUser(user);//调用
//userprocessor.GetUser(user);
}
private IUnityContainer GetConfiguredContainer()
{
callHandler = new PerformanceCounterCallHandler(TestCategoryName, TestInstanceName);
IUnityContainer container = new UnityContainer();
container.AddNewExtension <Interception>();
container.Configure <Interception>()
.AddPolicy("Monitor all methods")
.AddMatchingRule(new TypeMatchingRule(typeof(MonitorTarget)))
.AddCallHandler(callHandler).Interception
.SetDefaultInterceptorFor <MonitorTarget>(new TransparentProxyInterceptor());
return(container);
}
public void UnregisteredGenericParent_Test()
{
var container = new UnityContainer();
container.AddNewExtension <DisposableStrategyExtension>();
var obj1 = container.Resolve <GenericClass <SimpleClass> >();
var obj2 = container.Resolve <GenericClass <DisposableClass> >();
Assert.AreNotEqual(obj1, obj2);
container.Teardown(obj1);
container.Teardown(obj2);
Assert.IsFalse(obj2.Property.Disposed);
}
public static IUnityContainer RegisterComponents()
{
var container = new UnityContainer();
container.AddNewExtension <Interception>();
var interceptor = new Interceptor <InterfaceInterceptor>();
var behaver = new InterceptionBehavior <LoggingInterceptionBehavior>();
container.RegisterType <DbContext, DatabaseContext>(new HierarchicalLifetimeManager());
container.RegisterType(typeof(IRepository <>), typeof(EfRepository <>));
return(container);
}
public void TestAllInStepScope()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension <StepScopeExtension>();
container.RegisterStepScope <A>("a", new InjectionConstructor(new ResolvedParameter <B>("i")));
container.RegisterStepScope <B>("i");
StepSynchronizationManager.Register(_stepExecution);
var a = container.Resolve <A>("a");
Assert.IsNotNull(a.I);
Assert.IsFalse(a.I is IProxyObject);
}
public void AttributeDrivenPolicyIsAddedByDefault()
{
GlobalCountCallHandler.Calls.Clear();
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container.RegisterType<Interface, WrappableThroughInterfaceWithAttributes>(
new Interceptor<InterfaceInterceptor>(),
new InterceptionBehavior<PolicyInjectionBehavior>());
Interface wrappedOverInterface = container.Resolve<Interface>();
wrappedOverInterface.Method();
Assert.AreEqual(1, GlobalCountCallHandler.Calls["WrappableThroughInterfaceWithAttributes-Method"]);
}
public static void RegisterComponents()
{
var container = new UnityContainer();
container.AddNewExtension <Interception>();
container.RegisterType <IHotelesService, HotelesService>(new Interceptor <InterfaceInterceptor>(), new InterceptionBehavior <DBInterceptor>());
container.RegisterType <IHotelesRepository, HotelesRepository>();
container.RegisterType <IReservasService, ReservasService>(new Interceptor <InterfaceInterceptor>(), new InterceptionBehavior <DBInterceptor>());
container.RegisterType <IReservasRepository, ReservasRepository>();
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
}
public void unitycontainer_interception_162()
{
var container = new UnityContainer();
container.AddNewExtension <Interception>();
container.RegisterType <IMyClass, MyClass>(new ContainerControlledLifetimeManager(),
new Interceptor <InterfaceInterceptor>(),
new InterceptionBehavior <LoggingInterceptionBehavior>());
var class1 = container.Resolve <IMyClass>();
var class2 = container.Resolve <IMyClass>();
class1.MyFunction();
class2.MyFunction();
}
public void SimpleInterception()
{
var container = new UnityContainer();
container.AddNewExtension <Interception>();
container.RegisterType <IDependee, Dependee>(
new Interceptor <InterfaceInterceptor>(),
new InterceptionBehavior <LoggingAspect>(),
new InjectionProperty(nameof(IDependee.Dependency)));
container.RegisterType <IDependency, Dependency>();
var dependee = container.Resolve <IDependee>();
Assert.IsNotNull(dependee);
Assert.IsNotNull(dependee.Dependency);
}
static public IUnityContainer UnityContainerFactory()
{
IUnityContainer container = new UnityContainer();
container.RegisterInstance <IPerformanceCounterService>(new PerformanceCounterService {
Category = FTPFolder.PerfofmanceCounterCategory
})
.RegisterInstance <IFTPFolder>(new FTPFolder());
container.AddNewExtension <Interception>()
.Configure <Interception>()
.SetInterceptorFor <IFTPFolder>(new InterfaceInterceptor());
PerformanceCounterInstall.CreateCounters(typeof(FTPFolder), Assembly.GetAssembly(typeof(FTPClient)), FTPFile.PerfofmanceCounterCategory);
return(container);
}
static void Main(string[] args)
{
var uc = new UnityContainer();
uc.AddNewExtension <BrokerExtension>();
var p = uc.Resolve <FootballPlayer>();
p.Name = "Maradona";
var c = uc.Resolve <FootballCoach>();
p.Score();
p.Score();
Console.ReadKey();
}
static void Main(string[] args)
{
UnityContainer container = new UnityContainer();
container.AddNewExtension <Interception>();
container.RegisterType <ISomeObject, SomeObject>(
new Interceptor <TransparentProxyInterceptor>(),
new InterceptionBehavior <SetterCallsFilterMethodBehavior>());
// we must get our instance from unity for interception to occur
ISomeObject myObject = container.Resolve <ISomeObject>();
myObject.SomeProperty = "Hello Setter";
Console.ReadLine();
}
public void ConfiguringDefaultRemotingInterceptionOnNonMBROTypeThrows()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
try
{
container.Configure<Interception>()
.SetDefaultInterceptorFor<WrappableThroughInterface>(new TransparentProxyInterceptor());
Assert.Fail("Call to SetInjectorFor<T>() should have thrown");
}
catch (ArgumentException)
{
// expected exception
}
}
public void Unity_Interceptor_By_ContextBoundObject_Test()
{
using (IUnityContainer container = new UnityContainer())
{
container.AddNewExtension <Interception>();
container.RegisterType <MockClassForContextboundObject>(
new Interceptor <TransparentProxyInterceptor>(),
new InterceptionBehavior <MockClassForContextboundObjectBehavior>());
var obj = container.Resolve <MockClassForContextboundObject>();
obj.Say();
obj.Say();
obj.Say2();
obj.Say2();
}
}
public void CanSetUpInterceptorThroughInjectionMemberForExistingInterceptor()
{
CallCountInterceptionBehavior interceptionBehavior = new CallCountInterceptionBehavior();
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container.RegisterType<IInterface, BaseClass>(
"test",
new Interceptor<InterfaceInterceptor>(),
new InterceptionBehavior(interceptionBehavior));
IInterface instance = container.Resolve<IInterface>("test");
instance.DoSomething("1");
Assert.AreEqual(1, interceptionBehavior.CallCount);
}
public void CanSetUpAnEmptyRule()
{
// there is no visible effect for this, but it should still be resolved.
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
// empty
container
.Configure<Interception>()
.AddPolicy("policy1");
List<InjectionPolicy> policies
= new List<InjectionPolicy>(container.ResolveAll<InjectionPolicy>());
Assert.AreEqual(2, policies.Count);
Assert.IsInstanceOfType(policies[0], typeof(AttributeDrivenPolicy));
Assert.IsInstanceOfType(policies[1], typeof(RuleDrivenPolicy));
Assert.AreEqual("policy1", policies[1].Name);
}
public void CanSetUpAdditionalInterfaceThroughInjectionMemberForInstanceInterception()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
int invokeCount = 0;
container.RegisterType<IInterface, BaseClass>(
"test",
new Interceptor<InterfaceInterceptor>(),
new AdditionalInterface(typeof(IOtherInterface)),
new InterceptionBehavior(
new DelegateInterceptionBehavior(
(mi, gn) => { invokeCount++; return mi.CreateMethodReturn(0); })));
IInterface instance = container.Resolve<IInterface>("test");
((IOtherInterface)instance).DoSomethingElse("1");
Assert.AreEqual(1, invokeCount);
}
public void CanSetUpInterceptorThroughInjectionMember()
{
CallCountHandler handler = new CallCountHandler();
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container.Configure<Interception>()
.AddPolicy("policy")
.AddMatchingRule<AlwaysMatchingRule>()
.AddCallHandler(handler);
container.RegisterType<IInterface, BaseClass>(
"test",
new Interceptor<InterfaceInterceptor>(),
new InterceptionBehavior<PolicyInjectionBehavior>());
IInterface instance = container.Resolve<IInterface>("test");
instance.DoSomething("1");
Assert.AreEqual(1, handler.CallCount);
}
public void CanSetUpAPolicyWithGivenRulesAndHandlers()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
IMatchingRule rule1 = new AlwaysMatchingRule();
ICallHandler handler1 = new CallCountHandler();
container
.Configure<Interception>()
.AddPolicy("policy1")
.AddMatchingRule(rule1)
.AddCallHandler(handler1);
container
.Configure<Interception>()
.SetInterceptorFor<Wrappable>("wrappable", new VirtualMethodInterceptor());
Wrappable wrappable1 = container.Resolve<Wrappable>("wrappable");
wrappable1.Method2();
Assert.AreEqual(1, ((CallCountHandler)handler1).CallCount);
}
public void SettingUpAPolicyWithANullRuleElementThrows()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
try
{
container
.Configure<Interception>()
.AddPolicy("policy1")
.AddMatchingRule(typeof(AlwaysMatchingRule))
.AddMatchingRule((string)null)
.AddCallHandler(new CallCountHandler());
Assert.Fail("Should have thrown");
}
catch (ArgumentException)
{
}
}
public void CanSetUpAPolicyWithLifetimeManagedNamedInjectedRulesAndHandlers()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container
.Configure<Interception>()
.AddPolicy("policy1")
.AddMatchingRule<AlwaysMatchingRule>(
"rule1",
new ContainerControlledLifetimeManager())
.AddCallHandler<CallCountHandler>(
"handler1",
(LifetimeManager)null)
.AddCallHandler<CallCountHandler>(
"handler2",
new ContainerControlledLifetimeManager(),
new InjectionProperty("Order", 10));
GlobalCountCallHandler.Calls.Clear();
container
.Configure<Interception>()
.SetInterceptorFor<Wrappable>("wrappable", new TransparentProxyInterceptor());
Wrappable wrappable1 = container.Resolve<Wrappable>("wrappable");
wrappable1.Method2();
CallCountHandler handler1 = (CallCountHandler)container.Resolve<ICallHandler>("handler1");
CallCountHandler handler2 = (CallCountHandler)container.Resolve<ICallHandler>("handler2");
Assert.AreEqual(0, handler1.CallCount); // not lifetime maanaged
Assert.AreEqual(1, handler2.CallCount); // lifetime managed
}
public void CanSetUpAPolicyWithNamedInjectedRulesAndHandlers()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container
.Configure<Interception>()
.AddPolicy("policy1")
.AddMatchingRule<AlwaysMatchingRule>("rule1")
.AddCallHandler<GlobalCountCallHandler>(
"handler1",
new InjectionConstructor("handler1"))
.AddCallHandler<GlobalCountCallHandler>(
"handler2",
new InjectionConstructor("handler2"),
new InjectionProperty("Order", 10));
GlobalCountCallHandler.Calls.Clear();
container
.Configure<Interception>()
.SetInterceptorFor<Wrappable>("wrappable", new TransparentProxyInterceptor());
Wrappable wrappable1 = container.Resolve<Wrappable>("wrappable");
wrappable1.Method2();
GlobalCountCallHandler handler1 = (GlobalCountCallHandler)container.Resolve<ICallHandler>("handler1");
GlobalCountCallHandler handler2 = (GlobalCountCallHandler)container.Resolve<ICallHandler>("handler2");
Assert.AreEqual(1, GlobalCountCallHandler.Calls["handler1"]);
Assert.AreEqual(1, GlobalCountCallHandler.Calls["handler2"]);
Assert.AreEqual(0, handler1.Order);
Assert.AreEqual(10, handler2.Order);
}
public void CanSetUpAPolicyWithGivenRulesAndHandlersTypesWithGenerics()
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container
.Configure<Interception>()
.AddPolicy("policy1")
.AddMatchingRule<AlwaysMatchingRule>()
.AddCallHandler<GlobalCountCallHandler>();
GlobalCountCallHandler.Calls.Clear();
container
.Configure<Interception>()
.SetInterceptorFor<Wrappable>("wrappable", new TransparentProxyInterceptor());
Wrappable wrappable1 = container.Resolve<Wrappable>("wrappable");
wrappable1.Method2();
Assert.AreEqual(1, GlobalCountCallHandler.Calls["default"]);
}
private IUnityContainer CreateContainer(string globalCallHandlerName)
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container.RegisterInstance<IMatchingRule>(
"alwaystrue",
new AlwaysMatchingRule());
container.RegisterInstance<ICallHandler>(
"globalCountHandler",
new GlobalCountCallHandler(globalCallHandlerName));
container.Configure<Interception>()
.AddPolicy("policy")
.AddMatchingRule("alwaystrue")
.AddCallHandler("globalCountHandler");
return container;
}
public void CanInterceptMBROWithDependencyOnOtherMBRO()
{
GlobalCountCallHandler.Calls.Clear();
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container
.RegisterInstance<IMatchingRule>(
"parentRule",
new TypeMatchingRule(typeof(WrappableWithProperty)))
.RegisterInstance<IMatchingRule>(
"childRule",
new TypeMatchingRule(typeof(Wrappable)))
.RegisterInstance<ICallHandler>(
"parentCallHandler",
new GlobalCountCallHandler("parent"))
.RegisterInstance<ICallHandler>(
"childCallHandler",
new GlobalCountCallHandler("child"))
.RegisterType<InjectionPolicy, RuleDrivenPolicy>("parentPolicy",
new InjectionConstructor(
new ResolvedArrayParameter<IMatchingRule>(
new ResolvedParameter<IMatchingRule>("parentRule")),
new string[] { "parentCallHandler" }))
.RegisterType<InjectionPolicy, RuleDrivenPolicy>("childPolicy",
new InjectionConstructor(
new ResolvedArrayParameter<IMatchingRule>(
new ResolvedParameter<IMatchingRule>("childRule")),
new string[] { "childCallHandler" }))
.RegisterType<WrappableWithProperty>(new InjectionProperty("Wrappable"))
.Configure<Interception>()
.SetDefaultInterceptorFor<WrappableWithProperty>(new TransparentProxyInterceptor())
.SetDefaultInterceptorFor<Wrappable>(new TransparentProxyInterceptor());
WrappableWithProperty instance = container.Resolve<WrappableWithProperty>();
instance.Method();
Assert.AreEqual(1, GlobalCountCallHandler.Calls["parent"]); // method
instance.Wrappable.Method();
Assert.AreEqual(2, GlobalCountCallHandler.Calls["parent"]); // method and getter
Assert.AreEqual(1, GlobalCountCallHandler.Calls["child"]);
}
public void FactoryRecievesCurrentContainerWhenUsingChild()
{
IUnityContainer parent = new UnityContainer();
IUnityContainer child = parent.CreateChildContainer();
parent
.AddNewExtension<StaticFactoryExtension>()
.Configure<StaticFactoryExtension>()
.RegisterFactory<MockDatabase>(
c =>
{
Assert.AreSame(child, c);
return MockDatabase.Create("connectionString");
});
var db = child.Resolve<MockDatabase>();
}
private IUnityContainer CreateContainer(string globalCallHandlerName)
{
IUnityContainer container = new UnityContainer();
container.AddNewExtension<Interception>();
container.RegisterInstance<IMatchingRule>(
"alwaystrue",
new AlwaysMatchingRule());
container.RegisterInstance<ICallHandler>(
"globalCountHandler",
new GlobalCountCallHandler(globalCallHandlerName));
container
.RegisterType<InjectionPolicy, RuleDrivenPolicy>("policy",
new InjectionConstructor(
new ResolvedArrayParameter<IMatchingRule>(
new ResolvedParameter<IMatchingRule>("alwaystrue")),
new string[] { "globalCountHandler" }));
return container;
}
