public void ScopeShouldNeverCallDisposableOnScopedObjectCreatedInAnotherThread()
{
var mock = new Mock<IDisposable>();
var container = new ServiceContainer();
container.AddService(mock.Object);
using (var scope = container.GetService<IScope>())
{
var signal = new ManualResetEvent(false);
WaitCallback callback = state =>
{
// Create the service instance
var instance = container.GetService<IDisposable>();
signal.Set();
};
ThreadPool.QueueUserWorkItem(callback);
// Wait for the thread to execute
WaitHandle.WaitAny(new WaitHandle[] {signal});
}
// The instance should never be disposed
}
public static void Init()
{
ServiceContainer container = new ServiceContainer();
container.AddService(typeof(IValidator), typeof(Validator));
container.AddService(typeof(IEntityDuplicateChecker), typeof(EntityDuplicateCheckerStub));
ServiceLocator.SetLocatorProvider(() => new LinFuServiceLocator(container));
}
public Linfu()
{
container = new ServiceContainer();
container.AddService(typeof(Game), LifecycleType.Singleton);
container.AddService(typeof(Player), LifecycleType.OncePerRequest);
container.AddService(typeof(Gun), LifecycleType.OncePerRequest);
container.AddService(typeof(Bullet), LifecycleType.OncePerRequest);
container.AddService<Func<Bullet>>(r => () => r.Container.GetService<Bullet>(), LifecycleType.OncePerRequest);
container.DisableAutoFieldInjection();
container.DisableAutoMethodInjection();
container.DisableAutoPropertyInjection();
}
public LinFuAspectContainer(ServiceContainer container)
{
Proxy = new MasterProxy {Container = new LinFuServiceLocatorAdapter(container)};
_container = container;
_container.PostProcessors.Add(new AspectPostProcessor());
_container.AddService(Proxy);
}
public LinFuAspectContainer(ServiceContainer container)
{
Proxy = new MasterProxy();
_container = container;
_container.PostProcessors.Add(new AspectPostProcessor());
_container.AddService(Proxy);
}
private static void TestPropertyInjection(string serviceName)
{
var mockTarget = new Mock<IInjectionTarget>();
mockTarget.Expect(t => t.SetValue(123));
var target = mockTarget.Object;
var container = new ServiceContainer();
container.AddService(serviceName, target);
// Use the named fluent interface for
// named instances
if (!String.IsNullOrEmpty(serviceName))
{
container.Initialize<IInjectionTarget>(serviceName)
.With(service => service.SetValue(123));
}
else
{
// Otherwise, use the other one
container.Initialize<IInjectionTarget>()
.With(service => service.SetValue(123));
}
var result = container.GetService<IInjectionTarget>(serviceName);
Assert.IsNotNull(result);
// The container should initialize the
// service on every request
mockTarget.VerifyAll();
}
public void ShouldConstructParametersFromContainer()
{
var targetConstructor = typeof(SampleClassWithMultipleConstructors).GetConstructor(new[] { typeof(ISampleService),
typeof(ISampleService) });
// Initialize the container
var mockSampleService = new Mock<ISampleService>();
IServiceContainer container = new ServiceContainer();
container.AddService(mockSampleService.Object);
container.AddService<IArgumentResolver>(new ArgumentResolver());
// Generate the arguments using the target constructor
object[] arguments = targetConstructor.ResolveArgumentsFrom(container);
Assert.AreSame(arguments[0], mockSampleService.Object);
Assert.AreSame(arguments[1], mockSampleService.Object);
}
static void Main(string[] args)
{
string directory = AppDomain.CurrentDomain.BaseDirectory;
IServiceContainer container = new ServiceContainer();
// Load CarLibrary3.dll; If you need load
// all the libaries in a directory, use "*.dll" instead
container.LoadFrom(directory, "CarLibrary3.dll");
// Configure the container inject instances
// into the Car class constructor
container.Inject<IVehicle>()
.Using(ioc => new Car(ioc.GetService<IEngine>(),
ioc.GetService<IPerson>()))
.OncePerRequest();
Person person = new Person();
person.Name = "Someone";
person.Age = 18;
container.AddService<IPerson>(person);
IVehicle vehicle = container.GetService<IVehicle>();
vehicle.Move();
Console.WriteLine("Press ENTER to continue...");
Console.ReadLine();
}
public void ShouldCallStronglyTypedFunctorInsteadOfActualFactory()
{
var container = new ServiceContainer();
Func<int, int, int> addOperation1 = (a, b) => a + b;
container.AddService("Add", addOperation1);
Func<int, int, int, int> addOperation2 = (a, b, c) => a + b + c;
container.AddService("Add", addOperation2);
Func<int, int, int, int, int> addOperation3 = (a, b, c, d) => a + b + c + d;
container.AddService("Add", addOperation3);
Assert.AreEqual(2, container.GetService<int>("Add", 1, 1));
Assert.AreEqual(3, container.GetService<int>("Add", 1, 1, 1));
Assert.AreEqual(4, container.GetService<int>("Add", 1, 1, 1, 1));
}
public void LazyObjectShouldNeverBeInitialized()
{
var container = new ServiceContainer();
container.AddService<IProxyFactory>(new ProxyFactory());
container.AddService<IMethodBuilder<MethodInfo>>(new MethodBuilder());
Assert.IsTrue(container.Contains(typeof (IProxyFactory)));
var proxyFactory = container.GetService<IProxyFactory>();
var interceptor = new LazyInterceptor<ISampleService>(() => new SampleLazyService());
SampleLazyService.Reset();
// The instance should be uninitialized at this point
var proxy = proxyFactory.CreateProxy<ISampleService>(interceptor);
Assert.IsFalse(SampleLazyService.IsInitialized);
// The instance should be initialized once the method is called
proxy.DoSomething();
Assert.IsTrue(SampleLazyService.IsInitialized);
}
public void CanReturnServiceIfInitializedAndRegistered()
{
ServiceContainer container = new ServiceContainer();
container.LoadFromBaseDirectory("Shaml.Data.dll");
container.AddService("validator", typeof(IValidator), typeof(Validator), LinFu.IoC.Configuration.LifecycleType.OncePerRequest);
ServiceLocator.SetLocatorProvider(() => new LinFuServiceLocator(container));
IValidator validatorService = SafeServiceLocator<IValidator>.GetService();
Assert.That(validatorService, Is.Not.Null);
}
public void ScopeShouldCallDisposableOnScopedObject()
{
var mock = new Mock<IDisposable>();
mock.Expect(disposable => disposable.Dispose());
var container = new ServiceContainer();
container.AddService(mock.Object);
using (var scope = container.GetService<IScope>())
{
// Create the service instance
var instance = container.GetService<IDisposable>();
}
}
public void ScopeShouldNeverCallDisposableOnNonScopedObject()
{
var mock = new Mock<IDisposable>();
var container = new ServiceContainer();
container.AddService(mock.Object);
using (var scope = container.GetService<IScope>())
{
}
// Create the service instance OUTSIDE the scope
// Note: this should never be disposed
var instance = container.GetService<IDisposable>();
}
public void ShouldAutoInjectClassCreatedWithAutoCreate()
{
// Configure the container
var container = new ServiceContainer();
container.LoadFromBaseDirectory("*.dll");
var sampleService = new Mock<ISampleService>();
container.AddService(sampleService.Object);
var instance = (SampleClassWithInjectionProperties)container.AutoCreate(typeof(SampleClassWithInjectionProperties));
// The container should initialize the SomeProperty method to match the mock ISampleService instance
Assert.IsNotNull(instance.SomeProperty);
Assert.AreSame(instance.SomeProperty, sampleService.Object);
}
public void AroundInvokeClassesMarkedWithInterceptorAttributeMustGetActualTargetInstance()
{
var container = new ServiceContainer();
container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "*.dll");
var mockService = new Mock<ISampleWrappedInterface>();
mockService.Expect(mock => mock.DoSomething());
// Add the target instance
container.AddService(mockService.Object);
// The service must return a proxy
var service = container.GetService<ISampleWrappedInterface>();
Assert.AreNotSame(service, mockService.Object);
// Execute the method and 'catch' the target instance once the method call is made
service.DoSomething();
var holder = container.GetService<ITargetHolder>("SampleAroundInvokeInterceptorClass");
Assert.AreSame(holder.Target, mockService.Object);
}
public void CreatedServicesMustBeAbleToInitializeThemselves()
{
string baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
var loader = new Loader();
loader.LoadDirectory(baseDirectory, "*.dll");
var mockInitialize = new Mock<IInitialize>();
var container = new ServiceContainer();
// The service container should call the Initialize method
mockInitialize.Expect(target => target.Initialize(container));
loader.LoadInto(container);
container.AddService(mockInitialize.Object);
var result = container.GetService<IInitialize>();
Assert.IsNotNull(result);
Assert.AreSame(mockInitialize.Object, result);
mockInitialize.VerifyAll();
}
static void Main(string[] args)
{
string directory = AppDomain.CurrentDomain.BaseDirectory;
IServiceContainer container = new ServiceContainer();
// Load CarLibrary2.dll; If you need load
// all the libaries in a directory, use "*.dll" instead
container.LoadFrom(directory, "CarLibrary2.dll");
Person person = new Person();
person.Name = "Someone";
person.Age = 18;
container.AddService<IPerson>(person);
IVehicle vehicle = container.GetService<IVehicle>();
vehicle.Move();
Console.WriteLine("Press ENTER to continue...");
Console.ReadLine();
}
public void ContainerMustAllowUntypedOpenGenericTypeRegistration()
{
Type serviceType = typeof (ISampleGenericService<>);
Type implementingType = typeof (SampleGenericImplementation<>);
var container = new ServiceContainer();
container.AddService(serviceType, implementingType);
var result = container.GetService<ISampleGenericService<long>>();
Assert.IsNotNull(result);
}
public void ContainerMustBeAbleToAddExistingServiceInstances()
{
var container = new ServiceContainer();
var mockService = new Mock<ISerializable>();
container.AddService(mockService.Object);
var result = container.GetService<ISerializable>();
Assert.AreSame(result, mockService.Object);
}
public void ContainerMustAllowServicesToBeIntercepted()
{
var container = new ServiceContainer();
container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "*.dll");
var mock = new Mock<ISampleInterceptedInterface>();
ISampleInterceptedInterface mockInstance = mock.Object;
container.AddService(mockInstance);
// The container must automatically load the interceptor
// from the sample assembly
var result = container.GetService<ISampleInterceptedInterface>();
Assert.AreNotSame(mockInstance, result);
var proxy = (IProxy) result;
Assert.IsNotNull(proxy.Interceptor);
}
public void ContainerMustAllowUntypedServiceRegistration()
{
var container = new ServiceContainer();
container.AddService(typeof (ISampleService), typeof (SampleClass));
var service = container.GetService<ISampleService>();
Assert.IsNotNull(service);
}
public void ShouldNotReturnNamedServicesForGetServiceCallsForAnonymousServices()
{
var container = new ServiceContainer();
var myService = new MyService();
container.AddService<IMyService>(myService);
Assert.IsNotNull(container.GetService<IMyService>());
Assert.IsNull(container.GetService<IMyService>("frobozz"));
}
private static void VerifyInitializeCall(ServiceContainer container, Mock<IInitialize> mockService)
{
container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "*.dll");
container.AddService(mockService.Object);
mockService.Expect(i => i.Initialize(container)).AtMostOnce();
// The container should return the same instance
var firstResult = container.GetService<IInitialize>();
var secondResult = container.GetService<IInitialize>();
Assert.AreSame(firstResult, secondResult);
// The Initialize() method should only be called once
mockService.Verify();
}
public void ContainerShouldBeAbleToRegisterGenericTypeAndResolveConcreteServiceTypeUsingTheNonGenericGetServiceMethod()
{
var container = new ServiceContainer();
container.AddService(typeof (ISampleGenericService<>),
typeof (SampleGenericClassWithOpenGenericImplementation<>));
object instance = container.GetService(typeof (ISampleGenericService<int>));
Assert.IsNotNull(instance);
}
public void ContainerShouldCallPreProcessor()
{
var mockPreprocessor = new Mock<IPreProcessor>();
var mockService = new Mock<ISampleService>();
mockPreprocessor.Expect(p => p.Preprocess(It.IsAny<IServiceRequest>()));
var container = new ServiceContainer();
container.AddService("SomeService", mockService.Object);
container.PreProcessors.Add(mockPreprocessor.Object);
// The preprocessors should be called
var result = container.GetService<ISampleService>("SomeService");
Assert.IsNotNull(result);
mockPreprocessor.VerifyAll();
}
public void ContainerServicesShouldBeLazyIfProxyFactoryExists()
{
var container = new ServiceContainer();
container.AddService<IProxyFactory>(new ProxyFactory());
Assert.IsTrue(container.Contains(typeof (IProxyFactory)));
// The instance should never be created
container.AddService(typeof (ISampleService), typeof (SampleLazyService));
var result = container.GetService<ISampleService>();
Assert.IsFalse(SampleLazyService.IsInitialized);
}
public void ContainerMustListAvailableUnnamedServices()
{
var container = new ServiceContainer();
container.AddService<ISampleService>(new SampleClass());
IEnumerable<IServiceInfo> availableServices = container.AvailableServices;
Assert.IsTrue(availableServices.Count() > 0);
// There should be a matching service type
// at this point
IEnumerable<IServiceInfo> matches = from s in availableServices
where s.ServiceType == typeof (ISampleService)
select s;
Assert.IsTrue(matches.Count() > 0);
}
public void ContainerMustGracefullyHandleRecursiveServiceDependencies()
{
var container = new ServiceContainer();
container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "LinFu*.dll");
container.AddService(typeof (SampleRecursiveTestComponent1), typeof (SampleRecursiveTestComponent1));
container.AddService(typeof (SampleRecursiveTestComponent2), typeof (SampleRecursiveTestComponent2));
try
{
var result = container.GetService<SampleRecursiveTestComponent1>();
}
catch (Exception ex)
{
Assert.IsNotInstanceOfType(typeof (StackOverflowException), ex);
}
}
public void ContainerMustBeAbleToReturnAListOfServices()
{
var mockSampleService = new Mock<ISampleService>();
var container = new ServiceContainer();
// Add a bunch of dummy services
for (int i = 0; i < 10; i++)
{
string serviceName = string.Format("Service{0}", i + 1);
container.AddService(serviceName, mockSampleService.Object);
}
IEnumerable<ISampleService> services = container.GetServices<ISampleService>();
Assert.IsTrue(services.Count() == 10);
// The resulting set of services
// must match the given service instance
foreach (ISampleService service in services)
{
Assert.AreSame(mockSampleService.Object, service);
}
}
public void ContainerMustGetMultipleServicesOfTheSameTypeInOneCall()
{
var container = new ServiceContainer();
int mockServiceCount = 10;
// Add a set of dummy services
for (int i = 0; i < mockServiceCount; i++)
{
var mockService = new Mock<ISampleService>();
container.AddService(string.Format("Service{0}", i + 1), mockService.Object);
}
IEnumerable<ISampleService> instances = container.GetServices<ISampleService>();
foreach (ISampleService serviceInstance in instances)
{
Assert.IsInstanceOfType(typeof (ISampleService), serviceInstance);
Assert.IsNotNull(serviceInstance);
}
}
