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 }
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(); }
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 LinFuAspectContainer(ServiceContainer container) { Proxy = new MasterProxy(); _container = container; _container.PostProcessors.Add(new AspectPostProcessor()); _container.AddService(Proxy); }
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 void ShouldLoadAssemblyIntoLoaderAtRuntime() { string path = Path.Combine(@"..\..\..\SampleFileWatcherLibrary\bin\Debug", AppDomain.CurrentDomain.BaseDirectory); string targetFile = "SampleFileWatcherLibrary.dll"; string sourceFileName = Path.Combine(path, targetFile); var container = new ServiceContainer(); container.AutoLoadFrom(AppDomain.CurrentDomain.BaseDirectory, "dummy.dll"); // There should be nothing loaded at this point since the assembly hasn't // been copied to the target directory yet Assert.IsFalse(container.Contains(typeof (ISampleService))); // Copy the assembly to the target directory // and watch for changes string targetFileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "dummy.dll"); File.Copy(sourceFileName, targetFileName, true); // Give the watcher thread enough time to load the assembly into memory Thread.Sleep(500); Assert.IsTrue(container.Contains(typeof (ISampleService))); var instance = container.GetService<ISampleService>(); Assert.IsNotNull(instance); string typeName = instance.GetType().Name; Assert.AreEqual("SampleFileWatcherServiceClassAddedAtRuntime", typeName); }
public LinFuAspectContainer(ServiceContainer container) { Proxy = new MasterProxy {Container = new LinFuServiceLocatorAdapter(container)}; _container = container; _container.PostProcessors.Add(new AspectPostProcessor()); _container.AddService(Proxy); }
public override void PrepareBasic() { this.container = new LinFu.IoC.ServiceContainer(); this.RegisterDummies(); this.RegisterStandard(); this.RegisterComplex(); }
private static void Inject(string serviceName, Action<IGenerateFactory<ISampleService>> usingFactory, Func<IUsingLambda<ISampleService>, IGenerateFactory<ISampleService>> doInject, ServiceContainer container) { // HACK: Condense the fluent statements into a single, // reusable line of code usingFactory(doInject(container.Inject<ISampleService>(serviceName))); }
public void Prepare() { this.container = new LinFu.IoC.ServiceContainer(); this.container.Inject <ISingleton>().Using <Singleton>().AsSingleton(); this.container.Inject <ITransient>().Using <Transient>().OncePerRequest(); this.container.Inject <ICombined>().Using <Combined>().OncePerRequest(); this.container.Inject <ICalculator>().Using <Calculator>().OncePerRequest(); }
public static void InitializeServiceLocator() { ServiceContainer container = new ServiceContainer(); AddComponentsTo(container); ControllerBuilder.Current.SetControllerFactory(new LinFuControllerFactory(container)); ServiceLocator.SetLocatorProvider(() => new LinFuServiceLocator(container)); }
public override void Prepare() { this.container = new LinFu.IoC.ServiceContainer(); this.container.Inject<ISingleton>().Using<Singleton>().AsSingleton(); this.container.Inject<ITransient>().Using<Transient>().OncePerRequest(); this.container.Inject<ICombined>().Using<Combined>().OncePerRequest(); this.container.Inject<ICalculator>().Using<Calculator>().OncePerRequest(); }
static void Main(string[] args) { string directory = AppDomain.CurrentDomain.BaseDirectory; IServiceContainer container = new ServiceContainer(); container.LoadFrom(directory, "*.dll"); Console.WriteLine("Press ENTER to continue..."); Console.ReadLine(); }
public override void Prepare() { this.container = new LinFu.IoC.ServiceContainer(); this.RegisterDummies(); this.RegisterStandard(); this.RegisterComplex(); this.RegisterMultiple(); this.RegisterPropertyInjection(); }
private static void Test(string serviceName, Action<IGenerateFactory<ISampleService>> usingFactory, Func<IUsingLambda<ISampleService>, IGenerateFactory<ISampleService>> doInject, Func<string, IServiceContainer, bool> verifyResult) { var container = new ServiceContainer(); // HACK: Manually inject the required services into the container container.AddDefaultServices(); Inject(serviceName, usingFactory, doInject, container); verifyResult(serviceName, container); }
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 LinFu_Container_Fails_Without_Match() { var container = new ServiceContainer(); container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "*.dll"); SnapConfiguration.For(new LinFuAspectContainer(container)).Configure(c => { c.IncludeNamespace("Does.Not.Work"); c.Bind<HandleErrorInterceptor>().To<HandleErrorAttribute>(); }); Assert.Throws<NullReferenceException>(() => container.GetService<IBadCode>()); }
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 void LinFu_Container_Allow_Wildcard_Matching() { var container = new ServiceContainer(); container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "*.dll"); SnapConfiguration.For(new LinFuAspectContainer(container)).Configure(c => { c.IncludeNamespace("SnapTests.*"); c.Bind<HandleErrorInterceptor>().To<HandleErrorAttribute>(); }); Assert.DoesNotThrow(() => container.GetService<IBadCode>()); }
public void ShouldFindGenericMethod() { var container = new ServiceContainer(); container.LoadFromBaseDirectory("*.dll"); var context = new MethodFinderContext(new Type[]{typeof(object)}, new object[0], typeof(void)); var methods = typeof(SampleClassWithGenericMethod).GetMethods(BindingFlags.Public | BindingFlags.Instance); var finder = container.GetService<IMethodFinder<MethodInfo>>(); var result = finder.GetBestMatch(methods, context); Assert.IsTrue(result.IsGenericMethod); Assert.IsTrue(result.GetGenericArguments().Count() == 1); }
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 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 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); }
static void Main(string[] args) { string directory = AppDomain.CurrentDomain.BaseDirectory; var container = new ServiceContainer(); // Load CarLibrary.dll; If you need load // all the libaries in a directory, use "*.dll" instead container.LoadFrom(directory, "CarLibrary.dll"); IVehicle vehicle = container.GetService<IVehicle>(); Console.WriteLine("Press ENTER to continue..."); Console.ReadLine(); return; }
public void ContainerMustAllowInjectingCustomFactoriesForOpenGenericTypeDefinitions() { var container = new ServiceContainer(); var factory = new SampleOpenGenericFactory(); container.AddFactory(typeof (ISampleGenericService<>), factory); // The container must report that it *can* create // the generic service type Assert.IsTrue(container.Contains(typeof (ISampleGenericService<int>))); var result = container.GetService<ISampleGenericService<int>>(); Assert.IsNotNull(result); Assert.IsTrue(result.GetType() == typeof (SampleGenericImplementation<int>)); }
public void ShouldBeAbleToRedirectInterfaceCallToTarget() { var container = new ServiceContainer(); container.LoadFromBaseDirectory("*.dll"); // The duck should call the implementation instance var mock = new Mock<SampleDuckTypeImplementation>(); mock.Expect(i => i.DoSomething()); object target = mock.Object; var sampleService = target.CreateDuck<ISampleService>(); sampleService.DoSomething(); mock.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); }
public void ClassMarkedWithPreprocessorAttributeMustBeInjectedIntoContainer() { string baseDirectory = AppDomain.CurrentDomain.BaseDirectory; var loader = new Loader(); loader.LoadDirectory(baseDirectory, "*.dll"); var container = new ServiceContainer(); loader.LoadInto(container); IEnumerable<IPreProcessor> matches = from p in container.PreProcessors where p != null && p.GetType() == typeof(SamplePreprocessor) select p; Assert.IsTrue(matches.Count() > 0, "The preprocessor failed to load."); }
public void WillBeInformedIfServiceNotRegistered() { bool exceptionThrown = false; ServiceContainer container = new ServiceContainer(); ServiceLocator.SetLocatorProvider(() => new LinFuServiceLocator(container)); try { SafeServiceLocator<IValidator>.GetService(); } catch (ActivationException e) { exceptionThrown = true; Assert.That(e.Message.Contains("IValidator could not be located")); } Assert.That(exceptionThrown); }
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 ShouldAutoInjectMethod() { var container = new ServiceContainer(); container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "LinFu*.dll"); var instance = new SampleClassWithInjectionMethod(); // Initialize the container container.Inject<ISampleService>().Using<SampleClass>().OncePerRequest(); container.Inject<ISampleService>("MyService").Using(c => instance).OncePerRequest(); var result = container.GetService<ISampleService>("MyService"); Assert.AreSame(result, instance); // On initialization, the instance.Property value // should be a SampleClass type Assert.IsNotNull(instance.Property); Assert.IsInstanceOfType(typeof(SampleClass), instance.Property); }
public override void Dispose() { // Allow the container and everything it references to be disposed. this.container = null; }