From 4b8af653d4719b5114e8f017b16ca5ce0fc42ccb Mon Sep 17 00:00:00 2001 From: ".NET Junkie" Date: Tue, 23 Dec 2014 22:25:01 +0100 Subject: [PATCH] Simple Injector integration package added. --- .../Properties/AssemblyInfo.cs | 36 + .../SampleSimpleInjectorAopConfig.cs | 11 + .../SimpleInjectorAspectContainer.cs | 90 + .../Snap.SimpleInjector.csproj | 148 + Snap.SimpleInjector/packages.config | 9 + Snap.Tests/SimpleInjectorTests.cs | 281 + Snap.Tests/Snap.Tests.csproj | 11 + Snap.Tests/packages.config | 23 +- Snap.sln | 248 +- Snap/AspectUtility.cs | 26 +- ...eLocator.SimpleInjectorAdapter.2.6.1.nupkg | Bin 0 -> 6528 bytes ...onServiceLocator.SimpleInjectorAdapter.xml | 86 + .../Portable.CommonServiceLocator.1.2.2.nupkg | Bin 0 -> 46003 bytes .../Microsoft.Practices.ServiceLocation.XML | 280 + .../Microsoft.Practices.ServiceLocation.XML | 263 + .../Microsoft.Practices.ServiceLocation.XML | 280 + .../SimpleInjector.2.6.1.nupkg | Bin 0 -> 417727 bytes .../SimpleInjector.Diagnostics.xml | 193 + .../lib/net40-client/SimpleInjector.xml | 4583 +++++++++++++++++ .../lib/net45/SimpleInjector.Diagnostics.xml | 193 + .../lib/net45/SimpleInjector.xml | 4583 +++++++++++++++++ .../SimpleInjector.Diagnostics.xml | 193 + .../SimpleInjector.xml | 4573 ++++++++++++++++ packages/repositories.config | 19 +- 24 files changed, 16000 insertions(+), 129 deletions(-) create mode 100644 Snap.SimpleInjector/Properties/AssemblyInfo.cs create mode 100644 Snap.SimpleInjector/SampleSimpleInjectorAopConfig.cs create mode 100644 Snap.SimpleInjector/SimpleInjectorAspectContainer.cs create mode 100644 Snap.SimpleInjector/Snap.SimpleInjector.csproj create mode 100644 Snap.SimpleInjector/packages.config create mode 100644 Snap.Tests/SimpleInjectorTests.cs create mode 100644 packages/CommonServiceLocator.SimpleInjectorAdapter.2.6.1/CommonServiceLocator.SimpleInjectorAdapter.2.6.1.nupkg create mode 100644 packages/CommonServiceLocator.SimpleInjectorAdapter.2.6.1/lib/portable-net4+sl4+wp8+win8+wpa81/CommonServiceLocator.SimpleInjectorAdapter.xml create mode 100644 packages/Portable.CommonServiceLocator.1.2.2/Portable.CommonServiceLocator.1.2.2.nupkg create mode 100644 packages/Portable.CommonServiceLocator.1.2.2/lib/net35/Microsoft.Practices.ServiceLocation.XML create mode 100644 packages/Portable.CommonServiceLocator.1.2.2/lib/portable-net4+sl4+wp7+win8/Microsoft.Practices.ServiceLocation.XML create mode 100644 packages/Portable.CommonServiceLocator.1.2.2/lib/sl30/Microsoft.Practices.ServiceLocation.XML create mode 100644 packages/SimpleInjector.2.6.1/SimpleInjector.2.6.1.nupkg create mode 100644 packages/SimpleInjector.2.6.1/lib/net40-client/SimpleInjector.Diagnostics.xml create mode 100644 packages/SimpleInjector.2.6.1/lib/net40-client/SimpleInjector.xml create mode 100644 packages/SimpleInjector.2.6.1/lib/net45/SimpleInjector.Diagnostics.xml create mode 100644 packages/SimpleInjector.2.6.1/lib/net45/SimpleInjector.xml create mode 100644 packages/SimpleInjector.2.6.1/lib/portable-net4+sl4+wp8+win8+wpa81/SimpleInjector.Diagnostics.xml create mode 100644 packages/SimpleInjector.2.6.1/lib/portable-net4+sl4+wp8+win8+wpa81/SimpleInjector.xml diff --git a/Snap.SimpleInjector/Properties/AssemblyInfo.cs b/Snap.SimpleInjector/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..b9c5db5 --- /dev/null +++ b/Snap.SimpleInjector/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Snap.SimpleInjector")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Snap.SimpleInjector")] +[assembly: AssemblyCopyright("Copyright © Tyler Brinks 2014")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("0b56faaa-6910-4d62-812e-cd30814ceff7")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.7.*")] +[assembly: AssemblyFileVersion("1.7.*")] diff --git a/Snap.SimpleInjector/SampleSimpleInjectorAopConfig.cs b/Snap.SimpleInjector/SampleSimpleInjectorAopConfig.cs new file mode 100644 index 0000000..e686706 --- /dev/null +++ b/Snap.SimpleInjector/SampleSimpleInjectorAopConfig.cs @@ -0,0 +1,11 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Snap.SimpleInjector +{ + class SampleSimpleInjectorAopConfig + { + } +} diff --git a/Snap.SimpleInjector/SimpleInjectorAspectContainer.cs b/Snap.SimpleInjector/SimpleInjectorAspectContainer.cs new file mode 100644 index 0000000..2956c6f --- /dev/null +++ b/Snap.SimpleInjector/SimpleInjectorAspectContainer.cs @@ -0,0 +1,90 @@ +/* +Snap v1.0 + +Copyright (c) 2010 Tyler Brinks + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +using System; +using System.Linq.Expressions; +using Castle.DynamicProxy; +using CommonServiceLocator.SimpleInjectorAdapter; +using SimpleInjector; + +namespace Snap.SimpleInjector +{ + /// + /// Simple Injector Aspect Container for AoP interception registration. + /// + public class SimpleInjectorAspectContainer : AspectContainer + { + private readonly ProxyFactory _proxyFactory = new ProxyFactory(new ProxyGenerator()); + + private readonly Func _createProxy; + + /// + /// Initializes a new instance of the class. + /// + /// The builder. + public SimpleInjectorAspectContainer(Container container) + { + if (container == null) + { + throw new ArgumentNullException("container"); + } + + Proxy = new MasterProxy(); + Container = container; + + Proxy = new MasterProxy { Container = new SimpleInjectorServiceLocatorAdapter(container) }; + + _createProxy = instanceToProxy => _proxyFactory.CreateProxy(instanceToProxy, Proxy); + + container.ExpressionBuilding += Intercept; + } + + void Intercept(object sender, ExpressionBuildingEventArgs e) + { + if (AspectUtility.IsDecorated(e.KnownImplementationType, Proxy.Configuration)) + { + e.Expression = Expression.Convert( + Expression.Invoke(Expression.Constant(_createProxy), e.Expression), + e.RegisteredServiceType); + } + } + + /// + /// Gets or sets the container builder. + /// + /// The builder. + public Container Container { get; private set; } + + /// + /// Sets the aspect configuration. + /// + /// The config. + public override void SetConfiguration(AspectConfiguration config) + { + Proxy.Configuration = config; + Container.RegisterSingle((MasterProxy)Proxy); + config.Container = this; + } + } +} diff --git a/Snap.SimpleInjector/Snap.SimpleInjector.csproj b/Snap.SimpleInjector/Snap.SimpleInjector.csproj new file mode 100644 index 0000000..dc6e77b --- /dev/null +++ b/Snap.SimpleInjector/Snap.SimpleInjector.csproj @@ -0,0 +1,148 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {8ADE2FD7-93B9-4936-8B7B-34DB14443C9A} + Library + Properties + Snap.SimpleInjector + Snap.SimpleInjector + 512 + + + + + 3.5 + + ..\ + false + true + + + v4.0 + true + full + false + bin\NET40-Debug\ + DEBUG;TRACE;DOTNET40 + prompt + 4 + AllRules.ruleset + + + v4.0 + pdbonly + true + bin\NET40-Release\ + TRACE;DOTNET40 + prompt + 4 + AllRules.ruleset + + + v3.5 + true + full + false + bin\NET35-Debug\ + DEBUG;TRACE;DOTNET35 + prompt + 4 + AllRules.ruleset + + + v3.5 + pdbonly + true + bin\NET35-Release\ + TRACE;DOTNET35 + prompt + 4 + AllRules.ruleset + + + NET40 + NET35 + + + true + bin\NET45-Debug\ + DEBUG;TRACE;DOTNET40 + full + AnyCPU + prompt + AllRules.ruleset + + + bin\NET45-Release\ + TRACE;DOTNET40 + true + pdbonly + AnyCPU + prompt + AllRules.ruleset + + + + ..\packages\Castle.Core.3.2.2\lib\net40-client\Castle.Core.dll + + + ..\packages\CommonServiceLocator.SimpleInjectorAdapter.2.6.1\lib\portable-net4+sl4+wp8+win8+wpa81\CommonServiceLocator.SimpleInjectorAdapter.dll + + + ..\packages\fasterflect.2.1.3\lib\net40\Fasterflect.dll + + + False + ..\packages\Portable.CommonServiceLocator.1.2.2\lib\net35\Microsoft.Practices.ServiceLocation.dll + + + ..\packages\SimpleInjector.2.6.1\lib\net40-client\SimpleInjector.dll + + + ..\packages\SimpleInjector.2.6.1\lib\net40-client\SimpleInjector.Diagnostics.dll + + + + 3.5 + + + 3.5 + + + 3.5 + + + + + + + + + + + + {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC} + Snap + + + + + + + + + + + + + \ No newline at end of file diff --git a/Snap.SimpleInjector/packages.config b/Snap.SimpleInjector/packages.config new file mode 100644 index 0000000..74b2d6a --- /dev/null +++ b/Snap.SimpleInjector/packages.config @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/Snap.Tests/SimpleInjectorTests.cs b/Snap.Tests/SimpleInjectorTests.cs new file mode 100644 index 0000000..b73c4e8 --- /dev/null +++ b/Snap.Tests/SimpleInjectorTests.cs @@ -0,0 +1,281 @@ +/* +Snap v1.0 + +Copyright (c) 2010 Tyler Brinks + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ +using System; +using System.Linq; +using NUnit.Framework; +using Snap.SimpleInjector; +using SnapTests.Fakes; +using Snap.Tests.Interceptors; +using SimpleInjector; + +namespace Snap.Tests +{ + [TestFixture] + public class SimpleInjectorTests : TestBase + { + [Test] + public void SimpleInjector_Container_Supports_Method_Aspects() + { + var container = new SimpleInjectorAspectContainer(new Container()); + + SnapConfiguration.For(container).Configure(c => + { + c.IncludeNamespace("SnapTests*"); + c.Bind().To(); + }); + + container.Container.Register(); + var badCode = container.Container.GetInstance(); + + Assert.DoesNotThrow(badCode.GiddyUp); + Assert.IsTrue(badCode.GetType().Name.Equals("IBadCodeProxy")); + } + + [Test] + public void SimpleInjector_Container_Supports_Multiple_Method_Aspects() + { + var container = new SimpleInjectorAspectContainer(new Container()); + + SnapConfiguration.For(container).Configure(c => + { + c.IncludeNamespace("SnapTests*"); + c.Bind().To(); + c.Bind().To(); + }); + + container.Container.Register(); + var badCode = container.Container.GetInstance(); + badCode.RunInOrder(); + Assert.AreEqual("First", OrderedCode.Actions[0]); + Assert.AreEqual("Second", OrderedCode.Actions[1]); + } + + [Test] + public void SimpleInjector_Container_Supports_Class_Aspects() + { + var container = new SimpleInjectorAspectContainer(new Container()); + + SnapConfiguration.For(container).Configure(c => + { + c.IncludeNamespace("SnapTests*"); + c.Bind().To + (); + }); + + container.Container.Register(); + var code = container.Container.GetInstance(); + code.RunInOrder(); + + Assert.AreEqual("Fourth", OrderedCode.Actions[0]); + } + + [Test] + public void SimpleInjector_Container_Ignores_Types_Without_Decoration() + { + var container = new SimpleInjectorAspectContainer(new Container()); + + SnapConfiguration.For(container).Configure(c => + { + c.IncludeNamespace("SnapTests*"); + c.Bind().To + (); + }); + + container.Container.Register(); + var code = container.Container.GetInstance(); + + Assert.IsFalse(code.GetType().Name.Equals("INotInterceptableProxy")); + } + + [Test] + public void SimpleInjector_Container_Allow_Wildcard_Matching() + { + var container = new SimpleInjectorAspectContainer(new Container()); + + SnapConfiguration.For(container).Configure(c => + { + c.IncludeNamespace("SnapTests*"); + c.Bind().To + (); + }); + + container.Container.Register(); + var badCode = container.Container.GetInstance(); + + Assert.DoesNotThrow(badCode.GiddyUp); + Assert.IsTrue(badCode.GetType().Name.Equals("IBadCodeProxy")); + } + + [Test] + public void SimpleInjector_Container_Allow_Strict_Matching() + { + var container = new SimpleInjectorAspectContainer(new Container()); + + SnapConfiguration.For(container).Configure(c => + { + c.IncludeNamespace("SnapTests.Fakes.IBadCode"); + c.Bind().To + (); + }); + + container.Container.Register(); + Assert.DoesNotThrow(() => container.Container.GetInstance()); + } + + [Test] + public void SimpleInjector_Container_Fails_Without_Match() + { + var container = new SimpleInjectorAspectContainer(new Container()); + + SnapConfiguration.For(container).Configure(c => + { + c.IncludeNamespace("Does.Not.Work"); + c.Bind().To + (); + }); + + container.Container.Register(); + Assert.Throws(() => container.Container.GetInstance()); + } + + [Test] + public void SimpleInjector_Supports_Types_Without_Interfaces() + { + var container = new SimpleInjectorAspectContainer(new Container()); + + SnapConfiguration.For(container).Configure(c => + { + c.IncludeNamespace("SnapTests.Fakes*"); + c.Bind().To(); + }); + + container.Container.Register(); + + container.Container.Register(); + container.Container.Register(); + + var typeWithoutInterface = container.Container.GetInstance(); + + Assert.DoesNotThrow(typeWithoutInterface.Foo); + Assert.IsTrue(typeWithoutInterface.GetType().Name.Equals("TypeWithoutInterfaceProxy")); + + var typeWithInterfaceInBaseClass = container.Container.GetInstance(); + + Assert.DoesNotThrow(typeWithInterfaceInBaseClass.Foo); + Assert.IsTrue(typeWithInterfaceInBaseClass.GetType().Name.Equals("TypeWithInterfaceInBaseClassProxy")); + } + + [Test] + public void SimpleInjector_Supports_Resolving_All_Aspects_From_Container() + { + var container = new SimpleInjectorAspectContainer(new Container()); + + SnapConfiguration.For(container).Configure(c => + { + c.IncludeNamespace("SnapTests.*"); + c.Bind().To(); + c.Bind().To(); + c.AllAspects().KeepInContainer(); + }); + + container.Container.Register(); + container.Container.RegisterSingle(new FirstInterceptor("first_kept_in_container")); + container.Container.RegisterSingle(new SecondInterceptor("second_kept_in_container")); + + var orderedCode = container.Container.GetInstance(); + orderedCode.RunInOrder(); + + // both interceptors are resolved from container + CollectionAssert.AreEquivalent( + OrderedCode.Actions, + new[] {"first_kept_in_container", "second_kept_in_container"}); + } + + [Test] + public void SimpleInjector_Supports_Resolving_Only_Selected_Aspects_From_Container() + { + var container = new SimpleInjectorAspectContainer(new Container()); + + SnapConfiguration.For(container).Configure(c => + { + c.IncludeNamespace("SnapTests.*"); + c.Bind().To(); + c.Bind().To(); + c.Aspects(typeof (FirstInterceptor)).KeepInContainer(); + }); + + container.Container.Register(); + container.Container.RegisterSingle(new FirstInterceptor("first_kept_in_container")); + container.Container.RegisterSingle(new SecondInterceptor("second_kept_in_container")); + + var orderedCode = container.Container.GetInstance(); + orderedCode.RunInOrder(); + + // first interceptor is resolved from container, while second one is via new() + CollectionAssert.AreEquivalent( + OrderedCode.Actions, + new[] {"first_kept_in_container", "Second"}); + } + + [Test] + [Explicit( + "No way to unload given assembly from domain w/o destroying domain. Cannot make this test independent from others when all test suite is run." + )] + public void + When_resolving_services_from_container_SNAP_should_load_dynamicproxygenassebmly2_in_appdomain_only_once() + { + var container = new SimpleInjectorAspectContainer(new Container()); + + SnapConfiguration.For(container).Configure(c => + { + c.IncludeNamespaceOf(); + c.Bind().To(); + c.Bind().To(); + c.Bind().To(); + }); + + container.Container.Register(); + container.Container.Register(); + + var orderedCode = container.Container.GetInstance(); + var badCode = container.Container.GetInstance(); + + orderedCode.RunInOrder(); + Assert.AreEqual("First", OrderedCode.Actions[1]); + Assert.AreEqual("Second", OrderedCode.Actions[0]); + + Assert.DoesNotThrow(badCode.GiddyUp); + + var dynamicProxyGenerationAssemblies = AppDomain.CurrentDomain + .GetAssemblies() + .Where(assembly => assembly.GetName().Name == "DynamicProxyGenAssembly2") + .ToList(); + + Assert.That(dynamicProxyGenerationAssemblies.Count, Is.EqualTo(2)); + // both signed and unsigned. + Assert.IsNotNull(dynamicProxyGenerationAssemblies.FirstOrDefault(a => a.GetName().GetPublicKey().Length > 0)); + Assert.IsNotNull(dynamicProxyGenerationAssemblies.FirstOrDefault(a => a.GetName().GetPublicKey().Length == 0)); + } + } +} \ No newline at end of file diff --git a/Snap.Tests/Snap.Tests.csproj b/Snap.Tests/Snap.Tests.csproj index 31b5c67..cc1393f 100644 --- a/Snap.Tests/Snap.Tests.csproj +++ b/Snap.Tests/Snap.Tests.csproj @@ -113,6 +113,12 @@ ..\packages\NUnit.2.6.3\lib\nunit.framework.dll + + ..\packages\SimpleInjector.2.6.1\lib\net40-client\SimpleInjector.dll + + + ..\packages\SimpleInjector.2.6.1\lib\net40-client\SimpleInjector.Diagnostics.dll + ..\packages\structuremap.2.6.4.1\lib\net40\StructureMap.dll @@ -158,6 +164,7 @@ + @@ -180,6 +187,10 @@ {C8C529ED-68D6-4877-9D1A-78E34AA1465F} Snap.Ninject + + {8ade2fd7-93b9-4936-8b7b-34db14443c9a} + Snap.SimpleInjector + {9B28439F-F207-4669-8C89-E5CD86098FCC} Snap.StructureMap diff --git a/Snap.Tests/packages.config b/Snap.Tests/packages.config index f08152c..1fae116 100644 --- a/Snap.Tests/packages.config +++ b/Snap.Tests/packages.config @@ -1,12 +1,13 @@ - - - - - - - - - - - + + + + + + + + + + + + \ No newline at end of file diff --git a/Snap.sln b/Snap.sln index cd68f84..d6bac03 100644 --- a/Snap.sln +++ b/Snap.sln @@ -1,103 +1,145 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio 2013 -VisualStudioVersion = 12.0.21005.1 -MinimumVisualStudioVersion = 10.0.40219.1 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap", "Snap\Snap.csproj", "{C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap.Autofac", "Snap.Autofac\Snap.Autofac.csproj", "{47681067-0B27-4B18-819C-0A2F3D0DB2D6}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap.CastleWindsor", "Snap.CastleWindsor\Snap.CastleWindsor.csproj", "{D1102CFD-63B5-4587-AB70-AF59B7FB28E1}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap.LinFu", "Snap.LinFu\Snap.LinFu.csproj", "{B6C02C50-E493-408C-9649-2872CB591FA0}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap.Ninject", "Snap.Ninject\Snap.Ninject.csproj", "{C8C529ED-68D6-4877-9D1A-78E34AA1465F}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap.StructureMap", "Snap.StructureMap\Snap.StructureMap.csproj", "{9B28439F-F207-4669-8C89-E5CD86098FCC}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap.Tests", "Snap.Tests\Snap.Tests.csproj", "{3F3A6A53-D90C-41B6-88FF-D211DE0857D3}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "NuGet", "NuGet", "{558C50A4-F5C9-4B52-8414-69E08CA86994}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Specs", "Specs", "{CF658F2A-8ACD-4328-85B4-122C9429D535}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Samples", "Samples", "{5EBFCC82-B3AE-4B51-AFC0-0BFFDD262DF7}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{84EE23F7-9EA4-42BD-97E5-BB208468631D}" - ProjectSection(SolutionItems) = preProject - .nuget\packages.config = .nuget\packages.config - EndProjectSection -EndProject -Global - GlobalSection(SolutionConfigurationPlatforms) = preSolution - NET40-Debug|Any CPU = NET40-Debug|Any CPU - NET40-Release|Any CPU = NET40-Release|Any CPU - NET45-Debug|Any CPU = NET45-Debug|Any CPU - NET45-Release|Any CPU = NET45-Release|Any CPU - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU - {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU - {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU - {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU - {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU - {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU - {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU - {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU - {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU - {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU - {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU - {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU - {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU - {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU - {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU - {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU - {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU - {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU - {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU - {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU - {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU - {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU - {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU - {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU - {B6C02C50-E493-408C-9649-2872CB591FA0}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU - {B6C02C50-E493-408C-9649-2872CB591FA0}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU - {B6C02C50-E493-408C-9649-2872CB591FA0}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU - {B6C02C50-E493-408C-9649-2872CB591FA0}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU - {B6C02C50-E493-408C-9649-2872CB591FA0}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU - {B6C02C50-E493-408C-9649-2872CB591FA0}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU - {B6C02C50-E493-408C-9649-2872CB591FA0}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU - {B6C02C50-E493-408C-9649-2872CB591FA0}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU - {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU - {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU - {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU - {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU - {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU - {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU - {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU - {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU - {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU - {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU - {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU - {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU - {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU - {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU - {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU - {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU - {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU - {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU - {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU - {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU - {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU - {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU - {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU - {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU - EndGlobalSection - GlobalSection(SolutionProperties) = preSolution - HideSolutionNode = FALSE - EndGlobalSection - GlobalSection(NestedProjects) = preSolution - {CF658F2A-8ACD-4328-85B4-122C9429D535} = {558C50A4-F5C9-4B52-8414-69E08CA86994} - {5EBFCC82-B3AE-4B51-AFC0-0BFFDD262DF7} = {558C50A4-F5C9-4B52-8414-69E08CA86994} - EndGlobalSection -EndGlobal + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2012 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap", "Snap\Snap.csproj", "{C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap.Autofac", "Snap.Autofac\Snap.Autofac.csproj", "{47681067-0B27-4B18-819C-0A2F3D0DB2D6}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap.CastleWindsor", "Snap.CastleWindsor\Snap.CastleWindsor.csproj", "{D1102CFD-63B5-4587-AB70-AF59B7FB28E1}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap.LinFu", "Snap.LinFu\Snap.LinFu.csproj", "{B6C02C50-E493-408C-9649-2872CB591FA0}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap.Ninject", "Snap.Ninject\Snap.Ninject.csproj", "{C8C529ED-68D6-4877-9D1A-78E34AA1465F}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap.StructureMap", "Snap.StructureMap\Snap.StructureMap.csproj", "{9B28439F-F207-4669-8C89-E5CD86098FCC}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap.Tests", "Snap.Tests\Snap.Tests.csproj", "{3F3A6A53-D90C-41B6-88FF-D211DE0857D3}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "NuGet", "NuGet", "{558C50A4-F5C9-4B52-8414-69E08CA86994}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Specs", "Specs", "{CF658F2A-8ACD-4328-85B4-122C9429D535}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Samples", "Samples", "{5EBFCC82-B3AE-4B51-AFC0-0BFFDD262DF7}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{84EE23F7-9EA4-42BD-97E5-BB208468631D}" + ProjectSection(SolutionItems) = preProject + .nuget\packages.config = .nuget\packages.config + EndProjectSection +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Snap.SimpleInjector", "Snap.SimpleInjector\Snap.SimpleInjector.csproj", "{8ADE2FD7-93B9-4936-8B7B-34DB14443C9A}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + NET40-Debug|Any CPU = NET40-Debug|Any CPU + NET40-Release|Any CPU = NET40-Release|Any CPU + NET45-Debug|Any CPU = NET45-Debug|Any CPU + NET45-Release|Any CPU = NET45-Release|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.Debug|Any CPU.ActiveCfg = NET35-Debug|Any CPU + {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.Debug|Any CPU.Build.0 = NET35-Debug|Any CPU + {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU + {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU + {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU + {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU + {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU + {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU + {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU + {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU + {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.Release|Any CPU.ActiveCfg = NET35-Release|Any CPU + {C1B09D15-F861-48F4-8DA3-FEC0E03CA0FC}.Release|Any CPU.Build.0 = NET35-Release|Any CPU + {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.Debug|Any CPU.ActiveCfg = NET35-Debug|Any CPU + {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.Debug|Any CPU.Build.0 = NET35-Debug|Any CPU + {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU + {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU + {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU + {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU + {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU + {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU + {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU + {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU + {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.Release|Any CPU.ActiveCfg = NET35-Release|Any CPU + {47681067-0B27-4B18-819C-0A2F3D0DB2D6}.Release|Any CPU.Build.0 = NET35-Release|Any CPU + {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.Debug|Any CPU.ActiveCfg = NET35-Debug|Any CPU + {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.Debug|Any CPU.Build.0 = NET35-Debug|Any CPU + {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU + {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU + {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU + {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU + {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU + {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU + {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU + {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU + {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.Release|Any CPU.ActiveCfg = NET35-Release|Any CPU + {D1102CFD-63B5-4587-AB70-AF59B7FB28E1}.Release|Any CPU.Build.0 = NET35-Release|Any CPU + {B6C02C50-E493-408C-9649-2872CB591FA0}.Debug|Any CPU.ActiveCfg = NET35-Debug|Any CPU + {B6C02C50-E493-408C-9649-2872CB591FA0}.Debug|Any CPU.Build.0 = NET35-Debug|Any CPU + {B6C02C50-E493-408C-9649-2872CB591FA0}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU + {B6C02C50-E493-408C-9649-2872CB591FA0}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU + {B6C02C50-E493-408C-9649-2872CB591FA0}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU + {B6C02C50-E493-408C-9649-2872CB591FA0}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU + {B6C02C50-E493-408C-9649-2872CB591FA0}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU + {B6C02C50-E493-408C-9649-2872CB591FA0}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU + {B6C02C50-E493-408C-9649-2872CB591FA0}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU + {B6C02C50-E493-408C-9649-2872CB591FA0}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU + {B6C02C50-E493-408C-9649-2872CB591FA0}.Release|Any CPU.ActiveCfg = NET35-Release|Any CPU + {B6C02C50-E493-408C-9649-2872CB591FA0}.Release|Any CPU.Build.0 = NET35-Release|Any CPU + {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.Debug|Any CPU.ActiveCfg = NET35-Debug|Any CPU + {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.Debug|Any CPU.Build.0 = NET35-Debug|Any CPU + {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU + {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU + {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU + {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU + {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU + {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU + {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU + {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU + {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.Release|Any CPU.ActiveCfg = NET35-Release|Any CPU + {C8C529ED-68D6-4877-9D1A-78E34AA1465F}.Release|Any CPU.Build.0 = NET35-Release|Any CPU + {9B28439F-F207-4669-8C89-E5CD86098FCC}.Debug|Any CPU.ActiveCfg = NET35-Debug|Any CPU + {9B28439F-F207-4669-8C89-E5CD86098FCC}.Debug|Any CPU.Build.0 = NET35-Debug|Any CPU + {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU + {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU + {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU + {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU + {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU + {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU + {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU + {9B28439F-F207-4669-8C89-E5CD86098FCC}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU + {9B28439F-F207-4669-8C89-E5CD86098FCC}.Release|Any CPU.ActiveCfg = NET35-Release|Any CPU + {9B28439F-F207-4669-8C89-E5CD86098FCC}.Release|Any CPU.Build.0 = NET35-Release|Any CPU + {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.Debug|Any CPU.ActiveCfg = NET35-Debug|Any CPU + {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.Debug|Any CPU.Build.0 = NET35-Debug|Any CPU + {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU + {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU + {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU + {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU + {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU + {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU + {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU + {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU + {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.Release|Any CPU.ActiveCfg = NET35-Release|Any CPU + {3F3A6A53-D90C-41B6-88FF-D211DE0857D3}.Release|Any CPU.Build.0 = NET35-Release|Any CPU + {8ADE2FD7-93B9-4936-8B7B-34DB14443C9A}.Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU + {8ADE2FD7-93B9-4936-8B7B-34DB14443C9A}.Debug|Any CPU.Build.0 = NET45-Debug|Any CPU + {8ADE2FD7-93B9-4936-8B7B-34DB14443C9A}.NET40-Debug|Any CPU.ActiveCfg = NET40-Debug|Any CPU + {8ADE2FD7-93B9-4936-8B7B-34DB14443C9A}.NET40-Debug|Any CPU.Build.0 = NET40-Debug|Any CPU + {8ADE2FD7-93B9-4936-8B7B-34DB14443C9A}.NET40-Release|Any CPU.ActiveCfg = NET40-Release|Any CPU + {8ADE2FD7-93B9-4936-8B7B-34DB14443C9A}.NET40-Release|Any CPU.Build.0 = NET40-Release|Any CPU + {8ADE2FD7-93B9-4936-8B7B-34DB14443C9A}.NET45-Debug|Any CPU.ActiveCfg = NET45-Debug|Any CPU + {8ADE2FD7-93B9-4936-8B7B-34DB14443C9A}.NET45-Debug|Any CPU.Build.0 = NET45-Debug|Any CPU + {8ADE2FD7-93B9-4936-8B7B-34DB14443C9A}.NET45-Release|Any CPU.ActiveCfg = NET45-Release|Any CPU + {8ADE2FD7-93B9-4936-8B7B-34DB14443C9A}.NET45-Release|Any CPU.Build.0 = NET45-Release|Any CPU + {8ADE2FD7-93B9-4936-8B7B-34DB14443C9A}.Release|Any CPU.ActiveCfg = NET45-Release|Any CPU + {8ADE2FD7-93B9-4936-8B7B-34DB14443C9A}.Release|Any CPU.Build.0 = NET45-Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(NestedProjects) = preSolution + {CF658F2A-8ACD-4328-85B4-122C9429D535} = {558C50A4-F5C9-4B52-8414-69E08CA86994} + {5EBFCC82-B3AE-4B51-AFC0-0BFFDD262DF7} = {558C50A4-F5C9-4B52-8414-69E08CA86994} + EndGlobalSection +EndGlobal diff --git a/Snap/AspectUtility.cs b/Snap/AspectUtility.cs index b20f1ed..6673741 100644 --- a/Snap/AspectUtility.cs +++ b/Snap/AspectUtility.cs @@ -42,14 +42,28 @@ public static class AspectUtility /// true if the specified target is decorated; otherwise, false. /// public static bool IsDecorated(this object target, AspectConfiguration configuration) - { - var type = target.GetType(); - var methods = type.Methods(); + { + return IsDecorated(target.GetType(), configuration); + } + + /// + /// Determines whether the specified target type has methods decorated for interception. + /// + /// The target. + /// The configuration. + /// + /// true if the specified target is decorated; otherwise, false. + /// + public static bool IsDecorated(Type targetType, AspectConfiguration configuration) + { + var methods = targetType.Methods(); + + var isDecorated = methods.Any(m => m.Attributes().Any(a => a is MethodInterceptAttribute)) || targetType.Attributes().Any(p => p is ClassInterceptAttribute); + + return isDecorated; + } - var isDecorated = methods.Any(m => m.Attributes().Any(a => a is MethodInterceptAttribute)) || type.Attributes().Any(p => p is ClassInterceptAttribute); - return isDecorated; - } /// /// Gets the first type that matches the target namespace. /// diff --git a/packages/CommonServiceLocator.SimpleInjectorAdapter.2.6.1/CommonServiceLocator.SimpleInjectorAdapter.2.6.1.nupkg b/packages/CommonServiceLocator.SimpleInjectorAdapter.2.6.1/CommonServiceLocator.SimpleInjectorAdapter.2.6.1.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..1216f2f8885bbfbc6e3aca671b4bcd22cc6a4029 GIT binary patch literal 6528 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 + + + CommonServiceLocator.SimpleInjectorAdapter + + + + + Translates calls from to Simple Injector's container. + + + + + Initializes a new instance of the class. + + The to adapt. + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + Thrown when there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + Thrown when there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + Thrown when there is are errors resolving + the service instance. + Thrown when a non-null key is requested. Keyed + registration is not supported by the Simple Injector. + The requested service instance. + + + + Get an instance of the given . + + Type of object requested. + Thrown when there is are errors resolving + the service instance. + The requested service instance. + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + Thrown when there is an error resolving + the service instance. + Thrown when a non-null key is requested. Keyed + registration is not supported by the Simple Injector. + The requested service instance. + + + + Get an instance of the given . + + Type of object requested. + Thrown when there is an error resolving + the service instance. + The requested service instance. + + + Gets the service object of the specified type. + A service object of type serviceType.-or- null if there is no service object of type serviceType. + An object that specifies the type of service object to get. + + + diff --git a/packages/Portable.CommonServiceLocator.1.2.2/Portable.CommonServiceLocator.1.2.2.nupkg b/packages/Portable.CommonServiceLocator.1.2.2/Portable.CommonServiceLocator.1.2.2.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..678107f40f27ec08b90d1a6a89c9fd3574ee23a8 GIT binary patch literal 46003 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 hr*xlm0 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 Y$7!ja0a6Ga9x?D80St7ag5#tA10#xJlK=n! literal 0 HcmV?d00001 diff --git a/packages/Portable.CommonServiceLocator.1.2.2/lib/net35/Microsoft.Practices.ServiceLocation.XML b/packages/Portable.CommonServiceLocator.1.2.2/lib/net35/Microsoft.Practices.ServiceLocation.XML new file mode 100644 index 0000000..fb5136c --- /dev/null +++ b/packages/Portable.CommonServiceLocator.1.2.2/lib/net35/Microsoft.Practices.ServiceLocation.XML @@ -0,0 +1,280 @@ + + + + Microsoft.Practices.ServiceLocation + + + + + The standard exception thrown when a ServiceLocator has an error in resolving an object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error message. + + + The message that describes the error. + + + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + + + The error message that explains the reason for the exception. + + + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + + Initializes a new instance of the class with serialized data. + + + The that holds the serialized object data about the exception being thrown. + + + The that contains contextual information about the source or destination. + + + The parameter is null. + + + The class name is null or is zero (0). + + + + + The generic Service Locator interface. This interface is used + to retrieve services (instances identified by type and optional + name) from a container. + + + + + Get an instance of the given . + + Type of object requested. + if there is an error resolving + the service instance. + The requested service instance. + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + if there is an error resolving + the service instance. + The requested service instance. + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + if there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + Get an instance of the given . + + Type of object requested. + if there is are errors resolving + the service instance. + The requested service instance. + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + if there is are errors resolving + the service instance. + The requested service instance. + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + if there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Activation error occured while trying to get all instances of type {0}. + + + + + Looks up a localized string similar to Activation error occured while trying to get instance of type {0}, key "{1}". + + + + + This class provides the ambient container for this application. If your + framework defines such an ambient container, use ServiceLocator.Current + to get it. + + + + + Set the delegate that is used to retrieve the current container. + + Delegate that, when called, will return + the current ambient container. + + + + The current ambient container. + + + + + This class is a helper that provides a default implementation + for most of the methods of . + + + + + Implementation of . + + The requested service. + if there is an error in resolving the service instance. + The requested object. + + + + Get an instance of the given . + + Type of object requested. + if there is an error resolving + the service instance. + The requested service instance. + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + if there is an error resolving + the service instance. + The requested service instance. + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + if there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + Get an instance of the given . + + Type of object requested. + if there is are errors resolving + the service instance. + The requested service instance. + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + if there is are errors resolving + the service instance. + The requested service instance. + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + if there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + When implemented by inheriting classes, this method will do the actual work of resolving + the requested service instance. + + Type of instance requested. + Name of registered service you want. May be null. + The requested service instance. + + + + When implemented by inheriting classes, this method will do the actual work of + resolving all the requested service instances. + + Type of service requested. + Sequence of service instance objects. + + + + Format the exception message for use in an + that occurs while resolving a single service. + + The actual exception thrown by the implementation. + Type of service requested. + Name requested. + The formatted exception message string. + + + + Format the exception message for use in an + that occurs while resolving multiple service instances. + + The actual exception thrown by the implementation. + Type of service requested. + The formatted exception message string. + + + + This delegate type is used to provide a method that will + return the current container. Used with the + static accessor class. + + An . + + + diff --git a/packages/Portable.CommonServiceLocator.1.2.2/lib/portable-net4+sl4+wp7+win8/Microsoft.Practices.ServiceLocation.XML b/packages/Portable.CommonServiceLocator.1.2.2/lib/portable-net4+sl4+wp7+win8/Microsoft.Practices.ServiceLocation.XML new file mode 100644 index 0000000..d22c86a --- /dev/null +++ b/packages/Portable.CommonServiceLocator.1.2.2/lib/portable-net4+sl4+wp7+win8/Microsoft.Practices.ServiceLocation.XML @@ -0,0 +1,263 @@ + + + + Microsoft.Practices.ServiceLocation + + + + + The standard exception thrown when a ServiceLocator has an error in resolving an object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error message. + + + The message that describes the error. + + + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + + + The error message that explains the reason for the exception. + + + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + + The generic Service Locator interface. This interface is used + to retrieve services (instances identified by type and optional + name) from a container. + + + + + Get an instance of the given . + + Type of object requested. + if there is an error resolving + the service instance. + The requested service instance. + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + if there is an error resolving + the service instance. + The requested service instance. + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + if there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + Get an instance of the given . + + Type of object requested. + if there is are errors resolving + the service instance. + The requested service instance. + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + if there is are errors resolving + the service instance. + The requested service instance. + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + if there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + This class provides the ambient container for this application. If your + framework defines such an ambient container, use ServiceLocator.Current + to get it. + + + + + Set the delegate that is used to retrieve the current container. + + Delegate that, when called, will return + the current ambient container. + + + + The current ambient container. + + + + + This class is a helper that provides a default implementation + for most of the methods of . + + + + + Implementation of . + + The requested service. + if there is an error in resolving the service instance. + The requested object. + + + + Get an instance of the given . + + Type of object requested. + if there is an error resolving + the service instance. + The requested service instance. + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + if there is an error resolving + the service instance. + The requested service instance. + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + if there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + Get an instance of the given . + + Type of object requested. + if there is are errors resolving + the service instance. + The requested service instance. + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + if there is are errors resolving + the service instance. + The requested service instance. + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + if there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + When implemented by inheriting classes, this method will do the actual work of resolving + the requested service instance. + + Type of instance requested. + Name of registered service you want. May be null. + The requested service instance. + + + + When implemented by inheriting classes, this method will do the actual work of + resolving all the requested service instances. + + Type of service requested. + Sequence of service instance objects. + + + + Format the exception message for use in an + that occurs while resolving a single service. + + The actual exception thrown by the implementation. + Type of service requested. + Name requested. + The formatted exception message string. + + + + Format the exception message for use in an + that occurs while resolving multiple service instances. + + The actual exception thrown by the implementation. + Type of service requested. + The formatted exception message string. + + + + This delegate type is used to provide a method that will + return the current container. Used with the + static accessor class. + + An . + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Activation error occured while trying to get all instances of type {0}. + + + + + Looks up a localized string similar to Activation error occured while trying to get instance of type {0}, key "{1}". + + + + diff --git a/packages/Portable.CommonServiceLocator.1.2.2/lib/sl30/Microsoft.Practices.ServiceLocation.XML b/packages/Portable.CommonServiceLocator.1.2.2/lib/sl30/Microsoft.Practices.ServiceLocation.XML new file mode 100644 index 0000000..fb5136c --- /dev/null +++ b/packages/Portable.CommonServiceLocator.1.2.2/lib/sl30/Microsoft.Practices.ServiceLocation.XML @@ -0,0 +1,280 @@ + + + + Microsoft.Practices.ServiceLocation + + + + + The standard exception thrown when a ServiceLocator has an error in resolving an object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error message. + + + The message that describes the error. + + + + + Initializes a new instance of the class with a specified error message and a reference to the inner exception that is the cause of this exception. + + + The error message that explains the reason for the exception. + + + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + + Initializes a new instance of the class with serialized data. + + + The that holds the serialized object data about the exception being thrown. + + + The that contains contextual information about the source or destination. + + + The parameter is null. + + + The class name is null or is zero (0). + + + + + The generic Service Locator interface. This interface is used + to retrieve services (instances identified by type and optional + name) from a container. + + + + + Get an instance of the given . + + Type of object requested. + if there is an error resolving + the service instance. + The requested service instance. + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + if there is an error resolving + the service instance. + The requested service instance. + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + if there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + Get an instance of the given . + + Type of object requested. + if there is are errors resolving + the service instance. + The requested service instance. + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + if there is are errors resolving + the service instance. + The requested service instance. + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + if there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Activation error occured while trying to get all instances of type {0}. + + + + + Looks up a localized string similar to Activation error occured while trying to get instance of type {0}, key "{1}". + + + + + This class provides the ambient container for this application. If your + framework defines such an ambient container, use ServiceLocator.Current + to get it. + + + + + Set the delegate that is used to retrieve the current container. + + Delegate that, when called, will return + the current ambient container. + + + + The current ambient container. + + + + + This class is a helper that provides a default implementation + for most of the methods of . + + + + + Implementation of . + + The requested service. + if there is an error in resolving the service instance. + The requested object. + + + + Get an instance of the given . + + Type of object requested. + if there is an error resolving + the service instance. + The requested service instance. + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + if there is an error resolving + the service instance. + The requested service instance. + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + if there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + Get an instance of the given . + + Type of object requested. + if there is are errors resolving + the service instance. + The requested service instance. + + + + Get an instance of the given named . + + Type of object requested. + Name the object was registered with. + if there is are errors resolving + the service instance. + The requested service instance. + + + + Get all instances of the given currently + registered in the container. + + Type of object requested. + if there is are errors resolving + the service instance. + A sequence of instances of the requested . + + + + When implemented by inheriting classes, this method will do the actual work of resolving + the requested service instance. + + Type of instance requested. + Name of registered service you want. May be null. + The requested service instance. + + + + When implemented by inheriting classes, this method will do the actual work of + resolving all the requested service instances. + + Type of service requested. + Sequence of service instance objects. + + + + Format the exception message for use in an + that occurs while resolving a single service. + + The actual exception thrown by the implementation. + Type of service requested. + Name requested. + The formatted exception message string. + + + + Format the exception message for use in an + that occurs while resolving multiple service instances. + + The actual exception thrown by the implementation. + Type of service requested. + The formatted exception message string. + + + + This delegate type is used to provide a method that will + return the current container. Used with the + static accessor class. + + An . + + + diff --git a/packages/SimpleInjector.2.6.1/SimpleInjector.2.6.1.nupkg b/packages/SimpleInjector.2.6.1/SimpleInjector.2.6.1.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..39936a1458086dc1f49781e66ffb165cfb401cac GIT binary patch literal 417727 zcmb5S1C(V=ur65LWvk0}mrmL0vTgH}ZC96V+qP|+UAAqjr~d!mJM-?F_uiU0Ywg&X zJ2N7_h>VPkJaUqtU@##6{9xQQgg5qX>hHdRfc*2og5ZMa+5;^e=m7sv!aPinpE*DN zo%%nMtM+bgK36MCLT8}8gPDyr4>1FPo|q75ZD?a;W^KYl?Br-n%TCP4%dG&k)OY-v z;b3ZJ>p=L$V(q{~Z0hJ}%SlJ)U}y@o(suyZ*aEG;MvQIjt@Itgy7ne?w)%z^`X)d+ zMtXWyx-T^Uj|}4fE|XBn%@+9ol4xaSXm8_SW9$epw6Xe6VPCku#4*s*(X-K6>06r_ z105WR36=EiO@NL(#B_>gR<@Qvacgs+p`(pGz}m^d7HCLJC~m|Ty8#OmGmwdqoza+yiGhs~$jSj^r8i^+*g9Al8QT7*eTEJajLU-+J2{x-SGiXH#k*yKfu@wm(ZiidV)AKw1_}N8 z+=?l3J|CLj!gnrlV6n38{;C?)QYd^9+Q96ND-8lgANg&`7?-&S4a9pnXGC4BJi?ok z6x&1OWk+x6M-Ww;95e#(cdx0JQdYvAgk>`p@u{h;oNwj?dB%=W7%avy5egt9l7AYd zx)eoINyJeyT=o`1PJ~G#m#hQ6=+Z&d>vj>vU2c1VW#p~h2?o-Yj8UiP(Em(5x}=pJ zBXPvmEiJKLR*oPbrMD2%G*zL8KpgVDh2ceq@?Kse(1}|5>NEQ&Rm8u*@3EF{zrVu# zyV*CgN`#z)^<%7TiM3zUl;4kFt@@{(z;TLczKKlx!BL06Vi6&uOvKdkit(yK&GvGi zK4@6W${BPE0mI6GZlckN$q zH?7AzZcqC$*u5KTWkx+Ph@MnWe(D@~s7g{32VcTIW+ZDL!2g;NS^+Z_PdG_1N{m2_1oP=17n>ON3~}-|zoD zcFhlF|42)IrL-Xs5W26}wKOxJvj#dc)6*JSngOjH|L0U7WTtOoZR6l*X6OJgvb6j^ zMfF9ehiAf{S$5v(`t*%S@)aYtrm+azq$8XSiuguyHSUkmN%8;sFXKW+B_(qSv;^Y9dRdjk_LHqXHP#p z4dZOMO--aSnM`GHI2>k}peAK_!K;Dvgk@KEL%9AJkOlR;n+EaLGQ@Z3_1z~KjHU{Y z{=sGgEz+^EGjmweJ->E%bqe#~$_CM~vk9=N8Rv3Yp|UY4;gQQsI;2TtOqvE&t5Dk> ztwv|Fu$TRZj$ETz1^l3-fH4~uv1lIJleb=*RuO%CDGZ3;YhZhyF_Ukl= z(+{4nJL1ry=WltxZxj+^kwm8YV!WMaz2TpZL&V+In08seM<9r<&bJuc{^oV+!?$$r zs&3~}_nl@11@msEv!JD_*UxY|w*7*r$qhD}2j3vbEwR;u<7)Nt3ZI9$pd~-9c@ zYFl-y$H;PT$Jf;%p6VsQ=lLHt<1CNEb%Ldd_l?@*&Gfo1v!RzHM2tebPb1rxK2W|1 zua{V+#q}-saZp(AmXDn_z1yctEFX2r!~W4^Fcq55hsBN|9Nm@@vp?8>lHs?NXt^AY z^*2((qr+xTqi|o0a0%;00{`?WT#Dh(Wi-(zwF|ze;hUhox6g*;3xG>OW29P$k6DM8 zI;Y9wV3W1=@Y2|}rKmI)ViZQ(ua=R&!iX~@*%)F9j82tlZJ8DwF=pzS!i|oW>Txj1 zAv_*ET4OG``_F53xj#f(nxqQ_+InYLJirL5l%!Bwq6GnmV8#=~!Xpx8hfr4z;O<6- zhgJ&*wKVOioNMc}EoYsv#`g$tOp;NGlHtsf3*wt~FbtDx1y>3OER$#Z0BDl5=uX2B z3seD>RDPE>%284v zj5ra>{F{|VVLVl_LZNj28!q#yS%EvF(_z8XuZkUaWR#6Ah_rc;EFC!i#nF}1sK{sB zyFdFsSWGC;luZhGC~g^Vxn>nX#a33Le)DWYo$$bXltNEN_}hgqQa-w|GUU=D@U^PB z#d?0?XV3HeFs%=Cbb=ILJ1MpY#M@_9`#?hoW~I^v#4fiwz#`i_L)dhhK ztv5KtZx@T2BHYwpdrCiBEeIr+Ioyy2$dG*6C@Oz*P?8bC?-P7bs#j-TttjV~knl3B zwIpn{%jKltE`9Zu<)!&Cu04(oD`e{FWUJD@r0Y}p>K$y!F~xRXc7>S~wPu=y4IBB< z%8yLYKEQA(_k;!>+qyjaLJxD)0PT8};IQ3rkjXMlC7`fSERde>SASSaJaJphnA%3+ z6%Fep21({mB@6oCINP{*_2RCy&wyjy5Z_T^P?6CQ2AG_&Of36hmYJ$C;V8+6dzW~q z&jos}Mg3=nn^9llSpg0__JvuZ^{<}cs>wzyIIal^m+2{LRqRpx)|ardWNq+R3wnlc`B4Qr=Kae z)5RNvZll}~L(ia5irRR~lrPkKO=hQm7lu@b9y!*zh$0W4(H>#WWDNL^wws!&Evw_g#!dg^sU(WI zMnX}C#E3jPozzaj)L)0T;HYX|?$0h}q-U_Ij5o(kAZr97g>r|%NS35J%R0hZ#L)#8 zPZ~TN)EN|DK-h^DxAvUUs6+;6SaGl^tEu7REMVJQhn)qLHP<17#WNM>5qhFxE3aLR z@253AQ!Weyg5DUmFs$(GYU4 zS84MO_hihXzw($f7}L`*xJySpTx~3l+cL8Cj>pK{YOuwhM@inQ0KTpg-KFy=&e4U9 z+Gqrg*({Qe+0d(UNb)9+P+ai;KqEF$B&xWCsuiuyKWvDnH#F_s=N08$x(SmL+{)`R z9aMcClIX7U3x|_z;^~zEp17Ffc%X4OQwP!#Gh`Yl1AW4V82B||L4^!Bh114HAi{<# zG=0j3w4^7z4amQC_?uJ|F*HzExRDpQ`lCTKbE$Xx^{-{s4L8C?N*jt!z^D*AISH_>exzYfNZ*`SCaH4x_KtDIZiz3K#ify^ zE88wwS;@F`Sk;?doP60dvZ zjkgz*jUgqB1D5R7b&)4MlE|H?#CehnP`(Ua(Kui(gHr@Hi4>z@ZxpI!E}89&tICEZ z{b7s87w^Klw^jG5A9NNn;i-*v;Lk7tCsIYZWfsUH-M0wv6#qE`rS%N3hT{-7z>~$u zjLH>W5{ze+b>@<==nJf=Iw#IO7nrrK-3KhRzyhO%v2(>xL@dAnn6>Sy1D95e#!q8M zO+Oe9ys&O@L26We6@K*wQM0&SsoqLtDD#8zf6DD>D57}(Sz|Aq-Jgr>DoDdG1N@{#Z(*a9 zitKqa_=+68c%LZ6%v$nZ4YR z?z9ko76n~MaY%ev7#Qigv5Uxd5)r(zVGvX7CGwC!uDucBr5vhYJn!BF||?I;t4;MMVw~~ zUQ!M69m^Q)iR4$8X)fSE?H`iNEb65Ii+0%h8KeuS< zQv~xL0@{|MXcEbE2Zd7uo^?DJv_Fz9Sv`!LCT8~>jZcVlpIMcaOA??}54{U_$y-SJ zr0E28!u9$-(Xm&-YdtE$jsm}2;Gm5B8Lt*>L!ll z@D`L&myCklPMF_HWr*3)oQ83_I+{X8%OD$C&XlY`S*(aW8{uFbA;ve->{bx{RDqdm z^YUioPDfPikvKytI*(*46wqQZh>hLw+ZQxy?hfNlawabi%m1s{&|Ajh?{o%1f-=9N z_kqe1p+r8Z6UlLSnZB3M*olgA>?&F!_}(6z{s z?uh>v%%jJldD4ZKpz^LiA5Z9KjbxPk4h;E^RWGjz`2n|c@8B!<)@V&V?2TSbPBdFO zO6N)p59^jRqvb}O^A~|2?U4|!4k?r)6x|dNuR!*SkPOY4W`}@c;y?jz0z(;>z=-^$ z&(bu0=hI@Cue1rk7Y25Fm!%ZVz9`M|Y41HpIk#Yb?S(;xJ?2Qm-|W_e2*eBUW)_Q>`bKmv6kcfk%0G0d5&hxOPx_Hd{91Xfi0T-wfS~&b1l$)7M4qU%bT@(<%>D z*7`8=_rtCcpCCCMtpGI&XGY9P|fbH(tCaQj1r|1fA z4lrJ)cxrHNe<$a>lD-URhH77@y08oP+~iEq?qZI9Pf}~2kYf0==}zTLY1}>$(lk!X z{i(ToZcjaL^TiF1=kv}v1Zai>CTpUu9kA*r^P5Gl?K{{CogFu+wFgW(V{xOkM*!P1 z@U4>9T;H1qSAa1m{(`Fqe?B%4hn5eTa?cr4mH}@8+K-YR=ke1Yf-46qcOy@Os|NwC z&VNgn3j;0`2&|I5xIew@oL8prKLl3`pF8nr8Jt(x60{!${pwB6y>^M+n$g_tn za%A<|l`fJ`W(j986v-VYkj6Kb>}c) z;8evG-1m+(q3AVo>}0GH#ExPbobzc*`mI%}+y8ZVdBUGHXuh7Y6m4*##-;!+&A-m; zs<|ukujJtEKg*}M*OJDLPxNp62C^HQ;ck&ciT-n;xU!j{s?Hr7E~(?sf1}4MUl)gH zTszlY(PH-Jqo|i6sg2Yaw>}Mx^nUJC8L&=qfQI^$qNBr1L@6U zpB&i34+A&U{~jL2sKZ*3dl0+qVz^%g$i{*4(pfSsRefHMUIdG z$F}Xt0vkT|Oo2Td#m0FE{Go|rcn|CKm%c0vm#&(ld5c|wv?pj2-Yf+3d3pzemDZ~{ zX1B|Bp5E3grRk_pBh1f_j_WIo0$o13Y&y8Tt?8mv?&lY^zn{gekAaFeHUw`^r>1|s zvp$|**#CO_p3uRaY;8VSf2c?J@bM-1bn89Z^fQYFn&~8vb5Lc|^&z#&HjOji=GQt? zGAwnue(gq+_KMJ^ae4f|v+V61Blj4=4dYeg$+)4lW#o7y0>*aO}qdpRlo-3n>e3c%D7P>^?9pqLLF8oKw9Loe^bSS8=B))q&CWZ_w z)l4_=0jiK*ZyZcGasDVo>5EH3!tE{^d6cgtJUhfF^TK_NN_)?>SwH@%XvZ7IxE|6= zf!NyXQnX9#m&8$Q|Ly_ZT;)yp)w7GQs;~KXTJ-|Ew*W3h$UoQZWbed}a^@(HkUi3W z&pYy6(?#}6vZ&^NN1uYfMp>e=QHIz4t&*k+PBf(4Mr8*!aoiz$!B|wg+7LdVduK^6 zRJ1d|26VKL8!>cG8LtLc(b9y^vE-i`XIS*bQ0;Z-VSYBY(jzI(Zyx&1Mil(bjZ z7C#s13O;FbYx6w0&G9^`3&1_+*?;08y_#4wcQMxb)u)c_3ww+AeS>TMDgO51ib7h5 zM@l{Tk+yK%7F9*f;L#|&ViMNHpfXX%RT;bSelXWOym2niOWL%%a(9V6%@a2ga~$~sm^EMf(kD4(jeN&!uTD6d=1T6{LIZ-=Tpz+z;tm`2=G??|#pdVn zMoeJ$n~JzyTiBGS^SF$Gyx^4~tW*Yt-0u4~rxvNdGX6+5hNSlxG(}xISjDS>=Z!R6 z5Ae3fTVCbAD^j=lxqjBG(xz4ZR=dCdc(-!;!}2HIf_y1UB!Tq!*Ktb3(YyC=d{2ZN z1F~}WzTT=yE%E&L$oLzB5i&XApsKN#TNEV1hO z$W{VJFo5wV2V@U24vgRUROb}E!{fS+qWyPtsZ;W6q>nox?{={d=_H$=RX%x;-LZn! zP-*tEGVGODpT)d%8+%QlGGh#0Q1p=na2hlYH7u_i4gle(yudMTYP-uil%tLUXmQpS z;!3Vb2*kpTsB4a(D<;PlD0HTbUR#!a>!4(&_33L>K-^2!nF|1CzmRLrik>X z){~`Q9Se+$X=P2x>h>NpusL-0Y^9yjJHF^ywdZ$S?`lL-ZQaOypbHAOMvh98L zJazGzCBerPMqb%poK2q}CZfdMxq&BYCtlszghI8)t6m7WPzQ@2iw3|G zHU%(nc`c#TPTKMsAl!HGTiQ|k+)ayL3D;hFyW*YMR_S55Czi>zyW;$LpwX4B)h%ula@zt$Y`&K6H0h@yWK0_bb*pjo>pMn;MsfbOf?g|%bq3ikz=)WP#0p{-;gp2pOyrv4@Zj19@S_>(x<+<}{z1Q} zB(q$2U#`duF$4&SIK{lL;mVSDPTcq@z-6;huBPXb-0&w0j~R~O*qL5s zI90S{)I3AiMwBb3@AA<`Gs|1QTs2ZpodruOe(Xe#ts>#mc_8T@w)hZgF-JYSM3THj zM^Qht5CPv|0$94@SFBscp3wS8pj6=;*-grgd>T+ zgIKN17)wMQoxAy3X~=2G7Lq0h(3xn@6E84*778QokP15T;XAS?h?-$UlzXaB7VAn` z7oTWDRXR@^<=?A;92YR_F+4b$8$mM=l%+E5@S79l&r9dL1wT2I0MnyF>}0{N*bcWf z?*fdtZe99!REh@V(1-T773(~iJlE=F# zi|ohLs9>|kTQYP74i-`3USz~sFOkj7CKwF~N z7xf48&TcWDxewHh32QH}M#;N(Mg`IftdrGVX}J6%_av_62|4H~fbrch>*JFx z{1|n|F`@kaw(cJ6OGYW~l3GJE0OLfnb_;UpL`!qGVHC%RJ(Ywhjs<`5T~Tbzv_;;4 z6bMICg@P%5(^mv-;7KbkYdFyU%OF#nP5>G=Mvcz^D5pkSV-f!evbQ4;$`j*=;%Qqx zkR@D!i=VtKK0vh%ANs*`qCGJ#K>ny&wEGL|G6!Z+;o3$IApT{CpmfhjbZ7c0zN_R3ub3 zf2221+<8K&k34mj@nH!YaRMvZkuz&IRL^uO_GF zEjD$mdDMw4G4d459%~3=?jz->X&=cv(6zgqhC)Zb+%g&R9P|`2^+RoXBRKm}w){Ap zhNPPNQvaa>^%ZZcS-Fam1hjaPX=nGB;uGgr{SqXOIMi)@nN;BRTT3@r-+!N80pJ>Q?>KnY}M1MBU3)$$%Nr%T_=SxBfN9q^;+taVBE6 zWQ4&YLdzlZY=3r~<{#K?#n95J_!`u6Ca@%5HNJfY^4)QlZM4!All=C~Enm?h3*MFu z29WNws+Vo2DDCSB$4SVuIXb^B@rvPk?hk|OsTmpqIXd6bJjh{8lVo?S3|_$r-AE?C z<#ntfQ@UVqrifV`gmDwh{7zgzmVU$|jBD#G=0#$SN7ivC(}{o+TL#Y-=IkH(eE#`6 z_XqQojhqv=&Q~5a+S;u{8+$F#BQZFbM-wer98%V@bJHQG8exM(AOTPd5kqo9H|ePB zTUPus;`r(MR&axeFCOKaFAft(sQPf{`6p3C^76?ZD~EMJC<<)!+T}9nJgM_j3(d4N zJz*{CUXjP6KqIbh*44qeW{$jph1cJaE;Mw>bD{xj|HwOd4+H_dF8yi#;}n}^2c*mN zFG}E;ZMN*dw_dL{(lO@N>CV;Brgm4zbBedEL0pqQ+rPU4Q|WH4u}EhW_Pv|c63@DV(Gyo9DISp=w?ZDqaRq@6t$y; zXZC+VD@D@vPv-wmA{3a#g z{(9mH{7ak0+d!v87qa_*S8(lehb&v0g}P+^E#>`&*;6>dSKjR>E-BnDPML!ng!R=Z zN+2CL9BG56j4qMwORc+HPw)?6p+jS&lX{W*fM2guGL?=!HhUIY{2&?3=Y6>qE^b%~CQ3 zdYN)TEHe6TWPv{##!%JftFsP33^63VTPMNRj)N6VOzXf7Z)1mMjxQg@-Tiv}d4Sn% zfY!N2JFFKmVE}8t*eAIizl<^@l8oct1-1tUQGKv!>H{qkzl_n^yrLUqLJdd#fw1`_ zWiPU0n6|pd14Z!;k>pW6P`^+$r**Doj=HA#iDsY2&6eHS} z^s{@m=ku_tmUdK8B=I+n-9a}~&277&31HwBqqBD0QSnpsO})Nn#d`c+duutMWv8k| z+w2eNG)H)x_YXfgX&YY(n$l+XGt<$}cd-c2xadA5b=2PNDTOT*`n zPwu6eSEgszE}}aoF&)AJDG9grTUlGl^T>|=5HtY2(I+YdIws>^=xG{yBkyljfk6{= zIZAp_>0<=Vp3urDZ_+RN1E=WNjNJh^82?aISoqYxesK^RUNxYQ8SC5K`hSV=gW5u0f*yR9eRj z?9gR3jPs_6gZJNq3OSW>)5e{&vQj0kV1x2#mMCE=n0n`kep*dz@mQ+&e6pJ+CB-3? z+0wHtVpo0l^8@76gnnyONv;X7aC2;)sV0(qgF~FGY?HqCAmbtFXEf4efPET1IR_B8 zw2jQ%p#!%17|&X&J=6tH*`V>o3)$GtL~<&zymx1Euz_n%y3!==ivOf(S#C9vz6VS!RZCrdfghMGWLg)qTkEM-8cZ_E^34sLazLt;5SrRLlkP zFIRg|-W*vxD<(az(g6X8Ef?J_=i)e1<&&N1PD~chn(h|RThwGJ$s$(a^9C35LsQqpA(En=w{uzg)vt5Y!pY zgaeCV4auOgk*$Q)BhEZ+8o#`@j$S`p;##sStFedkE@xfN&1FPerjEL%Tj zrxorE^U}bTqu&DSQokj7X9Mm^v_u1c@0KXX>sTGo4V7TnJ(Lg+w4x^7mQF+rcW zg;Q|r0V+%sme-MTQyaM5O*7i@H?dEbv97YPH^JpwVQkV;`nWPR&m_n_e{&x z)H$M)E4T9|&lbWv1x-XnfSxPEdh$z2r5Z<^+ei~mSN22c1@pn1tFhT`{TMtw$(x;I zd>xuB33b8-RC)rID>{edi{uphoBCL{eUw^QZ>FY&?l(gRZD+nUA_DaN)pPzpn$~2i zMhw8Dwm~=OxXId`ul4cW&g;6QRWdc=fsP&>L>pZvhR9Co-tUDb(yN>gXuy>``B5Q9 zn7;ES-VB(vQ^P3o!&N7nummF%rYqJf&6UOnG%lRLuk!Yv~hOjvw2DCab;$;(yE zL^AS}#AnQSHvM~Ct};P0hml(n;qWX^u*RjD&|M7mWxh>zO>osHUwKY z@O75eES(8@EPVXTByTY{b4T*NBT<4{T!l>mF+&;|AHSDuW%nU1|3=UH!gH)Uf5$RB zDIbMgHhEd9`=(P4{5=Pl&PsRn+-7Au>aP#%cetv@R)4tu`6&AJanN!NF>!P+Jf2TK z-7{|{^b|Ev2AhDYen@xsCGJF*D#6LSbY>-FaU^HB3}vHiZgi+@&Ws|FvXm-QvQ8;Z zeI!93aSF4PYLrIlBtX7wE~E@|v9ym7c9?Fw;^)EGNo%@B`{-Rz1v1$KQ>W+J zAgEp0eXU8eu-S^u_KK~;v;g%&Os4^W|^S`DM8%n^Yx1P>NLnG6e;{KouBw&;#S5|FQolXXmjfFr5P2Q`JW7xDdPufQ+6!&t>T5=A6lD(wgmlxaI%b^ z>A40(ruu3VH39l0{Ty%~aBKhM736*|I2#k!kRAOX3aqY4x!O9{+a2T z$Q?is2E+RBwR2D~Ccd$2+|C+YB5Bfe%@@9Ykst@mFJKI~dS7DrgWfPVr>+VAQAW=_ ziew4a35SDet;gQ;KiVoD6qZRwPh-5?Qxm%b5#${N3g^OrYxI@Z_`ein>AA)cv8(Y4 z()Akz!NcKvnTh24_t%w$HNf?k}=&g{&(etGiliSx4Zy?{aYeH_V%qfK#)rE3!W`#zn7VkN61bn z^Wwl@T1&|8fjvVqA_MoRoH)go6Jv9;cYbkN3?A?UuJ&%f7Gw7o8j!uuXjH=s$3}l| zg5>qD>VM|jIdp%SVr^T`f{DP$J#q~uczs=h#Y(^4^97!;-~Y>B0aAx1|LW|eIW%(h zBQj#5=!Xcx!9<|PHFAyFf$oj(=Z1s)Vh_+t>aX$r@*IUdWghE3@_)z>9HBS{e(}eA zc~P#X@e2U1-ZFg{2NwR9FnvLy`F|P$J;YUbllK40gfeWw_;N5C{eQq=MC|_-~W5< zTHVBjn;OL}+Sz}AdtmAE$#Ecd+C1-_^(e3kwgd_wF&UlYHR$!kWxuz$KDMq zaf_18sH&%lYAO$0_89QlWX&mnW-=K?Phg@JNStAab_9t0t764@JMpW;VDWIso<{&} z3gq>1St%L)|9Xt%!FYJ((xM*7L!#U5hm*m8W6-F#(|pqomMX5 zfCX+TZ~CV#dcV^#8&yW6oUel(chVBmJGzFduSx)ww60aV;!UvGx5cT{Tm zcRtaQK7QP6m|$BYD(*lM#T_%;$T0OglmNP~-0Bm61{K{;6=2hE-bUM7TXu~cB^&s+ z@22#cGD<3N+LoEhGjvaGN0%J|O^NLHOrE94v78@Nd}1Y3eWFYNhXmBl&jYQ1K#2hB zi3FVh!^AtJDAiY_*95#4e4D=2@5|wh;I`C@=sA2(MC;RyEu5n zhc%BhXvKxa_u{{cd&F%@y^@|#txYz)Syr!Y)=t(}*KJw&EPrNs)scMNa@{;{7xs(x zllCu0m&mSUKMCF9?gWkqGOxI;=h z))yPuOn(BKs43Wr0mUrEY)4}m>m9ot!ft1`Q`7B?SF;@r?;J0Xw}1TlzMp|?{95_- zMlxB7{<@3o1mVZB}pL4AjJjtuwCxGpS6eLaU(h^X|%!afL5vMe~j_R-fN_B< z{Nc^Z7Ighm=grH#Pv%LarB-o$C*w`gC3Z{a2k>t1#LOZnzrHgZQtey3f#Iv(X&#%5 zk*~VGbH4O}Z(!_#=$gEWTN?YkR<8xSjnl{>GsDvgoPLYf*eNWSq@P_3yPvczzR+?- z8^4EMdFqAsfb}%C0WZ%-Gml>)>I64SCki=`jF0Xih}YcqiPI!nS^54jrK*=$kM^aj z7~Gj_Yv4${Vh!%^g(u=#b5CI@?X}t|O2P-0w+10oCAh@=XCP46Ox6Pt;wC=%p4|IU z-{ZXh&v%y=jo7SmxFWBiHlK)w&wG^?#t)jn`_Zv;Wp_r+?V$-LTaavuYsL6Rgs%8M z-(`)o3u3xPSI%;{+rbxikAluso+){UkA9A2WT5BBI&2~@XD@xf+OPBvdq-am&F0&0 z?(4qY>SyR4+QS#^&Qa(lUD#YhPJu4>%iO^8EvmACTy+=NIc??tdsrn`K(UNoYJGM5 zdkEkoy7l6FP47uhvG8XP(HXoC`|j4(RI>&T=Y+)p6vur;5*bHDWStmlQir z1%eflgvZx5$4i;8gLWA`~(f%aaqNo}H~C;oSTZvKmT+ESQixTlzpS5Beh>$;qBUhjx1?{^`I7VV?}y7Jn{qvKU+LO@s^jjx+==^ zr%Q$};RtNzgH`Z&7JwTxu&j{o8k0c#Lnxtp1x3{uTnK3if4$yVJ)vdp?{`hj;4KWw z=90gSzl%0^+H~FR@Q%5 zY0fGiLW1I5kiD|NzAo>NSn@!-L%3`lI$GSB1r)uZk zwW&Z9RNFvHXzyhx%1JAveg#8lRb*F>7rmL2s#-KpfpvtlkVFpin|H;o*b-MrF5Sh& zdI+FKygE9iG_sQ?w*~5_C$TRrkY_IzGh@=`loQ2Yu`^{dM2C14+efrIhFs!d_G3ue zy|Z-wSwb=TCUM=2JM}G+Bz+hisIaJYEb*GoBY+7=Qy>T&azfq8z$?ho!)2;Ew(_-= zb@=Hl8HRcIhhn&=#JZI)!eJV%PHcfga|RLFuq`S?KQs`RAu;kfryiR$vQ+1aZF4T~ z$hD0e&?O=fSxyf@A)0SdaI&++N@Dz{MDktJO`;arD_4_&IVb2X=zz>zZ28vXVKWL*41dF=XlkX=+7^ zeKusLgL^U1|4Ogn>QPhQjEW&vqaDup3gVBcnP!yrYmMyKFusggI4Ovp-3hAj(CTW4 z(2`M3Zm1{#&7tp`kL<7gEaC)GgYbFYT$)XMGlJs*N+a+Gr^Meh2D%YZ@?ciu31Nfd zVn4=$9Or#VGi(pmUiFvTPBrSf`tFnOG3!lhoC3(TCj4quP_>DH zf!RU%ei|4a-&O~pN-oHkETcC~+J3%Up>LR4tkNL19l)qHvMg`lnd+LIvVZS&ZFeNI z?`x8ytD4D?`p8)$cyzJfh9|v+@X?g5?(T1pTAOU-S%<9>$-qMvG{SF2d4qC>C}Zdj z&tX-ApZuif9QQn@wbl9A(O6qdfxEuEmS3Dq4VrFb4jCCMmg8V3s_RfwOrl3`ZZv-y zRXxzsK-to&szxU7WYXMSPS+)1WWp1w;rJBjpWaMbVvg{(2Ab)8r+2S%jGgjhNL4I+ zKy?Dq8Elv8h(<>k+Xd`Hn+KW(9r_`N(o7xuSeWm420HvhJKf_W9n?-*1$@=LA5)E= zdK;;Yc%vhBpxn{;cVpO<+7zHP=s};y4F!yqM|kMs*0!KI8Qu-W-6(?1{LIAK+{)@4 z#_7Q+$em=rmj#EMzq2WG^4;0Of~m^9B$;}e@R+7|Q3aXoC*b5QXOpl@L$iC5=!T6| zZ?pCI6t~8c0n&gRMuGu|V%JQ$f^1kfa%Okb3GnOa#ZzsBSt{k%!L%G^L8ItM z{j`(I#k;a|bUrJ3pl}pEtEKGsrN<8z`nkDZEXBQ<&}cN4SQ}&!QGYR}rijHYzc?@3 z@xZjE!C)BW=<@t_==e+$8!58PJQb6ckcy+JNg=EsFW-lLzF|8+&dEMkORr^^0o(sA zWozwEP<~2%S%deXS!JceyOpM`Km$Jj`rZ;+|N0clQe<2v{50R%D6&YDB`uFaLF1B% zn5bA7I+dy!I`@4)HuTz}UkCS`6C;9zHOtlPKp`a{i8jSP_lh;B-#fAej0DFxHx%Kf zKvK`Bb7>Kd#1PdnS`J1Ra^eJjK0@S53G+nWW!)2nz1ErRn=~}l?6_@lZ|@SK%RGI3 zXJezYf*%g}omHUDkUzl5LT^TB3U^nSbK;L^qqv&aL@&pq4v?Jnl;Hs>lI*yjl&k0@ zZlYWMSUwhP=N0Py_wTqrMg!*ZaK9fbvenmC zv3H(T`Relre$B^k@`v-NDx;hzy|$p=ew zQD!;GhpBOa&we@WDDY#WQBnH9tmyXsn7sHyxBeBX61SgxVlWjgc>>iqPfw~xC`X$O zumLH2P$G}zNw7_1q-^8DhClcHVyF{C*Z00@2frIy_NUitqqgD_E9V8x8A8aQRYQsO zUV6)5i_uA06`mVVeN#+$IH0I1YczgeMbu=R)kpSy$`5CFqHS?8iG3C8QDlX@<0b>oDKlAyo{#}+s9^00i)cb@LpxG~!h0YEj%9#2 zY*6`2uWf{$WP}zG4NN>pGX^{ z(dd>4@(toOyX5m>IOKcGNtzz_(kb!`T4yCdHZ21j3f?lH6xqP8orP<_V-}}Woi=s# zc8>S)xJp`B`toX5XfB@L{ZN^idP}A;*QqqhJU#h1D2epC0AJAl??-$+Z}tUB zO1q|#_*z}AvFk-7(X=13*!p_uaCe;T9zsQU)CT4PrwsuMCqrj4S&pFLQ!ykpZ5Gs> zez9*+THWEGU%91e;Cw4ijo|O9Xo|j3xG5&xEb19JUT&o02km9&zL%)tQc(<4QVM3k z$)bSDulaYmmievxZUzifKX46E*agpG<4tsU^LS^1bqufkj1(?sF6NEpNU779i(vC_ zBnDvwp9#x5q8ffYnrRFN;nD&_c%zm-AgNVkb*S$@Pm_6t|q?bBAq{z+A z1z%4HZ(bV3?(cws=USP)_Og^Sg?Th(OX+)M<#QH`j`x%PHTybBS=_@kS5nqYZiRH2 z&!DcnyM-M>T!c-!IDCH-Xu?7 zr=^0lV?FZaO}u%2dL+Gn_7AUSb*?_xZt?hk`t{jL7#o(W^k=38#Kp(OSe!T(TZz4% zt7`Vpe)DFYQF!iwIQqdl_K`o8BH7)=QsvLzsjQY+Yqykl5^MuR7sY*vR-56I*&}VG zrB|5)t{;(&i&<)Z{y3MQ7xzvp*r^NIK?!oT!x3LMo}U;KTtBVaZte6facSY4K0G#C z<+dz8#=?t33@QyoFy<9OTmd1rx1Y-Wk9;-t-{{GF~FTn{& zYx_u@B;w9WOELw42*i1SR~K%hEi2~oAHV3ExjSM@LeQX_Zr(?K;}dZQr+CYxFg6lV zwk29oZm_i#3f58UfN$;vJMGu={SKm8uDpnfl$w$EHR1;#hIyGWkztx;2Pl_^I;$%< z(&3dtntgckpycr`XX9E@l;Y=o3PRb~DJXnos9pRNbU)`&qz~8{!+$f{x>*U(Js$#^ zZMTsm$$QG?e}^U$_XBW;Q(u!@`YHLt3FmyTz&{nO0`kvqn!Vs13{To?^sKGo*4 zL{EZw%JKJ7OtiqQs>qF^3AWbp6xtqDel{Ct^#7vl9Kr+(mMmPhZQHhO+qP}n)n(hZ zZQHhuF4y!d-)6ACyZjS=I~c7Z&Pb1M=Hhj)!%XjEI`S z%QpHl#YZRl%V?*iLH}=kYY%b6yG6rN*ww%|t5Hi?YRixnyNb4rW}|TJi->l)j$&11 z*ny?cb=doyMu=&_v8W7pxPDZK|aRvbCJ^9;GXLdn|7T>F-uUsag_4ht!_W zp}PL{W|A#c6^GlR)$K_N_FbUw?--WcD#>(3)W2}JmM^tSGdG zvX>jy>Re1bR>Jj4;Y>e#%cUILoc8hT&d4n0=|B?Xh!Zn7Htn*{lhWg4TqsnM$^Igf z99Im4WmbC9ASzw(N~F*o73R6x^tR zX5lvOc=T=!jRwBOSyn$xm2VzlYR0#SC#mKaN4ch>3J&s&2bFRB$%TUAh2~;pTWVi` zqq76XeC+8+1EJo=#A)JV_zqW8SX*|S8%|v&8OXawC;sGr9Fk2$7F;8dOsT30w6ij> z;Zf8>Pb4(-aDsvbn9PYUi;HO24FGlXYTt*a2KTu>hx+H^jk-KvBph@fj|u9&?xs7d zvDj#QsZRo(o-sJ7#IpIMQTaCV8Az#Ca_xaaZb%eRYMYH*pOGZf2G7Mm-69QM1Io$A zp+xc(u#j*4GNOinCAmgr>XcL{L`vP2YAz(+w4u3;M06G7;-Xcs+8VwjGvbR1^<8kL z9e;YFqPI{>JtTPvfjJvC!&maXy7Al-%eDb4qoLUpbl&O@hZ13;gq!7FwNT|VrgYUM zGP|xMo|y1NGEfVm@2N(s>bHanQMGK=BWILLH+A01m25+c4KV|$uDcmltO+x=1v`eI zZE~EJH4sTH>zu;n)i&w_r&J@b4(peSGb$T<*i;}uAthCX3}y9F=<1}1Q7?;yHbhf= z(5!S-EkSWY$fL(nL|ZE#O$rci^p5+@sb-^g^Kh%CcueD1>OeOpNl-OmXi!ybp`dUp zXADdB#@eVr&g+mgXurxJQC5`W=0({Ife%dbU8gjootDe8X*6<$kk#nUmP%V(wjy*+ zC4f{ZT}(ZaGy=4Zmu2=>W%uPkp)(LQ=i`fUw>R&1=os&uK}e?OH`S?kzp5=(AN+qVJJ8)|w7s{ete0|Pqxq)2?$1&C zJdEAm_xxPOhFO*Ka`}3#ZX*_5I!6Vex(LS1j-1ydAW!tigXC zc3*p#JN0}X$8!9Ar*BnLWX4r!T4e;Z&4AEQs0b96g`PFQH&Lz-D6aQ?;Y5FSAanq( zRIOsDmznFQLQNH^R1(+ZNWELl_mQp%Fozl_48xbfOkxk4sWUN9?gT)uqku{64UpEN zh-gjRGt)XY)_624IO@1E1Cd!AIs&US`)xCn%T7leE^zEHlVGG;M=PiDFI`;Bg2$B8 zC3Vy_Wl(fPJ3Y+9gs9A@iv})L+QlAC>m8EJBsq{nJv}ii_tizHPqAQ&Qdr6|IC;&g zJ217_6=#-F$_(qa3B__xWCUbHN1|CQX+)3YOi<*zVMon1XtuRt7bUQ<8<)z(sxD^F z-HdM}MaeF-WV-}i+J}cdww+E6W7;qJR2Wf#4tj=i&_*(hD&09u192WcNk&IQWyT}h zPVhMW?XnO=Y+oI#1JaeqbPK(~{6e6`M*@yZ--f*vIH&f=TQN5OCR~-N>5yn^EIC!_ zs^UW6zE*wzjXqHvGWvj6Hw zO(nd_WswJ`nqgv1RPEEi^GFkJOEOf?1*@1|LO5$)c1Zi*tt@j@e;_KY*j5?uEJW zWUfV3L9bCAO2BLomUYf##7avm?Hz+t%QQppY?~rAtJTTsaFW+-)Fav(6!!`%Ojjq6 zq>>ga6f>x!Beq{VMzwl`a`g-q!sDZW;uet}lJ3q-^DxaE(TqaR5&Q^GQ;}RzeSq2i zgSJ92GAyh(ArSRCISsjiC zqw2)5-s!6oca_wDZLw4;X-$GfXd{nsASLm$*!LZ&guV-47gyzmz21w2*QV|-ehK=S}4v`TyHZGL4bLg-i7QyYOXb6Sjt>g6! zR%!yX6 z1v^*``HxwVRm?7LP&upwC3+W0-P74U{9=U&L*Dg4o>&z_XBy zc6oSI$uqT7_%&JZ5>r5uG}{8X{9rI2JL|CgMW}k#!joR@o>l#6t48G8OsrN7Z_0^` zP&5SLrKDzKjifm_f$7GjW0WcxnL#Jcf|5AU?3GO>B8^t^>)1#!xm%tI!ba%?r>^Zi znX7rjL;A|Nw_jP5Elf{(cW>L$0ISL^bv@=U>q7N7%7hv+ zyqCU07^+-nBh?cO&V6!?dVZtVMfd4Rfdl-vo>9uz6OXw~RaI?;79N}}lpDxw!rX-N zMMP%FuP^a?juw}NNg_fW*+^HVyD`Z;vshq|;m-W;jlM7}5V_Xze$BY(h;Gj&Q&!u=Um zPMxb91y5U%aU}mb>CdDkLBD@_nqM#7&?{yn>DS%d?|b~<=nODMM9ET(r7RHF_dLIS z=PQUn*h=|C{VL$M?v?6%lmlM%uo5y&a7hF^VRpRf$9w3@oqi$?_V11T5vTMdVWL$` zs&j@htiP&h@7HG4kEuyMy3X?Co09Z$mfKIq+~&-0*eR9Y7Tqqzn6%b359^1&Yki^( zfb{|->QAFb*$*D?px1~$XF{)HzVAwG?@U3DKe~S2Ppgl){0jiAg|Dm~`_*oEDw4ik zL7u%;AE20_w=ItIyRRp9d>yydml==~SB%;SiA12I`gQvHj{*YaUm*h_)G zc7Egy@_rrdqB}+m;y1UKiZHkTQkEas`PKB7Y`_dn2F+S58}!xQW&j8a{dR1gWVs=& ze~zU`6;>Y#!s*@UvlN%633R-DMlx>l(bDzOi@$BQwWnTMRc>9*UwXeE{{N(Q2`V3p zcYp%`q|*QYsa^j~D*PX4hBsO}_FHTS{`mF3fm2gR1}&{?a*l~)wu;qPL1gE6QGD}A zwvHtd!Nu3@{@=Id@K;NzG+W~VprBZk$2$-1d*bhPxkiF>61pFC+Fz`t*9T{$B&| zssO);Zx0oWG`W$ouh+YhSWOqe@o7OlX}|UTRJAghlHy?)&rtB9JvBgGDITz83ZsLO^jxsN$uOG3^Uc#wS($c3=NeF)03H1aL6pPH; z2&92v|7yu*muRTwPpT7SOb_M3q6QVP85t{Kw;QF;t4N~O&5QA{00rSPR_Np^0&+zQ zA=*zWMyG+u%uXAO~N~BjoY~M8T8848QOHo!v?9ygGr)-^`5y`DIU;Ss(kLkQ(Dub3C zy~fgH!eqd+0h%d5KhrHy%!U9bI@PD0uEQ)-KRS)^;s^mc`bn2r6FrSGT5_P1#@Ax? z{2h@Mu!Ur%12mCMeLy&AJKk3edL@S}l2~N@5m1#$@-hn0aOOn4+1=tLWBr3YLXOr9 z{@+|Lyec+3<=v&K?|PS#IlV9D_vRgX`6w;}x(x*}hC3AZGGrMg zwSXK7(n4lHGv?C;jj*Dsf~zXh5l~>qu#(d-VL-q_XOFP+?{c2dIetdab~GNUZ~f0v z;MIE{6%iMN%O+F6{(^D!)Rf|0E+alpz$1+Z;XDv!*6P^fqNm4Gpkbe~I8hT8Vw2 z!C_HHNb3w{7-uqp40%ctS*M+roMDzh=2{C~go2|btmB>X$<2XVJ+ZRV$g;}Cl2XSd zLrj6wqD0?EHX5FtN(TtofzFauR`=r?IubSV1XVq#=Kcx@I`>L68@s`@--h?APBG@3 z_ZY7(e{pfc<^oN|(3rZ8HldzDg5Uy)+8a1)jQUnXHc zfTGTIcnnvu)-+SHG_XR2L@i9cit2tVOja3kLcMzg>hIg9CNuQyRzY$)<%{(NFgk)O zFl(R2DeM+}U1(ahZMt;~J;H3t=C-^Xn;f%wT~zoD6i; z9Upot^S}n#ZaJRK3;=!hMeu_Nj(~D#4c+O>1}z*;o393g2!b}guT$H$09CDOiljcA zG*rLI&tbT)>6Yk!1sMaREe+8`l#?y!T2qjk7{0*RHSuhmtd(i`n@~voCzraUbn^{D z`_=qUM_4CMNG$;8@x(IV3c2!rX%fDPjph6&%h|+pO|O>(W(?& zi?|IJ=ipxz;n(f>>%|&u#b*PYKadnhk3~V{p{i{pdHVVXHnM1rFdD9+jlUYQYTzGi zheRMSe}#2xI)S#?4-LF;T))mM6d0w&qrq1sz)$7_HF8&fdFQzCO0`Fg1#Tv61Ylq5 zO#t(rs%4NgRdu7gG;`nygFzxk`vEJE!5i(Q^5*)bvbdm+bNWN}cj&oPi4-a4163 z#pOyN3wGC)FxAa{;En2eW0w;`B^mMf#X$Yu`XO6h4c|S5-Msg-^Hi!TnIQ99IUxq` z@)qx)P1<7&-ZAHz#4S9!g|2+Saw`F_jR9eTo;(G(y-h~L&CC*5plzh&r67&zLLN2* zOu3jcYR;O2i7N&{%+rRv?R`qUA~-Pc9-%!u)u1{r0@QR(tHdu%>d379;3_OtRaf;R z%$v)gW@p}MSVW__Fx|+zqPwyn8zn6W1L*JDn0T7ZId7;Q1Tk-eaz_P90k)XB$3)+@ z<8w}lYnZjbN>i(#MpEvW=xNq>y8*7`dtXug#eO@|Q*;B&k}b>CJRhP5*?))hi{!25 zNp%^})4Z2(+le)(yO?iRE9m>6YP$cf5#jo^#YVeC!lhum$z;?F-5L>w;TfUuW_~_B zN$~t!&JeruU zUbP)>zHxqd5lxul>#zC?TjBQcvM@%~qk4Y|x%rbB2-DMCAt$0lFUh_0g$&^~o&WFw>{a(>Yd`>wh;VU+jt+6=q+B) zCmOn5MYIt)f@!pipxW$HwPC!U5lcJ|nY%VdGc>zPy@*madzL_}2pXP{0uS*BpY5%; z5Tlk6{MZo^_l4MZ{@nB2_301zpB(}y81nY7;6ISD5-Z1x*0q3<@XM z2GUI!97M8QOl0a|;SBl=@P9v4UFW86cMLsx@9-?mOS#nD)zwwi)#o%FdXKo`juw9H zdmXdAao@KF-}n5f&;6I$KeMvAuW~W{?TyOJNAG@uhoo)A-9f`$aXnPF1i|U_aA+*G zT_m*E7DsHu>Fu`6&UQBApy2q5n;ICK;wFrDTjQFP2VMPk+LmtF_S$e+d-)XaIGW1M zECY9(FnZbw6qZ*pC-0;#Z#Wi~Jl9R%{v?avY#y?RjP#vj^1a!+PrB2KKl1iFfBfnm zal!5ZqJRHv4pu(tXZD(p^m3=+IBg?&?RNB7uF+Ju%c6n1xTSQ$6}s1AZ{99Bw`!x> zLw~GoxQ-_RirO%^o_3$UM7OEhvd;0#9Om0iN^-54AkF4{QkB(`?RK+W-2J||?+M=h zyd>1saXQv1%WrsP$=h$aimVk!=V^HT7J9>LJdOvgqSEvBUiRp_!12C@nz^4Oh6-Ow z)%o#sG#*L*^6d{@+;DF@58uM`xDJnV+xdEbZfr<;-?W{rZsEDEkm62+HgSo|@?MYs zv&UupPs_LB@Sa{DJHKv`Gq>W?S zi1ap7t}b5hZIO1(s%k@yaBA2eaP&cCA;;d|9F-)bM2Am6ybOSp7yJ#OL4Hekt=W3QTELkTOMt&(MG9+x`a z{{_e^hsyjj_mnS)MilHykm2i?KxuKRCUZ_F_Oj3LlF47(oGqyWnf%r;sCd%F?rwTT z^d(8-;7XZ`t*<;Nm^3$Vpm(UDV9gvL%iFGO4)1kr+|m|luyY=`OV3>u>1X%O_6&GG zF2*ljF!@3c-eB1T_%?XXnix-#ihVZ2Y~F(V%s0vI8pdFMf;7|y!k(G=VIm%(*bV`n z%b_UJreQ5qERiq%8Ypi~ul`#oqZfoQQt)F*@eCYVs^XN^v=!@*gr$wko#3>W>)T=R zXBs(O<@1;JqFhj!tX>}+WIfS5-yI!YM`LUih6%u^)g4YZHNFnOXhH-g2(uQ_5mc^% ze(4F})BmXJbS;667q)J~d&OQ`qad$N;MC5Y+wLXh^PszslSHkPcbIap|I( z109BUgTp=rf4Z-AFWB3ap`ziS`bSi9u~WIN-D}ZNR*Ocyj-s=F(GK1ra;WDHla~!_ z?S5%ZdwitIH_Q@L|JJp_zQ$DJ$yZFzXlT96wQuNTukQrV0F5~C!q0%v~+)=VK-K$Sl$?M~9D^8j` zPyfU%#nw@8P4u8DcYojA7D11wSfsZ+{+@fB4(z~djHe~UK%0S zwpfPEhgUOKZ_Sr6dx>bDT3%j!%QC}40DqxU^8g))MGK%0CM(m$LW*0soHr9{&ZS4f zGnONbDmCA+jAcQOA45pGO2ACx&KSZ-4Z%6rf_o6p%<{uiE%NvO#{V`VzO&2dvwW;9W)U+@WcSM{r%E8UM=)`pg|nRErBv*Zy&KW_`(i#k|nT zxi}$?jGrUASNmmSQS}9g9_cHaqdU+evz`#wwW2VK&Z9#kTCGqlI(avjFLD^!^j`Xm zND$YfzOQPZXS%c*YF0dKnHD`C3t7d1Fqc@x0Ws=`l{1$CTrGI3g>p08u?I_{CmZtP zU)7tzl#K-C9(|ZCSJ{BpQ7KE9O2gk5tDJm8Drrjarwe}ADbOFgi%Dc9k{sDzK{21j zl>82JbA%EvJ50!>Bz8B#?>fUwp2%t#c0!t7OC%$%C{_~f)4uLh)&Xewfl?`m9e$NB zrsQY(L1^G1S7AN%DcP;%(~;{)_xTPDXdK%sn))!NDNZYfMKpxG?Jd;K z8ccMjc3o;|y6#BHRWc*Ro0y`Y6S1VG^-V$~qdZI*lYVfBZ(cfSYcJT-X^>i3F9JUy zJ{~v21%k1}a|8OkWhT)58}p-G^p~;+%Km-1b)@^A^URGW5#r>W)ko$(Ui)k0DE!cS zOSJt#8sR==dV4^hCIXkPJf53H7Sg=f5cYqaIP?oH1uoAds$=o%tQ+sWT=xn zEPk1z=rfc5&Bh!0Q^{HJmu;$i;4T(!ikKbpQ?+-2$KDAnN!(3lm?RE62g}ps_n&&a z&pwVzq>7WNP7#m)6ACNOW3sR#cLUGk_Y!~pRx!K-8L&U%9O%^X>m%uCQH%8VjWQ|d zr2Q;AF?3y^GSUvzdiKy)cbp$SQOwLQ4H&$#jr&bv2JLUg655dZnfOOYx_7Lek*>IYGhBWBg zqh0HjzreA>$T`>#A_H|WHmbvll3fwZuB(O5yOl#@uo-L<*z6*0`F=y~ezkRs4`E~g z_AU1XQEw@{jLsGowV?$UtlpaLu&_dzsi9y{JD|XAa{Lk_r7yx@J6`lK)1tLTV!QOb zF<_>N)^N~(Q!JpBa~QeO#u(D?P0@^}q_D;`4?8j5%<-~y34YtPf7zv&$|h) z!Q}I(@}r|1ErXck-Aof&nZx*dc^Wb;UGo$sk5xUZy2YA;ndSBZ(jj|{%PXi+>N4JR zASC{2-Q#X7p#o)@s%uJ__L;>5{wGWf_ zfA*od=jtK5HMupJihC#9ncbePb>;={_)aoPC}f z)aD+~jb-FHKQOkOg`OE}Ys-*6C!bx$dM~}@VtiSjt0R0_U$ap@tu8q^Us;RKlGoSf zbCr$tXL!p*^-K1Onij&}H;9vl4?-w+^&>ZuejgYQ#)nuw=l0mC_qIO(} zG#!J+qryi`MX_E?i?3v~XO&a7V7qE)!|PxT8bM{)0=hwuMZpksDPcEGa|v4m_3FWN zexHWV+->OaryVa6c~S)Ve2}+GeSBf&^krFU<^_GsrQ8h<9u@~=)0MBfr0^m2-cd=f z=tfBx{bsr5rx2heRkpL%F)q>XA-@Nq_gxzm?o;NykoUpqjnG)@;|khNV$}1@nAcH zF3QswF_jxK(nfJg4xyODUoc7q%Yok_B$dLSOyXieQ!fSJ;=v)EE1)#>k_j2ngZPKX zAYIq+O$GAh^3AcH&r}r^SbL$(qZv)fqg5P`|$y=%3 z=?Sjcu^(BxgE6;Nd8ZPedRM>L(7Y6%8N8}wz5x}TDH-?80J~4s3+M54an?G zigbf4h7e#0!meNgcUQu~I^bZ*%)ve$g-%nqC%xuNLaa7i6YYGn_C&|)P~U6p4|awW zuf>E+*y<7K#fE8!fQB8)gQ2~USrAWz6!Ur%Kv)y(~aO%$-CP8figp~QuXXnkgZYXvBq93oX5$46H`Lt zeHxOS*aD+Uu?G$3iW;Q462s;!^*OIy1FxlHZr|h>RORqA>s%i%T)Cvsf-3A`j46Um zc%_AJ8mz$?`2ac=fH~gMz!n2e%6fdeka!nPF+C6_dd_~5K^YXNHajht`y@(oqwA|;Wtd>N7cDhxiMzr zDB27?`z5I!lS!;>KVX!i9O};0QETnD;MYuPJ01{{W&lvyqQ!L7#u~7srsjBnK3Xv6 zu^VQIO|y`jcGf&6T+-f^?uZKVoVk^1XIa`p>c)xzN4&b;#d^`gz9YYKJzrRnaFjwu zo>y-^@@D>kBO@Gi0`)qmiahZ|2yY&Bu>pCCzw;YN0*BsZmD&l}*9C{l<vjZO;vJI1yy( z5k-|TqW*4%He?I>{BT@8f@`aq{Y;HXoSy2{==gt5Ar zf=OtY)uajCXE$Kj+FM&e#$`>AZG)YP*gANX`DF|HsDo-Va2ev)zMi6$m|XfGcFx>N zi#LVyy@`aD5fjCN$QG?Dwss*AMkn~+is~cvLWK}YQmSx`75GyVla$es-me(~ z!aV?YyR6mcQy9X47q*^1h>&sh{-n2@{TTP1@&IT9Qwcg}W`s6zOuFQ`_a&+%#N1{_ zg9-lfLED1I=FH{4tT(?3bA*|bYOAqp3*-)-YvSMR-P|eS3XzP3;gg2k=yJN%h|8~d ze1hNgageGvoRfKOCSgxp;e^_?L?bNLReIU7y_2x;D+i`4ZsLZ#kQS6DALi9PYolHt z)lD#!TGYA^&=|RIB0uMp9Lt2)+LA^jS>s>2A}!8Re1)GMY)|VZW*?-g1&=sm|NLA} z68XM^5aZny-hH|rrJ^ybPFzu0c3|T9HTlU=Ur%tgfx2i)1izXzhECc&SH?gk3=lluWKR@!w>l1bv96l-vN?Xk&!P8NS=ie3wgt}B@U{aH z#oo9tUcd8jp|LGWEo{n@nq|C=8ANVyuW2)q4BHA|NR+$@juZL=xBcX=$6vc2A0|}m z0al&TbxGN4R6gm?1y?cpV-@6lI)*&6&=*?(!%ImAh=5*bn{CB@xH&e&Rtdtha$juq=xt6`2$%m%S$OuXc_-cxZxAKPv4YY86AD-f9e_TVdCJ5E#?7LlP*nDfdN zXIIy`1E+i4#ZH{OXeax;<*8d`^6M7E5VZek>n`H?dgKZAH`DU{hULY-O3U};T3z{a=OvfMFLX*RYsl6QM31l zczz;+da-GLB+74fHRYVzreEUJdbD)BbREc2Nyo`LPa1-rq*0})MW;2ZQobQSQFkXl zbv{O>*fsA;q;j~Umdbt@D>k-ZVV#Yzi}aC|{lqDr9E7tEqZzV#}_TYI#Ph{f_WDqcVVmusXqJ-KF_ZCw&FP*;!v5UsFKX*#G+dF zbi(x=)7(fhRc~0RnfY(hf)d#y-Js2&hYUcLw<2%(;;fviw*s*2Wx~1rj7Z+6fV|4O z=$%Aa&wgHieii*Q!%f4NY3dR~j@298{B_m^C%8+Aw>>uxIav(s0#pD7oN|27Jzm(s zJh#)$i*`)GzEKq4G<}T4Yp`_sx<_}{3Iq}GZrDCeQ}4>wyv!oAZ{sqQ(!OxbIT*i4 zbum89h&(FD7tSf=xmkQzuaWlij%#V1$@j);hDQhvc)c(M{mhWe*f=Lx^)K`Mk%>;} zd$`he2L?C(qk{_SutOL6`e<8tEO^Ahw#OmyFUV#KuEw;l&9!7i53d=M0L)k^AB&9l zWXPz8sQ&FV6L0DYQO(KGKLG9m40o9AHu?y&aonQhj;T%D4%qb<0W6(}(8N+Vu%#IdYjc?b+qm8|+xO?SALjOfEH zP0=bH(XQg8Ke|DPZ+G>ySIW3|3ZEFlw&Dux|CHb7y91dx zd4Vg@TY_$ zSsD8nH4G6Hi!N5BKv#gr-PDQt#-gnI)j+3^_}OnT9we_TLC8(`awlW2=Gr8=47%u@ zA#U+Dve~9ei2*jY$wDs~|0EBVE*_PH4w>YKG;Y|Kn1oBM zk8^KbPd!$#u-Y4d6Cvpj3y+fLUfe^XTg(-3dPR(5;RpT!77?2p5&HR@M_DcgE8HHO zSrgtIuX@Jw1+*2PhRRXJmjV5B+`d;ruA|?*GQ1~C>*oM00aZy76lkfUTb}WpTp-)cklT}jPE#mb69=Ydc!Xmi=8B|&KK`&w z<@yM6^oP9*6X+ znS_@C1K*_?Jvt1zeY5yYLywkj%rqr2k%JNnm^FKxg?NIJIY?UiF8s2jP6W$|$3gHGn&>>@cdT;1tvm1lIU0#EqGY* zs(4w}!8zX?8mk zzV<5aWFN`cu}u1cJb!3QMGftPJ_fzN>~8!`IaFPF8;*_3R72ZAqB-+(m*jt@*w@E5 zzbQ^FL-8V|2H_vi^|xkXK0o}Ph0jTBY~T!df}{p9>9^ND2G^ps#K#4fyqLTygQFegiTK<+ev}$<)jU+1s9#v5-3X z2)X^cHfZB^rgO(`(dxSZZLD*frtu)2sWh78th zm^t+U$3S&x+n~=f%+=5Ey@8xg=p2aGVMdQ6z=E)pQ}`zr{!af&`7IBm6olfEsNBA;KOEz>a#uayHBi*atACGF3yasX0F zvaKF&;Iv3|8cj#ffg(D6va#6HSEFoB@diBXfc6zB@HNCNm?#wdiQD}>F#Q>3ZoS~U zr4Ao>lYz+xQ)MSG7pOPZmSWeT{9m33~EI54~hkueE~NL2AYPmxcUhtbslI<(Rz|g;$ZXTIJcm z0rCDA*rNBw&aLCzXTwEM1DS^i=BgD9hKr(P$ zNMmm}%rA&qa;U3xvbh+m6T%~Re6x#rwR~aH7|8$(JQ_i|Jc`!oenC_Gk zb9qvO>vlqZTvXRbafy#0xA)Im6ds|k0_3fK4p@!AV!ty8M7Jg$QC*56$%EF`Ctr`6 zi+6z(xn3?EIJ0fn^MQqLN#`C{QVaOO)@239ZZAW~!|&sUr4RvFmsH;=d~k4=(1pXa zV_YrS=>PG8RTE~_QHvu?+Bfi`DNjZWwt|ulvl`8-9w(l4;V?wYNCu5xt_F|KmKA3I zJPiU)^30qY$b;*urZC^1Kg~6N0Ace>&lMs1+X>077eGk0wpUs`Z?8=P7qWAU9Ro6& zP}T^ql)Es3b3oRS>QQUpaex?q(A3IU!VIQ5G!yBiJzC?{O~C*=SDPBdu>u@t^6${D zy4%9$KG-}LU2bANKNyro>d+Y#&VMLK#D#h{wYPxKSRUpPBydVh%o=R;pQ z#u&?u?~eT_fc9;RGS43^l^5^XLsb9`dLjU}xU}-O1T#;D^s@#TOWj)p1O8P6tdG#mH`Nl2LZf$;fDbKp{5iCsN15k-5domO=i&1XY7rcZEUA;~ZeZ?f z7W_-NE@sVwFFW{jUb3L4d2F`-mYyx>l+h%!`m(;+rW2uC>w@Uz$T?^7HMy`BjZAZy z7H>|3q(+H%A|CvJ(shIQfWiz;tIgCA!eogqaBu9Q6eV%-_!E;f)NMH`VCC5jaPts=qE zhc`avPtRH;tY@cU_xC;ZyBp5g2-b||-=9HZ2TB2^>@^*5co;mud>+LwGB0zEA0$u1-NFH}p9vyi#;;s=?(TgY3iIv7ob9RumiA=zO#`0d$uXHK`X<@- z>1jj}D5ulr5i9IYE<7%+iRJxxN2+5;hFj`tes|)Pjvv}3Dvok(Cno$PYB=g|m2`Eu z#|_RL{4W~7G2EFOzl$>u>{C#7vi*BQhn|nwE{yNEMfm`E>*O-*?T{9#w7b<BCl_ zudYA-bKsl)c@eh7fP3>(F3i96Kw=Oy4v0-|L}mb$np~n5&hI4Gi~@BdSPZEPJo>Gg z33GADbCLNc`dB^3P#el(jVg^n>lI{mPEpr}*%Vzxzd(0?p_{lTA=@$Z`IG9|toI+( z?maLDy)FMGY>)3i*@L0toqfN#(=$ny253PnWIX*kYhBn>z}kd7&p_Kqr}bLqy0;{m z;w@j?4Pi5-ozGkyM(Q!oCF_yUTsK$7N2Ri57+dx>eeP>l z*DrNzB$3bpKQ~G@R$zG1@0wH<=XwlG7fJFMIWbSjGYAUgne`Ue;E5)Utg`)R18oNh z8DJzX+24d)#Iuy^r8rS}zjOv~8w`AMf_^^RB0f`;H%!5@iI7Y``CXQ8G=ftNXK}6n z+M&)Wa+eA5#c>7{95cC@P$vOT`;nCqavfxkI!#tVF2q^QZDRb9xXp&^2`XWb+-YGS4;Cub>xrm7?SdRQaRbbZdi&0!C{33CF5xG(NhzGHn&dCZzB!`2|4R3pv ze6y8XwKU3vW-u9yyc4<(xWR?wGx(GqlHWDV?TfiUw3=IITON~JAQD``-16Z;+3-1I zZZ!vhm!2!wyMVHITspd4E%7AehO?9r|HSX$cz|0f;!@fm6-fi_Z5(Qo__&C#C3G>;XtV+M>EbKFUH+BVV%nM067~FMx}>Lg4Q1 zGXazvCjd3QAe#C_&W=V1feXdGc>yJ?-5)rP{62DI^7BkUGo>OK5e&?FUMJ4yjCrHp ze|P7Jz;I5clwrU_d;O6L|EAUr1y7u8*sZGgr+ih(lFT6rZT0VYi6Bu)f#rkmtJH~Pg;Ir!wL>6O z)8MLr7o+nX;qWfiKkhNDg|HT0JYi{=M>t{F~4o z>oC^526-*zYGw2&l8St!VXhQ%%{#<;81LcOqQB(sRw}Ece}Gw|y5!ct`E5}FC_^xM%zHDjUC9enp9J6@mUX61P z)f3eDg>_ugD=eKCF~lBe3=qvmH(f`_(rZftg2DUoR|ftIus~10hUYJsMrogEMZVeN zYMQT@65RS-@i0D}^MS7#28Qi`Rr!JhiZ{ll`Eb8=5S+t^~uzw$}N`hw(+m#s>>a z%*Kb;nTW)-IKe~Ut;f2-!?N2|6TuIDllWG=@zXaqQ+ikq|Ec1*|uP%9EIfwQ-3){0?!SLfjSA zac3%z2FTM0`8~c#m;*d`1|OMRzDvH{;8{SQ!w*a(*|l|k6#6Q&9QaJIO~j9QzH|lM<7HdE z$LszjY(H^ieYk!83fH1F75o8}aJ`AS`9qa|J!)^xYrjA6dF>XbZMyWCDQlT31Dk;y zpk$nY=g0(q6w=4I35{hkZoW#_!3nxwO&DjNInE!d?hn%DRixG|*CHYO4{8$Q! zX#blnDP)9 z^p!rwC`v`X`|9eP5#qbgxK@sm$o8%(e*&yM?MAk|ZS-6XI{&Gu3SzjlrvDiu;xCAP z8lMY~@=`2j!ntlCzJ|H%k3`M}{FQl-&yf0a&bQc71^nAUz`vvI;&(YJ%&2|+e60EG zvQU!p3}P8LCi`NK?sBy09|_sBM)uS+B%qf46G>pBS^6T*W6YMLORD^3!tz=MN7!4u z0{Q*Ra|V7WI<2$oIHE+n=$Mh551l{g5sFoiqZF$k*TO?J`Fd?I=3|v8B-{9z)Dw&n z?q^mB_cNn*{J91E+yHL0fEx|qCJVU90DfTszc7HCE#PLegB0W8Itd3?@))^-rO^LN z#H^r+JGdN+{zz2$$Kkf9pO5^&U4?!aVR+apgoi~MpY!A68-4yruoGV;EN_J}uO8s6 zi|nfzp33z~N3xZ(oSICTGk3!%?KOPnZe!l_;}U|!%E|~iqmxykD%M@&=e#w(p7H-N z4u$93SRApjzBYFL4=z`HIrUecvPbcZ{t7bk8tf_FLVYkIcC;sl<2_#s)_EXU*`uo@rP7aBy$3JzL*9%=L9qvFkuzPeIeNd27dt zzoA3f-=;!)8!dfyb*Ey3b@5`(!|5u~c@gJ?5i^~_i!D{4X-X_Qqd9y7#?GjuoCmuy zRDz`X{L#rcGe`vX%xZ8IFo_&Rh&z$zKU>gO+qGnDWPP(C0S1` zx?6=r+$Vvn3{@>oi@^ub*GkkXrELyekWzL&(|U#d!sgNhh#Sfkm+Mn8MAFiw71YWn z!D4N6tVb!kZ?%H$y4XRYF_u{Y5X1FZ;FNB&G1fy2A29%8I2^nex^K5J)<=vKVgST& zeU6+>u2iYShEpmWFin8i+BU6JG{~R=ReXE`r zh^C6oLW<8M%RV3cUchfqYtKrwFsj1y52F{*@ zj1YV-a(tTFyy6z#GplNMsg8=O{1ReTDTCKLo#<4-Sun(}8`KNE z0e^@yYDu9rv-e_!ufsB}OIX;=yAK12BIb+5} zc0mj1d6SWKO+JZOK0$+mh}THJjfK{_ph>Zmiy-3g=%c+Z6qf2p!WChu_Wm5U*InCb z+gi#+9p>yT?^`L&zQtTG37=WMwUxrT%U`g}_P&+b!lu?&HPw}R3}~km+0joJ;*{Zw zpDi2ixAXr%%>SX7{{S&uuYv@87ox6`x{06M(9*3#CG)&jw40>`;7e|1UB-@RN~x0% z5pr6>(kFc4x}zzXf(PA#E7#m4Ax~rI1})0^-y3blLd*vd4U6+d4FI=pg=kMmY~3z2 zVHbtxfe-DUhs!H_mM5kjrdZ^@xW>yy{DjvIH9m3TVcW?jzWxy}ujU-sLAE{vIrh-I z)MmHvTZ&rPzo<)08}|r#Ea*UQVH%2w#{!iho~;UG%4ZZeq#Kn_qi_d4*Y5juoTI$W z##>#wb97zIoni{^6n_jyNyE`4-FG;~zcltj#U?Qv4xy(MU+)EyPtRS!?6MO|^bvGO zw_<(B0^zcn4fC?Yl7$VLz2+pJ58RVdlyLz>Lz>S>M%kx=MNsY0e1d!X=45U@)R%Bf zKm9j8cHTojOqeIP$v&;#otZ05Q?Ssnwy)>08ycQnj3_^e11|nhS9!jkPk>}hM_s-S zI@7jLM~!6&CwbSfUims^vI?;?v+!?nJKEQtls)Y0c(=M{!c>slgLe+981ZM5ur7`O z2XUDkqtR6W_NXs@hj8ZN4wf%46+33jGZ+bmV-$M1FqR0_Xhv>}!&syTuGzprF@I=+ zLP>PW6kip6(k-Dr$u;(oBb~xFqE8xT&XN2wDsQwr-C&Gj^Ca^%7MO2w`i4X0A9po8 zPBCNIW*EzH=Ghj`?Qh)&Mf57ZvM(Om_I>!uJDIP%wVJOS$NVFHtNF?{hPMsMSMEIL z`9uw0$(anqSGL9Z$_O#z1u+v0LdKgXe-DJ0&W2da$JgSeD;_%G`{3m+#>;Khcp1;_ zAKwoz6Bs^WP`n)c$!oXQ;AQ+^c$pB#%UqWTI!}At1XEfYSXkq_!8!_dEh7vGaD$1K zua089qpa`3>vvTNYM zfakFW0>p64{zCV!ZHz+@qktFyF&y3^aVG||?7rR`v^nbZ4(arw>Ff^kEQa;%-|tt& zd$!|S`@Q&m`u!g6_j{`Qy@UI=qhG%l8D1Q;->={0pm{a@-Z5Ce7pvtgxrJj_*YvRI z*G|)~Q>yxPN~~W`HvQ^#KVZA#P-QRc0EppySqJs;VF;RvKE4V)_@GVl1Hh-D2LWQZ zz8WzevM~-vjOmC05X1E~j=A?_ZxyqITBOQ1@uF}e1R|UebW7*6CUUe{7w$#BZjuy_ z0yl|A0Yt_Q(WW5yGf=~8nT0T{Ws|U$SQWRY9P2`lsS#6Y`PWWo)U4>-BF@O(2RVd~ z?-fexs?b6p7ka5)lVZNdjy>4n+&?hCCYPuZyOwrS@Lf~LyJ5pOR^|1W8-~XYH!ph& zIP>x=w3kH54BEQ^J*k}=(xZQ6Wa|uk2I|w;J0j*eF{PJ#;dL%`mhZ<+J7YEweeh_b z|M+#ti@5rFxV7pX9b?j{zYgTxGjn%SI<%`FGQ=5;e7Y4My($imo!UPjI$8h&kUM#~ z+en5df3?b&pI_DeupKl%#Gu(2g9admuVAiev3MU%>J3Hm3Yf*O{Kkk^_W6hvv-oAU z(u>&|0l~6i*rhZiF9`_#ft|q{!i|i`qI!vxvdqYLzqQ%^)|B(81@MbC_AG4z@$oU1 zBsazD<9Kx|PdH-7_=I6N{P2T~8fQ{TWhw9k74FO9-17s>hp`n0Nhl{mJGP^wRAm(7 zmQH5PWN<2irkYI0;A5CcmkQX@WQCGLFRTnmrTpMDD{Ejc>p`aTh_1VlxKWJX^kjS_ z@)Bg#2g)Z-i0hJuiAwheg}`^Va&RW49W4w)8{TQ4i`9*$?3PKV5mG?eG;Q6 zc+f;3LF-{jD*bUZmGK+q=fZ@ZQBsS4mN`aU(n#~=(#TPZuV+JK@=HIFuKF1U-ox?k z7;UnI{VPSE3kO6gs_M?{oWa`aKjQG6DQFI7Ma3ek{MnJs((fF$S$c{e+y#}VW$1N3 z=~%m^ZrCRwihh1Tb0qZRnU3+DQDsqtL~&cB-#g#c7Acl8Zi|Er#1`op&gu*!pq-A% z;EUnVnP}rrBn#K%6xsr@8IlRZsU@)qPQkv>`K{4G{H|ID!8nStX>p*`&lGo}>O9Rs zzmFoUiYkAJ)R^%GTOR$a7?#vz=i|U^)%C(LeT#CAJ>IS}KI`q+jx?4l3^)W8kx5mo zE-o8a*}ZynY5poz+8mVTxlm_C^yXQIosO@R{hn2Zi1k>S)nka*^A_;D0U(q7B}&8i zTmJ-JWJvxx7s(Cmr;ufrS{fzx%R~X2n>;t^8Dr(9b zy3l)Df&PDKtIg!1@&eag-d~h~%vAoNX zm6=keeoDpsS$a4J?L5vjgPT=GgZdpR$w(7a`Q?E^yZ>NodzG?BP5@%KzDfL9=wF0~ zXK;EGx3TF@;$?>V|3>cI<7`W+e7vJN1OLG0L=m>0Ajel+2*+mCBw~q=8Lab z0fO&PYF_uNHj8V+>H)-XuAWK6xP%P;gj0P7>8%O5gY=d}cn2w7Ri-d3TiQ-^;pN*1 zQn`&c^mY!Q%EeQH}@7;ZLRx|#z2VxCLr|AwpS zM-7)!%g9)cJ-t8;+Nc|0Fv*Pv1;piLHa=*;pq(J8aD7d$R;SwNCa5a~TDdvF7owuz zT;|QOv1*Kvhh!wNrKsRCsDAIkceZjbJqlYhm zw)aal?hn&R9#oCnm7bM^k`}t_ZIV`Zy(O`|o*Bd3l~FaO9#VqYvkNH<~jFUP678H?dH2J3=-lrk@BWVE-KVPM-8n4R&gm!b z&Sm)ALFL`Amweq_Bk#@`Ox~S4(7s|`@d-fC*hMb!0}o;(g7oq!!_v+`&@xqifYpoh zcrHE!sS?ys2qXk8&}Jf;&QrkO&PLyetWsX(Ayzw9kb}Mz#h(8N6;YxDFZY4nhnN!}aa4laYdjLsj`< zo+`gdFjw>lDtoyh_-5@PdDnRw?c3F~?>ExEN2Gm7pW^h4K51D??%XNtT`ns@YtnfW zCp5X1Ey{Tf1||8J!UkM{2+X$LKW&hOEV z-C6!mRvs1kpVI~5vCWL|4E3p1hx@Az?@VR6C3#vKuZ3NDpT9@au6l3UI^GbjdH^vz zTJ^v`nAzCNJPB?J^gP)Bo!|v~fo&W`tO~HgVHD+Uhbj6yPRzVzeYVr_MD&OcV3}h( zQ2U-?+n+m_zrdw*9^4x8?R=hbnC$CcLM~5tziTUhS2)xFVz^xSZRYNLdOi!h?P=^9 z9_Nn7U4W*}kMR&fA^K(M$Gxg|nfJ83PzGGoowh)Ir`U2UHtTziX)AIO@n@J6VL%I@ z?cPY~pR>f$F@?DMTNV2~@b!%>5E&t8xFkzSid0Jf7TD5{D09U8X2lL5^-aRk-HpoZ zgSm7UDtUKghlul{S60^vroi}c%bxcPek2^ zs{BIPb6dc14{$u+;P}Z}96!+y$9sPpj_*OU_C>SqL5o(2NZHW@E${6JdlY56;(Sp) zu8KDlXXS2ThMnu+mOpXi;=N3Mv9um{92ZOy46Id$(@0#%Hy(OL7KA0*Z6Y2Ho z`#W7=w3CRH=D13DL7}X36t5KG;dGy*sb+nu`$Jp3Uxn2Jh~dVQwAfEH)@9Y2I(;AN zX?%_Pyg(Vlji`^@RuBG$< zcTzTZNEsiJ;^QY4mXk0Q{Dz}M?9C@aEk8A6@@w(+mts9mbdI^TF@BC&hO#}!%!9Q1 z&$exkqiy?vlK5CET_vF#X~LA7voYnuNarQzq0#>@KOAd@T7-H3oAe1 z#yMgq2w%}J!;WWbyM^1eCv}LHTfACBML3)LwTAvkTw^Sl@x@$_%esW}dL^_^>=-A9 z{W8`d8{toVUUI3uV%e_(roqfp3rY0N3e zbFmWo!9M5t0%%%6*ow>5e+2QMua~2*T~!c(k;p_|>$7=2;{f{jN6^QPIu#s^9_npT z!7=<&*DkDSFXa%spS_Ma>cm2`W;7ZbEo+`dV-^x^{#n!7$%c6T#m=GELWTk$hD)<^ z`PnMy;(_!BH0nOHr>=PK;8oW5mXx`sZi(WvI?xhj2E3+DbYUrH)cEL}3ZcoNq0k&3 zS2)M~Vpv>6JC=!PbgU7HmYL_VYLNZk6B=WZ&$3#%=>B-SF7csWi0n9f-%kX0dm5YW~_WDbWT(oR3x#(Cm;J)~Af|uhBK8`cb;|IgbOYxQ;SBsZyQ!MoO z?}L{&7%#6?v{#{%`J>gFm6B#J=#p?Pdxdo+;aUdcqe6w&rdLF3gQUU93N{84 z+vPK6GzEqpCg?Fks>*B75EUsYUMeq(<_o#;l4r7g&1TEdrK&>^sH-K44R$piI; zLG(XOjgx$Q)YDB!u$}lpiN%<%TsUBoVEZw&-^WaQp=DD4LsfrsHu+XXqjrc}^NP;x z|Jn+#+J4RJp4DynR%rYTkINV1LH0Ii7ktxfd5e{uTDj)j{Tzz-F7SO4@LlCMD#CN= z6cB>9WQ3d?qMXY1n>-$-Dw*P}wHuyWlY21U<9+iM2m9ig;t*Z(Mel4GH zKs@w<@53j2$b7oSZei*#RzifZY1GvU;#Na{0hA#ub8?D-A-fFwZLolQFVGVlBU-7B5rd zp;vw%ynM`f`D-;^uHg1x(GM?IGW^Ox@$$@v|GBLOFINnPmn#Rx%Teyj;WWzos8vu4VYOgW_f1qnvx#>*PP%XJ1HYs~Yy!SFI+XsqRHYVop7JoLKngO@)uUj9~%mo?n}HU02% z9mB616fc`h%l@neFKY(F%XI^-!S-Uxnj0KHPuLqAu@+yic-v3~HvoqLN%fi1Px13J zvq=9OS>GraO~BLjSeJfbBHYY09c#)C;hw@R$bl2^YqygyE7};OycH`N zKn%yt*##BchUM=*E1Z{ZH~bWM!1-cs(p%_!43Dze@v+MzxWe=L!^?-RkX!)=I zp(}jgTY23Fzt24TE6=k;qH3N!!1L*We)H@>hCevyJbQKi8E4hZvj+y7XAcfE&!7|g z2kSN(&=(IWIWq7tJw@4qiSe*9`y22H`5AC@r{PgK>8iu+?i18tccHI;gTDS9`Z{4J z%vj|A2>KczhT|6VLbtLp#v#UU5d$EG<1(&7bPvWOEX&1BUPUptE7c)4tx>spMdT)b zag*1zn8=}ScCDXaA|s;uSd^>|LIBIKamU32r)Ql=w<6v?*O^m2+lGhQ&IXTZZU&AV ztWR*+n0p--QFXh>$z?ZTw$k{80GJ)ot*iWcFe{*VlVaMcyP|1+&`f8|s6lC{ zfZy3$HI2Qr9eZgr80##c&HyqNkTHOI3#d1M1`B8i$FIl!ng7oAv(upx3f90y5L@9V z^75thx^A^mdwq&E@g0+t#7Oa!_xRRMy_w5impuXMnK7S5*nj>9>z|UPHon!98p17(4V-qRQ_ZKB1v{0V`S-Lg&i0ESw?Py=YT0Df`oeXwggasN88{_ogaK6o3_XbSb#=q?FvQ@-AbClqg^b_|8% z&pEhZ)JsbzVViYZ(7acaJ?CGI^TukNH}=E%T)}zc_rQ7VQsRHIp63f*N_Te69t!+Z ze~I<-ZetPhh1jbhGR~{rgSGN;RvUrI+Yaqcb0$h}&#j+?86cpP!1Ow@SFCq1UA(>R z;=Jv?#;WdXv3V+`JS_JL-pS9M8&r% z?1IABNDx<^c2vW}6e;+(1Lolg#rH#Zt5Jg{XTvvpo}J4YJ7`?FxFLe^e#!Vagk7C< zRyq7GB(fP+wsq1knurCEpQ^)5tRuA&;aUB8dQOG{YM7rRi-)w3WxvAecKaX8WFFkmZ}U1ebG3t+ArXAOd9 zfUO$Xvw(HS99UF2bMb=b*uuc=dMI?j;!>GEbj>;-K2QITePF~ckGLq>w5YvZVzVg1 zX0q1uJG{7bXA{l@c&?C>_Vra75Q!r^UL zxyIh61~)A^a^+%YO}BFj$4LFa3$%u7uj#@Ju`t0bWzV_6@5$F}3)|1Zh+-EU_2ST{ zA(f8YchgXJ^)b|vuK&>J^7x{2w=_M$bMt@O>fkIE@jT9dFn`~oI<3GiUFmmt14mr? z7;kWe-Lq3@3B?>3d#d((dYrhsqVSAx>&iBY9&>=fZi!OtmMHXR?5|1d=h@;Ig=7aQ zq_M8&1*gAHB<`-(mGG9{v!L4hQL~pDxcp`>RsrtNI_k?<9WWZeQ|oV+axO`((MqHZMPa8eC%f9RW%k~5uo(r=0gu5>T*dPxkPTvwlgf`vf?DwlTF6FU8iPP8=BL*|B^6K@+9HxZeME)4SGuuj)Fp1rux~)uiiE zdQI}HehZc6;o?@tN}a|f_#|o@%IQ+&adz~ma+`hCZ!12JErI(-fq2#LFt%gEi|y{< zchE_|j&K+Dx!95NgY$qFwUk&*C642}qT>mRztK%wm&(w&>k0U5%uF zAIM)(RZ=h5B1&sMJV|`IM2S!(u>@ZrQ1;lP8!aPMV(B$4k-w%3MV)Z5s1q(R>V)x@ z#T#$>eS!r{Fo3l!fL|b|Z&syCxVxoFmvE_7BU}XDVn3@!z(w4_I4?4zov!o+R?&c? z@Axn`fL&x?4>alIHZbV@a(a0onFLfeeeKk;zBC5Swpsd4>2Boj#L5VDD z=XXk#Q7%vJbnIQftK@jjBpFY9{#A$X))(1Mkn*51tuIf60@NMbquZsP)it1&(< z8AM_r`j4i&r9bmzugXAzN`H~Ht?SWYp?i3eI}5a?+DoLv)%3w=HGME#O>dIkE(mSw z5ZYEWt7%8Hnil)5rXA60S{!^eU98H;JNPS)aEY3i#PC^uAFCOHn_bq#+Rt0e%GSXI zFrop#C39 zZFh-N`3i3jMjWMAna&J+Wdl^Bx z<~8;ORznUmQGAxuB4uPuXFANvh)3a@+s(C!vc>{ABLrDjkJYg427t|$b4oRrK2=?Z zl0P{d8`SLog8T2o&o^i`t&E6J#xqE`W-*L$_|k6hr?5TDB-p>P%Z{2{7bOLr3xR{v zVJ|6@Hu`1wqpxQ?y~@WqM%Txj>8IH1QbXD}aPq71#eSC#RmI`4ibO7#Xt2}p_g!B9 zQ!WqoFdih0GJyIuL)+P4uzEt!M0(xf>*l*Y4+mH#$3rNM$nAS z!aFS&hjF4;9U>q4-$p%(n|!${u0;BP3NhZ}9MHT&EzRSK1kF@H_a+ImHTZ>VJZ`Q4 zh~eyevwKq;CPddTpEwCz4cqD2(FLsy0{fL z$-m8KM9s>^LJ!Lk_fWn=d9IIe`G$gEB!)R6bX|i{JPk=ya6OZ*;5@Ll>zK1wYbo(e z&XIpYktG_JLhD4@3wJ$=%Fp{*f7}7VD3G7gXm6@}rp0W%XU{zX#Be$Hh_*KPT{lwR z+_tn{i;{NTf{MMREFPg(X=Ztv#E{XgeQriAB^hLNahO{AGa6vUdbM=2gcK6FdcWwV zib~Py^Nu}l?edw;7RJLE7Y7z`mGoHj!#L1B6|}jKVAg7Jv00sINVO>Jk7rtVyE+rB zgLfC3)tTb!y-h7{UzQjKWA$v;2zcR{yq(xRhqrR5iDj3Tf0qX80TsMSzrgS6FpQ0- zn2*SEkb;%M(@Eo8PS>$VE>5m99$Vv!gY%Tqj>kJ9@0x>oozlO>c2#r0rK7cHV(5*G zRr@lNhM9A5utDdO%RmV1&4~w0V!P|N{LTmJRqG`%ZM_7>lz-6X>UXI#8|#90*T{o%_H#JZqvrtI!mc}7YtMeh zu8YW>+YotpkFJVv>W#d{az8V_GYD6cFi!R!nkZloR$~yLvt5AP?37P?o80X5Iubbc zW==Wsz1`xBEJXfwarP;js6PATD>?g=RN>htyvo_97tPtHG(jpUWsd&*Ud}$L*g0M# ziJg5SSys;Ra#pl*Dtkz&PMI@Jc&T`b&om(xpJ_7D>#Cy5ch#9Dq^mm9#DM5b6Xz2< z)8wnFGflw3xIWvuO4>H;z0eng;3`*xtI4jMdCt4xnP^`Dc4CBJ zZNzyv@voG3tL}O_g#P1_hr&UG0M3rsb@cE;AYh8i2b}>gOra2b^KDs`sS*{B$~3%> z;8^BfC(cM>v*P1X-i0^!I?Zsa?{zx)9=*w3bvjbp1pQiA2X8a0G5TWU(?(R)_3D4{;y}M zgI}{WN0B`S*1~;t_rJ0$Qd#3W%AAiajF^-$Yf77R9*>w_IxgA7{4vTEGoJenh zyFfpgl}EwNeS=Xwr{K30GoVA-qN@*(U2ud)T$gk0%djG%48{qL&Hulr(`HVkFq zUAORq9hjF6g&)JMjJVT@I&OreYh#SVEg?58okyh=8@xcgoMIcd~JJGWDHf0dtIQr}l37 zhg+-emPh>~`?Dr5R2++{7~>50(v4<58hF-+vrEIR!N82C))Xm8Wowq!@XJ>O6OGVo z!3kzV6;RUx>G!tQn~aV~@C~X{Jjh1S2ytB^5h#+E>YdGIVOhl;#1L*0J~H4_a18jHH;t`9Gp`T03NY2@_kzdS z9E9KlaJ$lJ{&1`4rzLt^TZ%ItwV<>G#aol6jvE$sV|ql_*x}%M!2qvG8^;;gBZb~$ zEc4M}Y`Ag`wxmq<9} zVLy(u<4WU7zzhZkr%iF%l%(|sN-MgiwuIOSfr!NXgKp0=dq}$~Ev5`6HdX+rgZ4B? zRD1Re*9hfIn;|;)g+yh-dl6v)nW)!z}KigPnO4kvy z7j#iMb-DSCb?H@yPyaK`g|TMb_itWY=F~dE4S22z3AxL~w9kpPubArIoF0XG`3$zk zB3^T~OW3xKPHSuC;(i`yZJs;PgfT;$eO>Dh!Akb#OkMpN6-LZ1puuTv14{xK*=75R zbr=_6Ucq?wfQoO$`!S;S#kcMbC%Gx7bPoFzHWcWB1e;y{ILv@EBuE?kL%tY}hntkV z@M=JWCKa5Ir2uq2#lBYacCVp{?QL2;P9#Joz<{Gf^0f$Geph|cIocJoK(RnTlk-~% z2_crfmDd>=_aGw^!*So z!rLN8zJyf&2?Kr>2K)%-a`CG_BH+gVrQ{oKlwhxyfCf7t)=0@9j7AGmWt6}WWC$Q2 z9cfiYZAn_-XV7sv z7^Awjpjed_VdsZgb{;Qo-;&qUMrVWi_<+HwTzKMNzjEAQ9a}D=^XMkxH zehi6!42ys8b+qftN0yf@m~`N)?HZ~DcUL~IioUD&!D|<8(&7mYY!w^2W)TXkIsI}4 zi|I^pxC(Z}vr*||y~x^rfk^Bf1U@bXo^4zw6w}Z&?&~qT#(FNqTo#LIal`Xlr2ipG zpTd(l9*1~TXAgm%7yR4|l(F=|!7n|tic(BE$ z#+K_KA~gn@6pob@e{f?l7aCm&ky9bL(AIG>_>VssUkQkiN>-4-B@X1HDt8wI__*5P z-6yPtGhY9Or8s}TrdrG)n={g|31dG<-8);Y*M4Z^PBbW10K{$fCKs+38UmhOAKH@>kZ&& zq-~4qwd#2TR6fRs(0ax7U+9WftVn}MUl#35pk3hI`2MS^tFPd%V0YHcCG~vIF+SzS zgnh`%IPcIGoAfz6QN3{5+q(kH8Nw`=13gwJ&)rQ__dGj%7JBv!9Y73^8~t_+@%8zP zqHt!T9=VVgV7+XUzMzU!uuKd4Mz(2o`6^RlS(ps%;Te8nj8k)OX|WFBdmTCv!~p{z0+Jv+*2FI@`Z7fZ0G0pZ`+lO@1)y*H=dd9|H(eMguT7Tm*P5K z!SE(3du(O&VEA2Fwf%N4l;LXpL1gx;RqEiH(tB3=UK-T6i2Vj3{*GeF$f)0-5`HWB zd?_xW-w;H;{pvbREGCA4 zP4wDvn7ELCU!R{!<^Q|+`Sf4fU-A1d=fC2Ax1JmL|8MKrHQ;}1H>L7_Zs(f0wkp|q z8fI<{L>WTncSOQxdS4iC-=P04Kfi|jC;J8^?DMOCY41AU*m!)5WP$6?H~g%ogwHx9 ze6Fae@hPfnn_W7aWWFZqN^+)U7|PHbJpV9p%1pTcV#HQJOvK zKlWq!<*kq9FRX;$oprQ%FX2~UkD0Yq;3gGXwy29T;FT7rR=-zQX3q?R=yl}CM8ieU zV&f;rw2IZUPmcMP_Nks`OA`&dqlq(L3MP65zFODB<$V2;gEP_Wza`Jv-!=H+Iop`7 ze>%ns8h&v-ezuTHADdO1eD&CL&74D&{-yiUHT}1Jm2Br7|L@vK?D-G zyu|#GGZd=E=C8S7{+7`BYew&ZXcepXdq(F^gl|k8nPjkBYMg0W#p>Bi^M|$3iJFJC zJZhb@2~4j}UH>KX8q@s0J0~P3X>z0PPyaEem6EkN<>%ke(74|kK`|| zIm7GiQpo^HzayWSqHWI)UuXXMjNwo1zi{;du~aSLt3~S)$F|0Wvrzh)s9}k=uUePb zZ@$!4U!vNj{4ZDG1LPFcI z2`Rm93fuj6>&B$h|8`B#z4QOpZbFwYw`*5wow}D?-(9ui(w;X;j{ip2|8D$qyZvv+ zjccE1_#lL10~Mg0XBT}>l(Es~JCBp~`I#=B9A7#e>7;fX1P>!$bX3?a~0HEddy+i7k} zU)25R8%)1Af%Z;+oa!K=?@l1}SVpM1g4p#583Oxmg<&Gg2eYNGe9+%!y+{7lAr}vMr{6Kf{%)CMgpW``PUhC;3i2S*3^g^cPRbovO)nG`hcl1}#<*Ky2uR4`WYtlHst4S^Q zhS8c%wP_5m!fCx}1huaaLnC|}L$yLIm4(e{jbj2WS735ucPeZ4rgB{G?!6V{JHUJZ z>30CNY{6tEle3sy&*Tv%Z!-CTNxLlCwmg#|S+u4plWAGh^Q^4VS)^4~5s{CxXjbKc zR9ki+Ek_b*hT5`nzkw_gCg(Am+Jk6)uR$#bDJYl8Z zGFU-FhS0VnhtO>A96~dEa|pHnoz;5}r9OKPrR51jGlwc@Eh`@wN+Z8Sq#4o=t8Q+E zhG%!nwnF(tDrj9c&28Wa>dki~_1tqLo!?r zW->W+6!kNj$%#zPWO6=}1x&7GvXIH$tkuC$G#kZCK4)@DE?qhEa_P9Xvho2|HW^2= zy>nd4L1xHgJk3nl1e%BB3Di%<1Zp#40=1t;H*TWt*s0<1s`y8b)*ak(DoyC-tW%gLPHzx~5qX}6e z9ow>O&=N*w$OSD!^tbBij$}^H%|v&BwKFHasqP)qSz=TWV*v#SBdFva9se2)du~=sR}YBItL*M*&-|YHVvVw0*%@Rg)?14 zAwjT3cBnC<{)`;S{icr4WY*4^{>32eU7$YQ==Yxz+R4ZVb%xP0pT6{6Z9_z%JM&9(>-K9(@`Tv^p!nR)E70u)Mr_V z`piJ_m}QC4P}CjMF~l$$j(V{ZWglsrM5#9^+n@qQqfjPmx08?^%0a`J&kLkoWi%Fz zX7rrVL^Oq2n#j(wDVmPvV@xQB(QLE|(=}L^Q6AdBbS*h;$D@gt40#5j`RE|?vYpTw zlA~L=fQ<8jOxMH;^qNH`D|8-Kpm)sDSE23JA}4{4s4=6>$VV7MEL$sdeA`e>f##*V zLeH#+P`W_d&19BGP$oTbqa}=vp}|a7q|n|^pd3cmnC>iDH_fg}wzB~%B!L^m1rAmmHv7lCGJIJ101h-PUy zBN2OuRJWgzg8f9=!)?}s39iP79KeJuaXpbn=B=Zab~sU_nW(L!nXt!gnXZAZg)R`g z;4D!jx_&yE7gs!tdC4VI9=YL>%yI#-yocOz4x>WWt}LD?(#Q_#=sbAhnIav-1=2$u z2%p;JeH+ zj8RSefLW$8%bNHxquypTXEpI}BAvf%MiKZu8+$IJC~PUwd7ooOGv5q{NYru*)5YW3 zjCM0h#2qAhteh~T$4U#lOd3aYzp!>Gc$37kI}m8IMB{8Wginr8amcvurwo zQb)X>>Gm<|jE^!Rn>nE__&Bqy!>B7h!RQ{N?)WUD!(%A*#1~n+;2cV6xR_DoI7+?o z4MrcwQ|g0nX?p03B%NhYT+P$=Zy>k@4HDelW%1y;xLa`d#XYz?1Xx@a_l4jDcXx;2 z8a(*R|9L;0-<;__AEs*ROm$WFTz$#Tm?c|I)>U~mOD6iA+ZMY-@g;JGLK^N0NBUa| z1A6ZifszULCs8Y0!LV8Ommf)68uBau@QV6vQl+=~VjD`;iNdyQIFn+w8n4bR+Fbro z&AI1&vw;P`aOQC_DD}b?)x^@8$!QhkM&n6SS*d2lyT_(;WJM_vx=$5x6K9W|#7^{i z#GdS{XC;sjSa9e?<`A5JzeQghJ0ZX~)6SGOw8SW(SvJ%vV(l@?D$6h-lWsgv(~BQ# z^k5^X?#Cm%%aXC-sTnO>gO#^)abLVx6qi4BagaXPQdy0pB4}kUZ9rpBlfD9(z)oe=7_$!G$Kz%7I6%|1!!$oCO!R zS{G6$|2W1DRuzC?9u{L?DKDmm%}7cVJ~UcBU|;j($R436b{BzJBQ4Ols4ix+Uzn@38f0FYL21r zt=2~ETT()FE~uAu0?}+Q9AmODE|m9{e{)4O5pmYU(zV%n=Pdu!-=N|gh)&PY0VJgi zBb`P`PB!L-3(x4D?n@dqZ;G)hi94{SJV{IX6n@wDgegMOSEe*`c!gJX=bk!rQ{_R_@A^pAtS!`?8aM)>TD6Q&E}&PFf1k9&;@P7`*MtAF3GcCQgf?^NHaZPX=n(i(+z{p3Z5v6rH$vp z!dqX%qC*N^f8N^3 zBXk;tPvx7Tx#we_JLWiouk`mHJ;8xR_|R4~9pmkErdMH3)mvQz4TJHmGw1IkHd+>; z&dA&A;+2|VbM}-tp~}Q3j9i|m@!KkeJ*rx9%K8Tk%Gb_Uc!4Efrdi$6>x3i?$4T8i z(&B<1PnwVkYz-Xn`-JiW2x-r03~q=D|6Af;!jsMwxU0H^~56kcJQPJDS@%U&%6 z7N12uJ+QkB2?_ zW%WT+0Q&m(@R{Q8wsOxULmQ3T&;~PSlNuLrJCSd3pJZG58Hps(7Pqb zRFA1Cq*T_Q_upwrRP&w# ze@J=kBFr8=Xist+HMsF@S?w?Vu zk1CxHw4`cNpRktntSFQQLE4rhFGS~+OIS28R@FGdExXLnCSIZm1fmfoJy@zp?P8j7 zbIDx?7j2cITB@Uz6l#=lWrprJ1*hxx-j0`2<#iO;FE^p0EvgSXArt48)n6sB;*A}M zqQ|4qq~otZooP`{PK2S@QMZzPyEsb1Gozt;K!S56YstNcPeAjuQL!Z0IN+S%4prqPtO3>)BiXV#pXI(v%l1nS6J<_0)74Q zM@Tb1tueW5znQx2zUL;XSa>p*p7{~Xwe01Jd{}BSA|NcimU67>?fUE)1#<*7kinG09VM(#Tn5z3Z@H>9e@1)1j~jYdNlov)QxG&b{*7mA2Som<5^PZGhAL*L-T zZEj)mOP@g_s$N1PVp$fHQBe?(X`&VES5dcFoc$~@ai$BxRoUb?WlkEhn)xb1hTq2} z2Q`$yYhtR!Od7gDh#+c!xdUwwnQs=OTcWJ4)2+{b)(in~F!K^=ZUO$-5e&B5UU;@m zQRd0G1$-xE$sUL7cff~p-U*=-`?T)+(t@RzN9*?t4wX(w%k$}8^#F{+Amp^#r}GA_ z#5runS6wBf6c+^_oG~p0>qh>q4yI z;;J7};oXUYVMJBmg2rl9X=i&?L1&Au#85zZ+WF$FtWU}Bk7Lsz#ie?TqlV@uNn)M2 zk$IKjI8bG#;t@Z;%_KnA9Bdf0~aghyQkgX!TClLzApWetF5uB{QDdid~=@F2+)ZM`-p zmH6(1jM9FhrP6+$TdYZx;+;~H_@uK&pk~w_azXtLⅆ$ud(8Jza5sUEN5;{@u~df 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

IJ(Vk``KAxlHpVQ=C(Dl&tEQKWx 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

  • hjL|w5HHVIDLUt!l1pGcKUn?sQj?6 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%0Dfu$U}Ku2zN^TUD&|gj%4f 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

    m-L_1zxUsXShX790QqO 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

    W&=wWE>!~MupYFQtn6|(ww$1mb*jwSRQ8+ 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

    |n#EC3`t{39gUFP@S};~x&h&$$Sc(YMb9qqw zbJ17*^b!=OS~%{DeV)<`Hbi{SwUOGU&g1TR^KNsM3b;d2w<4Mu1h$43NRYM;)Dr?( zEM9XO@4~3{)L{G5&I3zWvxQ*5iRi@DA_U`ml8Ha62w{U^*a(?0$u~w8Alm3p!z)U& z9w1@e_RG~jtjc zsoR84M?(^^F&!nbcWb2%QP{>b>93wPg<{%GEGvv@>9l3j-O})~z~^|xEu`2Yf!+t_ zB{%D(yv|LqH3Y*n$Q!ulcXPE*U)*0TbZ723D|74b1uekC7&{G5KW}`3^QUs@!~@Er zxDH8yR!lkRP6ErhTdyk>4IVWf88hdEuoc`-d0gsK-T$J$nuHSO5N>2Xm&6MSb*|!a zaQ{j)@Fl#9KqYpAt2{ceF>60WC!g#GLAULs%46)W(leM2Cq4ue*SnIBA+kmCOcg5h zYTwC^)F4pnSYXW=m9GXBm(<2a)v|4m-DX9a(9s=#Xv8aVA(o=d*}5$r!Llr`%V!Bze*lB|*HvybcM2KpuER zmXxU0WTM`dvqH7}gwkO7>vG0f(r~OaIEdV{YJac6`JMq#_YKpabewy8PBLgLz0Mzr zEBYfZTySf0(zU$H{^-M^m3+kxd>8IqtSK)oU#WQ2FEy9zlH)^9_r7L-{7+w{R->y# z{7c|ly|(YPen~XATjndHVodTB>G&O+l1sEIj!}2jb2QR50)Mr@&G%+mUsJd4@}}r;V5%t zx7`SkNz2!f@f$^@G*{Z09sa^m^%Z7^Xz|Z)ES@(7V%;~yyCJF>eGY&!1WCqYifE($ z4SJk(-N3$c$uXYfskjP{{o>wiU`f?}G(i!sV(qRj6a?*KN5;t!|{4;pe^yEax_b^@|21|yo;Q9iZeOn3q zXqt~-_>ezOnVf}`1FpWg^SVL`0M%2;H)QFsyGn-Knbsab&F z1Pn1dwV!)S8Cn0;_?NZZU&Xu5KR%8&Sl7`}5NosvR}dR>RXjU#b4B!qHQPn^hPCRW z`oLV#f$S4ibIvf_&9XURV(_?0Yixk9DKXNG(-9l)!|qCm`;N2VqkCcP@O)cedvvAz zp!R`_4BvV9ql3`5Z;*ao3M=`%W1@VkHs~`IJ~lVl`Nc44jh~L&l#c%>Xbg~eu0_b% z`=zksAqE@dTsqwrfboR#W<(Og}e5`dV}Aa+UR>^Lnu?EyE6`@0mKl^KhP-c%>nY#MQ>UL?_O|shtY{ysa8j*bT3f?W76SxLk@Y9+ z1ckLX6cfolshMk2lxUfyD6sh5VOhp|4g!?UoxTHrtNCL9?#fvs{sD(Lng5YqTk@CU z8TZDRcPk9WoyfM$7#usZ?YDdWYQ%!9A3(w|!YAFAsHJZQON!?9DM

     + Entry point for doing diagnostic analysis on instances. + + + The following example shows the usage of the Analyzer class: + + + + + + Analyzes the supplied instance. + + The container instance to analyze. + A collection of sub types that describe the diagnostic + warnings and messages. + + + + Diagnostic result for a warning about a concrete type that was not registered explicitly and was not + resolved using unregistered type resolution, but was created by the container using the transient + lifestyle. + For more information, see: https://simpleinjector.org/diaut. + + + + + Base class for types that hold information about a single diagnostic message or warning for a + particular type or part of the configuration. + + + + Gets the diagnostic type of this result. + The . + + + Gets the service type to which this warning is related. + A . + + + Gets the description of the diagnostic result. + A with the description. + + + Gets the hierarchical group to which this diagnostic result belongs. + The . + + + Gets a collection of instances that describe all + container-registered dependencies for the given component. + List of objects. + + + + A hierarchical group of . + + + + + Gets the base that describes the service types of its + . The value often be either (in case this is a + root group) or a partial generic type to allow hierarchical grouping of a large number of related + generic types. + + The . + + + Gets the friendly name of the group. + The name. + + + Gets the description of the group. + The description. + + + Gets the diagnostic type of all grouped instances. + The . + + + Gets the parent or null (Nothing in VB) when this is the + root group. + The . + + + Gets the collection of child s. + A collection of elements. + + + Gets the collection of instances. + /// A collection of elements. + + + + Specifies the list of diagnostic types that are currently supported by the diagnostic + . Note that new diagnostic types might be added in future versions. + For more information, please read the + Diagnosing your configuration using the Diagnostic + Services wiki documentation. + + + + + Diagnostic type that warns about + a concrete type that was not registered explicitly and was not resolved using unregistered type + resolution, but was created by the container using the transient lifestyle. + For more information, see: https://simpleinjector.org/diaut. + + + + + Diagnostic type that warns when a + component depends on a service with a lifestyle that is shorter than that of the component. + For more information, see: https://simpleinjector.org/dialm. + + + + + Diagnostic type that warns when a + component depends on an unregistered concrete type and this concrete type has a lifestyle that is + different than the lifestyle of an explicitly registered type that uses this concrete type as its + implementation. + For more information, see: https://simpleinjector.org/diasc. + + + + + Diagnostic type that warns when a + component depends on (too) many services. + For more information, see: https://simpleinjector.org/diasr. + + + + + Diagnostic result for a warning about a + component that depends on a service with a lifestyle that is shorter than that of the component. + For more information, see: https://simpleinjector.codeplex.com/wikipage?title=PotentialLifestyleMismatches. + + + + Gets the object that describes the relationship between the component and its dependency. + A instance. + + + + Diagnostic result that warns about a + component that depends on an unregistered concrete type and this concrete type has a lifestyle that is + different than the lifestyle of an explicitly registered type that uses this concrete type as its + implementation. + For more information, see: https://simpleinjector.codeplex.com/wikipage?title=ShortCircuitedDependencies. + + + + Gets the instance that describes the current relationship between the checked component + and the short-circuited dependency. + The . + + + + Gets the collection of registrations that have the component's current dependency as + implementation type, but have a lifestyle that is different than the current dependency. + + A collection of instances. + + + + Diagnostic result that warns about a component that depends on (too) many services. + For more information, see: https://simpleinjector.codeplex.com/wikipage?title=PotentialSingleResponsibilityViolations. + + + + Gets the created type. + A . + + + Gets the list of registrations that are dependencies of the . + A collection of instances. + + + diff --git a/packages/SimpleInjector.2.6.1/lib/net40-client/SimpleInjector.xml b/packages/SimpleInjector.2.6.1/lib/net40-client/SimpleInjector.xml new file mode 100644 index 0000000..18de2a3 --- /dev/null +++ b/packages/SimpleInjector.2.6.1/lib/net40-client/SimpleInjector.xml @@ -0,0 +1,4583 @@ + + + + SimpleInjector + + + + + The standard exception thrown when a container has an error in resolving an object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error + message. + + The message that describes the error. + + + + Initializes a new instance of the class with a specified error + message and a reference to the inner exception that is the cause of this exception. + + + The error message that explains the reason for the exception. + + + The exception that is the cause of the current exception, or a null reference (Nothing in Visual + Basic) if no inner exception is specified. + + + + + Initializes a new instance of the class with serialized data. + + + The that holds the serialized object data about the exception + being thrown. + + + The that contains contextual information about the source or + destination. + + + The parameter is null. + + + The class name is null or hresult is zero (0). + + + + + Extension methods for enable advanced scenarios. + + + + + Determines whether the specified container is locked making any new registrations. The container + is automatically locked when GetInstance is called for the + first time. + + The container. + + true if the specified container is locked; otherwise, false. + + Thrown when is null. + + + Determines whether the specified container is currently verifying its configuration. + The container. + true if the specified container is verifying; otherwise, false. + Thrown when is null. + + + + Builds up an delegate wrapping all delegates that + are registered using RegisterInitializer and + that apply to the given (including delegates that are registered + for interfaces implements and base types that + inherits from). Null will be returned when no delegates are + registered that apply to this type. + + The container. + + This method has a performance caracteristic of O(n). Prevent from calling this in a performance + critical path of the application. + + The type for with an initializer must be built. + An delegate or null. + + + + Retrieves an item from the container stored by the given or null when no + item is stored by that key. + + + Thread-safety: Calls to this method are thread-safe, but users should take proper + percausions when they call both GetItem and . + + The container. + The key of the item to retrieve. + The stored item or null (Nothing in VB). + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + + Stores an item by the given in the container. + + + Thread-safety: Calls to this method are thread-safe, but users should take proper + percausions when they call both and SetItem. + + The container. + The key of the item to insert or override. + The actual item. May be null. + Thrown when either or + is a null reference (Nothing in VB). + + + + Allows appending new registrations to existing registrations made using one of the + RegisterAll overloads. + + The container. + The service type of the collection. + The registration to append. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + Thrown when the is not a + reference type, is open generic, or ambiguous. + Thrown when the container is locked. + Thrown when the method is called for a registration + that is made with one of the RegisterAll overloads that accepts a dynamic collection + (an IEnumerable or IEnumerable<TService>). + + + + Defines the container's behavior for building an expression tree based on the supplied constructor of + a given type. + Set the ConstructorInjectionBehavior + property of the container's property to change the default behavior + of the container. + + + + + Builds an for the supplied , based on the + container's configuration. + + The parameter. + An that describes the intend of creating that + . This method never returns null. + + + + Defines the container's behavior for finding a suitable constructor for the creation of a type. + Set the ConstructorResolutionBehavior + property of the container's property to change the default behavior + of the container. + + + + + Gets the given 's constructor that can be used by the + container to create that instance. + + Type of the abstraction that is requested. + Type of the implementation to find a suitable constructor for. + + The . This method never returns null. + + Thrown when no suitable constructor could be found. + + + + Defines the container's behavior for verifying the constructor that will be picked by the + . + Set the ConstructorVerificationBehavior + property of the container's property to change the default behavior + of the container. + + + + Verifies the specified . + The parameter. + Thrown when the cannot be + used for auto wiring. + + Thrown when the is a + null reference. + + + + Defines the container's behavior for selecting the lifestyle for a registration in case no lifestyle + is explicitly supplied. + Set the LifestyleSelectionBehavior + property of the container's property to change the default behavior + of the container. By default, when no lifestyle is explicitly supplied, the + Transient lifestyle is used. + + + + Selects the lifestyle based on the supplied type information. + Type of the abstraction that is registered. + Type of the implementation to that is registered. + The suited for the given type. + Thrown when either one of the arguments is a null reference. + + + + Defines the container's behavior for selecting properties to inject during the creation of a type. + Set the PropertySelectionBehavior + property of the container's property to change the default behavior + of the container. By default, no properties will be injected by the container. + + + + + Determines whether a property should be injected by the container upon creation of its type. + + Type of the abstraction that is requested. + The property to check. + True when the property should be injected. + + + + An instance of this type will be supplied to the + delegate that is that is supplied to the + RegisterInitializer + overload that takes this delegate. This type contains contextual information about the creation and it + allows the user to examine the given instance to decide whether the instance should be initialized or + not. + + + + + Gets the that is responsible for the initialization of the created + instance. + + The or null (Nothing in VB) when the instance producer is + unknown. + + + + Gets the that is responsible for the initialization of the created + instance. + + /// The . + + + + Contains data that can be used to initialize a created instance. This data includes the actual + created and the information about the created instance. + + + + Returns the hash code for this instance. + A 32-bit signed integer that is the hash code for this instance. + + + Indicates whether this instance and a specified object are equal. + Another object to compare to. + True if the current object is equal to the other parameter; otherwise, false. + + + + Indicates whether the current object is equal to another object of the same type. + + An object to compare with this object. + True if the current object is equal to the other parameter; otherwise, false. + + + + Indicates whether the values of two specified objects are equal. + + The first object to compare. + The second object to compare. + True if a and b are equal; otherwise, false. + + + + Indicates whether the values of two specified objects are + not equal. + + The first object to compare. + The second object to compare. + True if a and b are not equal; otherwise, false. + + + Gets the with contextual information about the + created instance. + The . + + + Gets the created instance. + The created instance. + + + + This is an internal type. Only depend on this type when you want to be absolutely sure a future + version of the framework will break your code. + + + + Initializes a new instance of the struct. + The scope factory. + The container. + + + Gets the lazily initialized Scope of the current LazyScope instance. + The current Scope or null. + + + + This is an internal type. Only depend on this type when you want to be absolutely sure a future + version of the framework will break your code. + + Service type. + Implementation type. + + + + Initializes a new instance of the + struct. + The registration. + + + Gets the lazily initialized instance for the of the current LazyScopedRegistration. + The scope that is used to retrieve the instance. + The cached instance. + + + + The container. Create an instance of this type for registration of dependencies. + + + + Thread-safety: + Resolving instances can be done safely from multiple threads concurrently, but registration needs to + be done from one single thread. + + + It is therefore safe to call , , + GetService, and + and anything related to resolving instances from multiple thread + concurrently. It is however unsafe to call + RegisterXXX, + , , , + or anything related to registering from multiple threads concurrently. + + + + + + Registers that a new instance of will be returned every time it + is requested (transient). + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The concrete type that will be registered. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + Thrown when the is a type + that can not be created by the container. + + + + Registers that an instance of will be returned when it + is requested. The instance is cached according to the supplied . + + The concrete type that will be registered. + The lifestyle that specifies how the returned instance will be cached. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + Thrown when the is a type + that can not be created by the container. + + + + Registers that a new instance of will be returned every time a + is requested (transient). + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + Thrown when the given + type is not a type that can be created by the container. + + + + + Registers the specified delegate that allows returning transient instances of + . The delegate is expected to always return a new instance on + each call. + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The interface or base type that can be used to retrieve instances. + The delegate that allows building or creating new instances. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + + Thrown when is a null reference. + + + + Registers that a new instance of will be returned every time it + is requested (transient). + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The concrete type that will be registered. + Thrown when is a null + references (Nothing in VB). + Thrown when represents an + open generic type or is a type that can not be created by the container. + + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers that a new instance of will be returned every time a + is requested. If and + represent the same type, the type is registered by itself. + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The base type or interface to register. + The actual type that will be returned when requested. + Thrown when or + are null references (Nothing in VB). + Thrown when is + no sub type from (or the same type), or one of them represents an + open generic type. + + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers the specified delegate that allows returning instances of . + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The base type or interface to register. + The delegate that will be used for creating new instances. + Thrown when either or + are null references (Nothing in VB). + Thrown when represents an + open generic type. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers a single concrete instance that will be constructed using constructor injection and will + be returned when this instance is requested by type . + This must be thread-safe when working in a multi-threaded + environment. + + The concrete type that will be registered. + + Thrown when this container instance is locked and can not be altered, or when + has already been registered. + + Thrown when the is a type + that can not be created by the container. + + + + Registers that the same a single instance of type will be + returned every time an type is requested. If + and represent the same + type, the type is registered by itself. must be thread-safe + when working in a multi-threaded environment. + + + The interface or base type that can be used to retrieve the instances. + + The concrete type that will be registered. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + Thrown when the given + type is not a type that can be created by the container. + + + + + Registers a single instance that will be returned when an instance of type + is requested. This must be thread-safe + when working in a multi-threaded environment. + + The interface or base type that can be used to retrieve the instance. + The instance to register. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + + Thrown when is a null reference. + + + + + Registers the specified delegate that allows constructing a single instance of + . This delegate will be called at most once during the lifetime of + the application. The returned instance must be thread-safe when working in a multi-threaded + environment. + + The interface or base type that can be used to retrieve instances. + The delegate that allows building or creating this single + instance. + + Thrown when this container instance is locked and can not be altered, or when a + for has already been registered. + + Thrown when is a + null reference. + + + + Registers that the same instance of type will be returned every + time an instance of type type is requested. If + and represent the same type, the + type is registered by itself. must be thread-safe when working + in a multi-threaded environment. + + The base type or interface to register. + The actual type that will be returned when requested. + Thrown when either or + are null references (Nothing in VB). + Thrown when is + no sub type from , or when one of them represents an open generic + type. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers the specified delegate that allows constructing a single + instance. The container will call this delegate at most once during the lifetime of the application. + + The base type or interface to register. + The delegate that will be used for creating that single instance. + Thrown when represents an open + generic type. + Thrown when either or + are null references (Nothing in + VB). + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers a single instance that will be returned when an instance of type + is requested. This must be thread-safe + when working in a multi-threaded environment. + + The base type or interface to register. + The instance to register. + Thrown when either or + are null references (Nothing in VB). + Thrown when is + no sub type from . + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers that an instance of will be returned when an + instance of type is requested. The instance is cached according to + the supplied . + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The lifestyle that specifies how the returned instance will be cached. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + Thrown when the given + type is not a type that can be created by the container. + + + + + Registers the specified delegate that will produce instances of + type and will be returned when an instance of type + is requested. The delegate is expected to produce new instances on + each call. The instances are cached according to the supplied . + + The interface or base type that can be used to retrieve instances. + The delegate that allows building or creating new instances. + The lifestyle that specifies how the returned instance will be cached. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + + Thrown when one of the supplied arguments is a null reference (Nothing in VB). + + + + Registers that an instance of type will be returned when an + instance of type is requested. The instance is cached according to + the supplied . + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The lifestyle that specifies how the returned instance will be cached. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + Thrown when the given + type is not a type that can be created by the container, when either + or are open generic types, or when + is not assignable from the . + + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + + Registers the specified delegate that will produce instances of + type and will be returned when an instance of type + is requested. The delegate is expected to produce new instances on + each call. The instances are cached according to the supplied . + + The interface or base type that can be used to retrieve instances. + The delegate that allows building or creating new instances. + The lifestyle that specifies how the returned instance will be cached. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + + Thrown when one of the supplied arguments is a null reference (Nothing in VB). + + + + Registers an delegate that runs after the creation of instances that + implement or derive from the given . Please note that only instances + that are created by the container (using constructor injection) can be initialized this way. + + The type for which the initializer will be registered. + The delegate that will be called after the instance has been + constructed and before it is returned. + + Thrown when the is a null reference. + + + Thrown when this container instance is locked and can not be altered. + + + Multiple delegates can be registered per + and multiple initializers can be applied on a created instance, + before it is returned. For instance, when registering a + for type , the delegate will be called for every instance created by + the container, which can be nice for debugging purposes. + + + Note: Initializers are guaranteed to be executed in the order they are registered. + + + The following example shows the usage of the + RegisterInitializer method: + + (); + + // Configuring property injection for types that implement ICommand: + container.RegisterInitializer(command => + { + command.SendAsync = true; + }); + + // Configuring property injection for types that implement CommandBase: + container.RegisterInitializer(command => + { + command.Clock = container.GetInstance(); + }); + + // Act + var command = (ConcreteCommand)container.GetInstance(); + + // Assert + // Because ConcreteCommand implements both ICommand and CommandBase, + // both the initializers will have been executed. + Assert.IsTrue(command.SendAsync); + Assert.IsNotNull(command.Clock); + } + ]]> + + The container does not use the type information of the requested service type, but it uses the + type information of the actual implementation to find all initialized that apply for that + type. This makes it possible to have multiple initializers to be applied on a single returned + instance while keeping performance high. + + + Registered initializers will only be applied to instances that are created by the container self + (using constructor injection). Types that are newed up manually by supplying a + delegate to the container (using the + and + methods) or registered as single instance + (using ) will not trigger initialization. + When initialization of these instances is needed, this must be done manually, as can be seen in + the following example: + commandInitializer = command => + { + initializerCallCount++; + }); + + // Configuring that initializer. + container.RegisterInitializer(commandInitializer); + + container.Register(() => + { + // Create a ConcreteCommand manually: will not be initialized. + var command = new ConcreteCommand("Data Source=.;Initial Catalog=db;"); + + // Run the initializer manually. + commandInitializer(command); + + return command; + }); + + // Act + var command = container.GetInstance(); + + // Assert + // The initializer will only be called once. + Assert.AreEqual(1, initializerCallCount); + } + ]]> + The previous example shows how a manually created instance can still be initialized. Try to + prevent creating types manually, by changing the design of those classes. If possible, create a + single public constructor that only contains dependencies that can be resolved. + + + + + + Registers an delegate that runs after the + creation of instances for which the supplied returns true. Please + note that only instances that are created by the container can be initialized this way. + + The delegate that will be called after the instance has been + constructed and before it is returned. + The predicate that will be used to check whether the given delegate must + be applied to a registration or not. The given predicate will be called once for each registration + in the container. + + Thrown when either the or are + null references. + + + Thrown when this container instance is locked and can not be altered. + + + Note: Initializers are guaranteed to be executed in the order they are registered. + + + Note: The is not guaranteed to be called once per registration; + when a registration's instance is requested for the first time simultaneously over multiple thread, + the predicate might be called multiple times. The caller of this method is responsible of supplying + a predicate that is thread-safe. + + + + + + Registers a dynamic (container uncontrolled) collection of elements of type + . A call to will return the + itself, and updates to the collection will be reflected in the + result. If updates are allowed, make sure the collection can be iterated safely if you're running + a multi-threaded application. + + The interface or base type that can be used to retrieve instances. + The collection to register. + + Thrown when this container instance is locked and can not be altered, or when a + for has already been registered. + + Thrown when is a null + reference. + + + + Registers a collection of singleton elements of type . + + The interface or base type that can be used to retrieve instances. + The collection to register. + + Thrown when this container instance is locked and can not be altered, or when a + for has already been registered. + + Thrown when is a null + reference. + Thrown when one of the elements of + is a null reference. + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, a generic type definition, or the is + not assignable from one of the given elements. + + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, a generic type definition, or the is + not assignable from one of the given elements. + + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, a generic type definition, or the is + not assignable from one of the given elements. + + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, the is a generic type definition, or when + is + not assignable from one of the given elements. + + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, the is a generic type definition, or when + is + not assignable from one of the given elements. + + + + + Registers a dynamic (container uncontrolled) collection of elements of type + . A call to will return the + itself, and updates to the collection will be reflected in the + result. If updates are allowed, make sure the collection can be iterated safely if you're running + a multi-threaded application. + + The base type or interface for elements in the collection. + The collection of items to register. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + Thrown when represents an + open generic type. + + + + Verifies the Container. This method will call all registered delegates, + iterate registered collections and throws an exception if there was an error. + + Thrown when the registration of instances was + invalid. + + + + Adds the for the supplied . This + method can be used to apply the same to multiple different service + types. + + The base type or interface to register. + The registration that should be stored for the given + . + + (container); + + container.AddRegistration(typeof(IFoo), registration); + container.AddRegistration(typeof(IBar), registration); + + // Act + IFoo foo = container.GetInstance(); + IBar bar = container.GetInstance(); + + // Assert + bool fooAndBareAreTheSameInstance = object.ReferenceEquals(foo, bar); + Assert.IsTrue(fooAndBareAreTheSameInstance); + } + ]]> + + In the example above a singleton registration is created for type FooBar and this + registration is added to the container for each interface (IFoo and IBar) that it + implements. Since both services use the same singleton registration, requesting those services + will result in the return of the same (singleton) instance. + + + events are applied to the of the + instance and are therefore applied once. + events on the other hand get applied to the Expression of the . + Since each AddRegistration gets its own instance producer (that wraps the + Registration instance), this means that the ExpressionBuilt events will be + applied for each registered service type. + + + The most practical example of this is the use of decorators using one of the + RegisterDecorator overloads + (decorator registration use the + ExpressionBuilt event under the covers). Take a look at the following example: + + (container); + + container.AddRegistration(typeof(IFoo), registration); + container.AddRegistration(typeof(IBar), registration); + + // Registere a decorator for IBar, but not for IFoo + container.RegisterDecorator(typeof(IBar), typeof(BarDecorator)); + + // Act + var foo = container.GetInstance(); + var decorator = container.GetInstance() as BarDecorator; + var bar = decorator.DecoratedBar; + + // Assert + bool fooAndBareAreTheSameInstance = object.ReferenceEquals(foo, bar); + Assert.IsTrue(fooAndBareAreTheSameInstance); + } + ]]> + The example shows that the decorator gets applied to IBar but not to IFoo, but that + the decorated IBar is still the same instance as the resolved IFoo instance. + + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + Thrown when is not a reference + type, is open generic, is ambiguous, when it is not assignable from the + 's ImplementationType + or when the supplied is created for a different + instance. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + Gets an instance of the given . + Type of object requested. + The requested service instance. + Thrown when there are errors resolving the service instance. + + + Gets an instance of the given . + Type of object requested. + The requested service instance. + Thrown when there are errors resolving the service instance. + + + + Gets all instances of the given currently registered in the container. + + Type of object requested. + A sequence of instances of the requested TService. + Thrown when there are errors resolving the service instance. + + + + Gets all instances of the given currently registered in the container. + + Type of object requested. + A sequence of instances of the requested serviceType. + Thrown when there are errors resolving the service instance. + + + Gets the service object of the specified type. + An object that specifies the type of service object to get. + A service object of type serviceType. -or- null if there is no service object of type + . + + + + Gets the for the given . When no + registration exists, the container will try creating a new producer. A producer can be created + when the type is a concrete reference type, there is an + event registered that acts on that type, or when the service type is an . + Otherwise null (Nothing in VB) is returned. + + + + A call to this method locks the container. No new registrations can't be made after a call to this + method. + + + Note: This method is not guaranteed to always return the same + instance for a given . It will however either + always return null or always return a producer that is able to return the expected instance. + + + The that the returned instance producer should produce. + An or null (Nothing in VB). + + + + Gets the for the given . When no + registration exists, the container will try creating a new producer. A producer can be created + when the type is a concrete reference type, there is an + event registered that acts on that type, or when the service type is an . + Otherwise null (Nothing in VB) is returned, or an exception is throw when + is set to true. + + + + A call to this method locks the container. No new registrations can't be made after a call to this + method. + + + Note: This method is not guaranteed to always return the same + instance for a given . It will however either + always return null or always return a producer that is able to return the expected instance. + + + The that the returned instance producer should produce. + The indication whether the method should return null or throw + an exception when the type is not registered. + An or null (Nothing in VB). + + + + Injects all public writable properties of the given that have a type + that can be resolved by this container instance. + NOTE: This method will be removed in a future release. To use property injection, + implement a custom the instead. For more information, + read the + extendibility points wiki. + + The instance whose properties will be injected. + + Thrown when the is null (Nothing in VB). + Throw when injecting properties on the given instance + failed due to security constraints of the sandbox. This can happen when injecting properties + on an internal type in a Silverlight sandbox, or when running in partial trust. + + + Initializes a new instance of the class. + + + Initializes a new instance of the class. + The container options. + Thrown when the is a null + reference. + Thrown when supplied is an instance + that already is supplied to another instance. Every container must get + its own instance. + + + + Returns an array with the current registrations. This list contains all explicitly registered + types, and all implicitly registered instances. Implicit registrations are all concrete + unregistered types that have been requested, all types that have been resolved using + unregistered type resolution (using the event), and + requested unregistered collections. Note that the result of this method may change over time, + because of these implicit registrations. + + + + This method has a performance characteristic of O(n). Prevent from calling this in a performance + critical path of the application. + + + Note: This method is not guaranteed to always return the same + instance for a given registration. It will however either + always return a producer that is able to return the expected instance. Because of this, do not + compare sets of instances returned by different calls to + by reference. The way of comparing lists is by the actual type. The type of each instance is + guaranteed to be unique in the returned list. + + + An array of instances. + + + + Returns an array with the current registrations for root objects. Root objects are registrations + that are in the root of the object graph, meaning that no other registration is depending on it. + + + + This method has a performance characteristic of O(n). Prevent from calling this in a performance + critical path of the application. + + + This list contains the root objects of all explicitly registered types, and all implicitly + registered instances. Implicit registrations are all concrete unregistered types that have been + requested, all types that have been resolved using unregistered type resolution (using the + event), and requested unregistered collections. Note that + the result of this method may change over time, because of these implicit registrations. + + + Note: This method is not guaranteed to always return the same + instance for a given registration. It will however either + always return a producer that is able to return the expected instance. Because of this, do not + compare sets of instances returned by different calls to + by reference. The way of comparing lists is by the actual type. The type of each instance is + guaranteed to be unique in the returned list. + + + An array of instances. + Thrown when this method is called before + has been successfully called. + + + Determines whether the specified System.Object is equal to the current System.Object. + + The System.Object to compare with the current System.Object. + + True if the specified System.Object is equal to the current System.Object; otherwise, false. + + + + Returns the hash code of the current instance. + The hash code of the current instance. + + + + Returns a that represents the . + + + A that represents the . + + + + Gets the of the current instance. + The instance that represents the exact runtime + type of the current instance. + + + Prevents any new registrations to be made to the container. + + + + Occurs when an instance of a type is requested that has not been registered explicitly, allowing + resolution of unregistered types before the container tries to create the type. + + + + The event is called by the container every time an + unregistered type is requested for the first time, allowing a developer to do unregistered type + resolution. By calling the + Register method on the + , a , or + delegate can be registered allowing the container to retrieve + instances of the requested type. This registration is cached and it prevents the + ResolveUnregisteredType event from being called again for the same type. + + + When no registered event handled the registration of an unregistered type, the container will try + to create the type when this type is either concrete or is the + interface. Concrete types will be registered with the Transient + lifestyle and registrations will return an empty collection. When no + even handled the registration and the container could not create it, an exception is thrown. + + + Thread-safety: Please note that the container will not ensure that the hooked delegates + are executed only once. While the calls to for a given type + are finite (and will in most cases happen just once), a container can call the delegate multiple + times and make parallel calls to the delegate. You must make sure that the code can be called + multiple times and is thread-safe. + + + + The following example shows the usage of the event: + + { + void Validate(T instance); + } + + // Implementation of the null object pattern. + public class EmptyValidator : IValidator + { + public void Validate(T instance) + { + // Does nothing. + } + } + + [TestMethod] + public void TestResolveUnregisteredType() + { + // Arrange + var container = new Container(); + + // Register an EmptyValidator to be returned when a IValidator is requested: + container.ResolveUnregisteredType += (sender, e) => + { + if (e.UnregisteredServiceType.IsGenericType && + e.UnregisteredServiceType.GetGenericTypeDefinition() == typeof(IValidator<>)) + { + var validatorType = typeof(EmptyValidator<>).MakeGenericType( + e.UnregisteredServiceType.GetGenericArguments()); + + object emptyValidator = container.GetInstance(validatorType); + + // Register the instance as singleton. + e.Register(() => emptyValidator); + } + }; + + // Act + var orderValidator = container.GetInstance>(); + var customerValidator = container.GetInstance>(); + + // Assert + Assert.IsInstanceOfType(orderValidator, typeof(EmptyValidator)); + Assert.IsInstanceOfType(customerValidator, typeof(EmptyValidator)); + } + ]]> + + The example above registers a delegate that is raised every time an unregistered type is requested + from the container. The delegate checks whether the requested type is a closed generic + implementation of the IValidator<T> interface (such as + IValidator<Order> or IValidator<Customer>). In that case it + will request the container for a concrete EmptyValidator<T> implementation that + implements the given + UnregisteredServiceType, and + registers a delegate that will return this created instance. The e.Register call + registers the method in the container, preventing the from + being called again for the exact same service type, preventing any performance penalties. + + + Please note that given example is just an uhhmm... example. In the case of the example the + EmptyValidator<T> can be better registered using of the built-in + RegisterOpenGeneric + extension methods instead. These extension methods take care of any given generic type constraint + and allow the implementation to be integrated into the container's pipeline, which allows + it to be intercepted using the event and allow any registered + initializers to be applied. + + + + + + Occurs after the creation of the of a registered type is complete (the + lifestyle has been applied), allowing the created to be wrapped, + changed, or replaced. Multiple delegates may handle the same service type. + + + + The ExpressionBuilt event is called by the container every time an registered type is + getting compiled, allowing a developer to change the way the type is created. The delegate that + hooks to the ExpressionBuilt event, can change the + property on the + , which allows changing the way the type is constructed. + + + Thread-safety: Please note that the container will not ensure that the hooked delegates + are executed only once per service type. While the calls to for a + given type are finite (and will in most cases happen just once), a container can call the delegate + multiple times and make parallel calls to the delegate. You must make sure that the code can be + called multiple times and is thread-safe. + + + + The following example shows the usage of the ExpressionBuilt event: + + { + void Validate(T instance); + } + + public interface ILogger + { + void Write(string message); + } + + // Implementation of the decorator pattern. + public class MonitoringValidator : IValidator + { + private readonly IValidator validator; + private readonly ILogger logger; + + public MonitoringValidator(IValidator validator, ILogger logger) + { + this.validator = validator; + this.logger = logger; + } + + public void Validate(T instance) + { + this.logger.Write("Validating " + typeof(T).Name); + this.validator.Validate(instance); + this.logger.Write("Validated " + typeof(T).Name); + } + } + + [TestMethod] + public void TestExpressionBuilt() + { + // Arrange + var container = new Container(); + + container.RegisterSingle(); + container.Register, OrderValidator>(); + container.Register, CustomerValidator>(); + + // Intercept the creation of IValidator instances and wrap them in a MonitoringValidator: + container.ExpressionBuilt += (sender, e) => + { + if (e.RegisteredServiceType.IsGenericType && + e.RegisteredServiceType.GetGenericTypeDefinition() == typeof(IValidator<>)) + { + var decoratorType = typeof(MonitoringValidator<>) + .MakeGenericType(e.RegisteredServiceType.GetGenericArguments()); + + // Wrap the IValidator in a MonitoringValidator. + e.Expression = Expression.New(decoratorType.GetConstructors()[0], new Expression[] + { + e.Expression, + container.GetRegistration(typeof(ILogger)).BuildExpression(), + }); + } + }; + + // Act + var orderValidator = container.GetInstance>(); + var customerValidator = container.GetInstance>(); + + // Assert + Assert.IsInstanceOfType(orderValidator, typeof(MonitoringValidator)); + Assert.IsInstanceOfType(customerValidator, typeof(MonitoringValidator)); + } + ]]> + + The example above registers a delegate that is raised every time the container compiles the + expression for an registered type. The delegate checks whether the requested type is a closed generic + implementation of the IValidator<T> interface (such as + IValidator<Order> or IValidator<Customer>). In that case it + will changes the current with a new one that creates + a new MonitoringValidator<T> that takes the current validator (and an ILogger) + as an dependency. + + + Please note that given example is just an uhhmm... example. In the case of the example the + MonitoringValidator<T> is a decorator and instead of manually writing this code that + many limitations, you can use one of the built-in + RegisterDecorator extension methods instead. + These extension methods take care of any given generic type constraint, allow to register decorators + conditionally and allow the decorator to be integrated into the container's pipeline, which allows + it to be intercepted using the event and allow any registered + initializers to be applied. + + + + + + Occurs directly after the creation of the of a registered type is made, + but before any initializer and lifestyle specific caching + has been applied, allowing the created to be altered. Multiple delegates + may handle the same service type. + + + + The ExpressionBuilding event is called by the container every time an registered type is + getting compiled, allowing a developer to change the way the type is created. The delegate that + hooks to the ExpressionBuilding event, can change the + property on the + , which allows changing the way the type is constructed. + + + The exact type supplied depends on the type of registration. + Registrations that explicitly supply the implementation type (such as + Register<TService, TImplementation>()) + will result in an , while registrations that take a delegate (such as + Register<TService>(Func<TService>)) + will result in an . Singletons that are passed in using their + value (RegisterSingle<TService>(TService)) + will result in an . Note that other ExpressionBuilding + registrations might have changed the + property and might have supplied an of a different type. The order in + which these events are registered might be of importance to you. + + + Thread-safety: Please note that the container will not ensure that the hooked delegates + are executed only once per service type. While the calls to registered ExpressionBuilding + events for a given type are finite (and will in most cases happen just once), a container can + call the delegate multiple times and make parallel calls to the delegate. You must make sure that + the code can be called multiple times and is thread-safe. + + + + The following example shows the usage of the ExpressionBuilding event: + + { + var expression = e.Expression as NewExpression; + + if (expression != null) + { + var propertiesToInject = + from property in expression.Constructor.DeclaringType.GetProperties() + where property.GetCustomAttributes(typeof(MyInjectPropertyAttribute), true).Any() + let registration = container.GetRegistration(property.PropertyType, true) + select Tuple.Create(property, registration); + + if (propertiesToInject.Any()) + { + Func[], object> injectorDelegate = + (instance, dependencies) => + { + foreach (var dependency in dependencies) + { + dependency.Item1.SetValue(instance, dependency.Item2.GetInstance(), null); + } + + return instance; + }; + + e.Expression = Expression.Convert( + Expression.Invoke( + Expression.Constant(injectorDelegate), + e.Expression, + Expression.Constant(propertiesToInject.ToArray())), + expression.Constructor.DeclaringType); + } + } + }; + } + ]]> + + The example above registers a delegate that is raised every time the container compiles the + expression for an registered type. The delegate checks if the type contains properties that are + decorated with the supplied MyInjectPropertyAttribute. If decorated properties are found, + the given expression is replaced with an expression that injects decorated properties. + + + The example differs from the container's built-in method in that + it will fail when one of the decorated properties can not be injected. The built-in + will look at all properties of a given class and will simply skip + over any properties that can not be injected, making the use of the + method often verify fragile and error prone. + + + + + Gets the container options. + The instance for this container. + + + + Gets the intermediate lifestyle that forwards CreateRegistration calls to the lifestyle that is + returned from the registered container.Options.LifestyleSelectionBehavior. + + + + Implements a cache for implementations. + + is thread-safe can be used over multiple threads concurrently. + + + + + Allows registering an delegate that will be called when the scope ends, + but before the scope disposes any instances. + + + During the call to all registered delegates are + processed in the order of registration. Do note that registered actions are not guaranteed + to run. In case an exception is thrown during the call to , the + will stop running any actions that might not have been invoked at that point. + Instances that are registered for disposal using on the other + hand, are guaranteed to be disposed. Note that registered actions won't be invoked during a call + to . + + The delegate to run when the scope ends. + Thrown when one of the arguments is a null reference + (Nothing in VB). + Thrown when the scope has been disposed. + + + + Adds the to the list of items that will get disposed when the + scope ends. + + + Instances that are registered for disposal, will be disposed in opposite order of registration and + they are guaranteed to be disposed when is called (even when + exceptions are thrown). This mimics the behavior of the C# and VB using statements, + where the method is called inside the finally block. + + The instance that should be disposed when the scope ends. + Thrown when one of the arguments is a null reference + (Nothing in VB). + Thrown when the scope has been disposed. + + + Releases all instances that are cached by the object. + + + + Releases all instances that are cached by the object. + + False when only unmanaged resources should be released. + + + Configuration options for the . + + The following example shows the typical usage of the ContainerOptions class. + (); + + // Use of ContainerOptions class here. + container.Options.AllowOverridingRegistrations = true; + + // Replaces the previous registration of ITimeProvider + container.Register(); + ]]> + + + + Initializes a new instance of the class. + + + + Gets or sets a value indicating whether the container allows overriding registrations. The default + is false. + + The value indicating whether the container allows overriding registrations. + + + + Gets or sets the constructor resolution behavior. By default, the container only supports types + that have a single public constructor. + + The constructor resolution behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + + Gets or sets the constructor verification behavior. The container's default behavior is to + disallow constructors with value types and strings. + + The constructor resolution behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + Gets or sets the constructor injection behavior. + The constructor injection behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + + Gets or sets the property selection behavior. The container's default behavior is to do no + property injection. + + The property selection behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + + Gets or sets the lifestyle selection behavior. The container's default behavior is to make + registrations using the lifestyle. + The lifestyle selection behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + + Gets the container to which this ContainerOptions instance belongs to or null when + this instance hasn't been applied to a yet. + + The current . + + + + Gets or sets a value indicating whether the container will use dynamic assemblies for compilation. + By default, this value is true for the first few containers that are created in an app + domain and false for all other containers. You can set this value explicitly to false + to prevent the use of dynamic assemblies or you can set this value explicitly to true to + force more container instances to use dynamic assemblies. Note that creating an infinite number + of instances (for instance one per web request) with this property set to + true will result in a memory leak; dynamic assemblies take up memory and will only be + unloaded when the AppDomain is unloaded. + + A boolean indicating whether the container should use a dynamic assembly for compilation. + + + + + Allows verifying whether a given type has a direct or indirect dependency on itself. Verifying is done + by preventing recursive calls to a IInstanceProvider. An instance of this type is related to a single + instance of a IInstanceProvider. A RecursiveDependencyValidator instance checks a single + IInstanceProvider and therefore a single service type. + + + + + Extension methods for the RecursiveDependencyValidator class. + + + + + Provides data for and interaction with the + ExpressionBuilding event of + the . An observer can change the + property to change the component that is + currently being built. + + + + Gets the registered service type that is currently requested. + The registered service type that is currently requested. + + + + Gets the type that is known to be returned by the + Expression (most often the implementation + type used in the Register call). This type will be a derivative of + RegisteredServiceType (or + or RegisteredServiceType itself). If the Expression is changed, the new expression + must also return an instance of type KnownImplementationType or a sub type. + This information must be described in the new Expression. + + A . + + + + Gets the lifestyle for the component that is currently being built. + + The . + + + Gets or sets the currently registered . + The current registration. + Thrown when the supplied value is a null reference. + + + + Gets the collection of currently known relationships. This information is used by the Diagnostics + Debug View. Change the contents of this collection to represent the changes made to the + Expression property (if any). This allows + the Diagnostics Debug View to analyze those new relationships as well. + + The collection of instances. + + + + Provides data for and interaction with the + ExpressionBuilt event of + the . An observer can change the + property to change the component that is currently + being built. + + + + Initializes a new instance of the class. + Type of the registered service. + The registered expression. + + + Gets the registered service type that is currently requested. + The registered service type that is currently requested. + + + Gets or sets the currently registered . + The current registration. + Thrown when the supplied value is a null reference. + + + Gets or sets the current lifestyle of the registration. + The original lifestyle of the registration. + + + + Gets the collection of currently known relationships. This information is used by the Diagnostics + Debug View. Change the contents of this collection to represent the changes made to the + Expression property (if any). This allows + the Diagnostics Debug View to analyze those new relationships as well. + + The collection of instances. + + + + A map containing a generic argument (such as T) and the concrete type (such as Int32) that it + represents. + + + + Implements equality. Needed for doing LINQ distinct operations. + The other to compare to. + True or false. + + + Overrides the default hash code. Needed for doing LINQ distinct operations. + An 32 bit integer. + + + + An instance of this type can be injected into constructors of decorator classes that are registered + using RegisterDecorator. This type contains + contextual information about the applied decoration and it allows users to examine the given instance + to make runtime decisions. + + + + + Gets the closed generic service type for which the decorator is about to be applied. The original + service type will be returned, even if other decorators have already been applied to this type. + + The closed generic service type. + + + + Gets the type of the implementation that is created by the container and for which the decorator + is about to be applied. The original implementation type will be returned, even if other decorators + have already been applied to this type. Please not that the implementation type can not always be + determined. In that case the closed generic service type will be returned. + + The implementation type. + + + + Gets the list of the types of decorators that have already been applied to this instance. + + The applied decorators. + + + + Gets the current object that describes the intention to create a new + instance with its currently applied decorators. + + The current expression that is about to be decorated. + + + + Extension methods for applying decorators. + + + + + Ensures that the supplied decorator is returned and cached with + the given , wrapping the original registered + , by injecting that service type into the constructor of the + supplied . Multiple decorators may be applied to the same + . Decorators can be applied to both open, closed, and non-generic + service types. + + + + The RegisterOpenGenericDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterOpenGenericDecorator on the same service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The registered may have a constructor with an argument of type + where T is . In this case, the + will not inject the decorated itself into the + instance, but it will inject a that allows + creating instances of the decorated type, according to the lifestyle of that type. This enables + more advanced scenarios, such as executing the decorated types on a different thread, or executing + decorated instance within a certain scope (such as a lifetime scope). + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + The lifestyle that specifies how the returned decorator will be cached. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or + implement , when + does not have a single public constructor, or when does + not contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that the supplied decorator is returned when the supplied + returns true and cached with the given + , wrapping the original registered , by + injecting that service type into the constructor of the supplied . + Multiple decorators may be applied to the same . Decorators can be + applied to both open, closed, and non-generic service types. + + + + The RegisterOpenGenericDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterOpenGenericDecorator on the same service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The registered may have a constructor with an argument of type + where T is . In this case, the + will not inject the decorated itself into the + instance, but it will inject a that allows + creating instances of the decorated type, according to the lifestyle of that type. This enables + more advanced scenarios, such as executing the decorated types on a different thread, or executing + decorated instance within a certain scope (such as a lifetime scope). + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + The lifestyle that specifies how the returned decorator will be cached. + The predicate that determines whether the + must be applied to a service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or + implement , when + does not have a single public constructor, or when does + not contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that the decorator type that is returned from is + supplied when the supplied returns true and cached with the given + , wrapping the original registered , by + injecting that service type into the constructor of the decorator type that is returned by the + supplied . + Multiple decorators may be applied to the same . Decorators can be + applied to both open, closed, and non-generic service types. + + + + The types returned from the may be open-generic. The + container will try to fill in the generic parameters based on the resolved service type. + + + The RegisterOpenGenericDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterOpenGenericDecorator on the same service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The type returned from may have a constructor with an + argument of type where T is . In this + case, the framework will not inject the decorated itself into the + decorator instance, but it will inject a that allows + creating instances of the decorated type, according to the lifestyle of that type. This enables + more advanced scenarios, such as executing the decorated types on a different thread, or executing + decorated instance within a certain scope (such as a lifetime scope). + + + + The following is an example of the registration of a decorator through the factory delegate: + , MoveCustomerCommandHandler>(); + + container.RegisterDecorator( + typeof(ICommandHandler<>), + context => typeof(LoggingCommandHandler<,>).MakeGenericType( + typeof(LoggingCommandHandler<,>).GetGenericArguments().First(), + context.ImplementationType), + Lifestyle.Transient, + context => true); + + var handler = container.GetInstance>(); + + Assert.IsInstanceOfType(handler, + typeof(LoggingCommandHandler)); + + ]]> + The code above allows a generic LoggingCommandHandler<TCommand, TImplementation> to + be applied to command handlers, where the second generic argument will be filled in using the + contextual information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the decorator type returned by the supplied . + A factory that allows building Type objects that define the + decorators to inject, based on the given contextual information. The delegate is allowed to return + open-generic types. + The lifestyle that specifies how the returned decorator will be cached. + The predicate that determines whether the decorator must be applied to a + service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type. + + + + Ensures that the supplied decorator is returned, wrapping the + original registered , by injecting that service type into the + constructor of the supplied . Multiple decorators may be applied + to the same . Decorators can be applied to both open, closed, and + non-generic service types. By default, a new instance will be + returned on each request (according the Transient lifestyle), + independently of the lifestyle of the wrapped service. + + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + + The RegisterDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterDecorator on the same generic service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The registered may have a constructor with an argument of type + where T is . In this case, an decorated + instance will not injected into the , but it will inject a + that allows creating instances of the decorated type, according to the + lifestyle of that type. This enables more advanced scenarios, such as executing the decorated + types on a different thread, or executing decorated instance within a certain scope (such as a + lifetime scope). + + + + The following example shows the definition of a generic ICommandHandler<T> interface, + a CustomerMovedCommandHandler implementing that interface, and a + ValidatorCommandHandlerDecorator<T> that acts as a decorator for that interface. + + { + void Handle(TCommand command); + } + + public class CustomerMovedCommand + { + [Required] + public int CustomerId { get; set; } + + [Required] + public Address Address { get; set; } + } + + public class CustomerMovedCommandHandler + : ICommandHandler + { + public void Handle(CustomerMovedCommand command) + { + // some logic + } + } + + // Decorator that validates commands before they get executed. + public class ValidatorCommandHandlerDecorator + : ICommandHandler + { + private readonly ICommandHandler decoratedHandler; + private readonly Container container; + + public ValidatorCommandHandlerDecorator( + ICommandHandler decoratedHandler, + Container container) + { + this.decoratedHandler = decoratedHandler; + this.container = container; + } + + public void Handle(TCommand command) + { + this.Validate(command); + + this.decoratedHandler.Handle(command); + } + + private void Validate(TCommand command) + { + var validationContext = + new ValidationContext(command, this.container, null); + + Validator.ValidateObject(command, validationContext); + } + } + + // Decorator that measures the time it takes to execute a command. + public class MonitoringCommandHandlerDecorator + : ICommandHandler + { + private readonly ICommandHandler decoratedHandler; + private readonly ILogger logger; + + public MonitoringCommandHandlerDecorator( + ICommandHandler decoratedHandler, + ILogger logger) + { + this.decoratedHandler = decoratedHandler; + this.logger = logger; + } + + public void Handle(TCommand command) + { + var watch = Stopwatch.StartNew(); + + this.decoratedHandler.Handle(command); + + this.logger.Log(string.Format("{0} executed in {1} ms.", + command.GetType().Name, watch.ElapsedMilliseconds)); + } + } + + [TestMethod] + public static void TestRegisterOpenGenericDecorator() + { + // Arrange + var container = new Container(); + + container.RegisterSingle(); + + // Search the given assembly and register all concrete types that + // implement ICommandHandler. + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), + typeof(ICommandHandler<>).Assembly); + + // Wrap all ICommandHandler service types with a decorator + // that measures and logs the duration of that handler. + container.RegisterDecorator(typeof(ICommandHandler<>), + typeof(MonitoringCommandHandlerDecorator<>)); + + // Wrap all ICommandHandler types (in this case it will + // wrap the monitoring decorator), but only if the TCommand contains + // any properties. + container.RegisterDecorator(typeof(ICommandHandler<>), + typeof(ValidatorCommandHandlerDecorator<>), context => + { + var commandType = context.ServiceType.GetGenericArguments()[0]; + bool mustDecorate = commandType.GetProperties().Any(); + return mustDecorate; + }); + + // Act + var handler = + container.GetInstance>(); + + // Assert + Assert.IsInstanceOfType(handler, + typeof(ValidatorCommandHandlerDecorator)); + } + ]]> + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or implement + , when does not + have a single public constructor, or when does not + contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that the supplied decorator is returned when the supplied + returns true, wrapping the original registered + , by injecting that service type into the constructor of the + supplied . Multiple decorators may be applied to the same + . Decorators can be applied to both open, closed, and non-generic + service types. By default, a new instance will be returned on + each request (according the Transient lifestyle), + independently of the lifestyle of the wrapped service. + + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + + The RegisterOpenGenericDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterOpenGenericDecorator on the same service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The registered may have a constructor with an argument of type + where T is . In this case, the + will not inject the decorated itself into the + instance, but it will inject a that allows + creating instances of the decorated type, according to the lifestyle of that type. This enables + more advanced scenarios, such as executing the decorated types on a different thread, or executing + decorated instance within a certain scope (such as a lifetime scope). + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + The predicate that determines whether the + must be applied to a service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or + implement , when + does not have a single public constructor, or when does + not contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that a single instance of the supplied decorator is + returned, wrapping the original registered , by injecting that + service type into the constructor of the supplied . Multiple + decorators may be applied to the same . Decorators can be applied + to both open, closed, and non-generic service types. + + + + This method ensures that a single instance of the supplied is + returned, no matter what the lifestyle of the wrapped service type is. Use with care, because the + wrapped service type will also become a singleton. This method is especially useful when use for + injecting factory methods, which will allow the wrapped service type to get + it's own lifestyle back. + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or implement + , when does not + have a single public constructor, or when does not + contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that the supplied decorator is returned when the supplied + returns true, wrapping the original registered + , by injecting that service type into the constructor of the + supplied . Multiple decorators may be applied to the same + . Decorators can be applied to both open, closed, and non-generic + service types. + + + + This method ensures that a single instance of the supplied is + returned, no matter what the lifestyle of the wrapped service type is. Use with care, because the + wrapped service type will also become a singleton. This method is especially useful when use for + injecting factory methods, which will allow the wrapped service type to get + it's own lifestyle back. + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + The predicate that determines whether the + must be applied to a service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or + implement , when + does not have a single public constructor, or when does + not contain a constructor that has exactly one argument of type + or where T is + . + + + + An instance of this type will be supplied to the + delegate that is that is supplied to the + RegisterDecorator + overload that takes this delegate. This type contains information about the decoration that is about + to be applied and it allows users to examine the given instance to see whether the decorator should + be applied or not. + + + Please see the + RegisterDecorator + method for more information. + + + + + Gets the closed generic service type for which the decorator is about to be applied. The original + service type will be returned, even if other decorators have already been applied to this type. + + The closed generic service type. + + + + Gets the type of the implementation that is created by the container and for which the decorator + is about to be applied. The original implementation type will be returned, even if other decorators + have already been applied to this type. Please not that the implementation type can not always be + determined. In that case the closed generic service type will be returned. + + The implementation type. + + + + Gets the list of the types of decorators that have already been applied to this instance. + + The applied decorators. + + + + Gets the current object that describes the intention to create a new + instance with its currently applied decorators. + + The current expression that is about to be decorated. + + + + Hooks into the building process and adds a decorator if needed. + + + + This interface is not meant for public use. + + + Please do not use. + Do not use. + + + PLease do not use. + Do not use. + + + + A Registration implements lifestyle based caching for a single service and allows building an + that describes the creation of the service. + + + implementations create a new Registration instance for each registered + service type. s returned from the + BuildExpression method can be intercepted by any event + registered with , have + initializers + applied, and the caching particular to its lifestyle have been applied. Interception using the + Container.ExpressionBuilt will not + be applied in the Registration, but will be applied in . + + See the documentation for an example. + + + + + Initializes a new instance of the class. + + The this that created this registration. + The instance for this registration. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + + Builds a new with the correct caching (according to the specifications of + its ) applied. + + An . + + + + Gets the list of instances. Note that the list is only available + after calling . + + A new array containing the instances. + + + + Initializes an already created instance and applies properties and initializers to that instance. + + + This method is especially useful in integration scenarios where the given platform is in control + of creating certain types. By passing the instance created by the platform to this method, the + container is still able to apply any properties (as defined using a custom + ) and by applying any initializers. + + The instance to initialize. + Thrown when is a null reference + (Nothing in VB). + Thrown when the supplied is not + of type . + + + + Builds a delegate for the creation of the + using the supplied . The returned might + be intercepted by a + Container.ExpressionBuilding event, + and the will have been wrapped with a delegate that executes the + registered initializers + that are applicable to the given (if any). + + The interface or base type that can be used to retrieve instances. + + The delegate supplied by the user that allows building or creating new instances. + A delegate. + + + + Builds a delegate for the creation of . + The returned might be intercepted by a + Container.ExpressionBuilding event, + and the creation of the will have been wrapped with a + delegate that executes the registered + initializers + that are applicable to the given (if any). + + The interface or base type that can be used to retrieve instances. + The concrete type that will be registered. + A delegate. + + + + Builds an that describes the creation of the + using the supplied . The returned might + be intercepted by a + Container.ExpressionBuilding event, + and the will have been wrapped with a delegate that executes the + registered initializers that are + applicable to the given (if any). + + The interface or base type that can be used to retrieve instances. + + The delegate supplied by the user that allows building or creating new instances. + An . + + + + Builds an that describes the creation of + . The returned might be intercepted + by a Container.ExpressionBuilding + event, and the creation of the will have been wrapped with + a delegate that executes the registered + initializers + that are applicable to the given (if any). + + The interface or base type that can be used to retrieve instances. + The concrete type that will be registered. + An . + + + Gets the type that this instance will create. + The type that this instance will create. + + + Gets the this that created this registration. + The this that created this registration. + + + Gets the instance for this registration. + The instance for this registration. + + + + Allows retrieving the concrete types of the generic type arguments of that must be used to create a + closed generic implementation of a given open generic implementation, based on on the concrete + arguments of the given closed base type. + + + + + Helper class for building closed generic type for a given open generic type and a closed generic base. + + + + Result of the GenericTypeBuilder. + + + + A open generic type with the concrete arguments that can be used to create a closed generic type. + + + + + Helper methods for the extensions. + + + + + Represents the method that will called to register one or multiple concrete non-generic + of the given closed generic type + . + + The service type that needs to be registered. + One or more concrete types that implement the given + . + + + { + foreach (Type implementation in implementations) + { + container.RegisterSingle(implementation); + } + + container.RegisterAll(closedServiceType, implementations); + }; + + container.RegisterManyForOpenGeneric( + typeof(ICommandHandler<>), + registerAsCollectionAsSingletons, + typeof(ICommandHandler<>).Assembly); + ]]> + The BatchRegistrationCallback can be supplied to some overloads of the + RegisterManyForOpenGeneric extension methods. + The default behavior of the RegisterManyForOpenGeneric methods is to register a closed generic + type with the corresponding implementation (and will throw when multiple implementations are found for + a single closed generic service type). The given example overrides this default registration by + registering the found list of implementations (one or more) as collection of singletons for the given + closed generic service type. + + + + Defines the accessibility of the types to search. + This type is not available in Silverlight. + + + Load both public as internal types from the given assemblies. + + + Only load publicly exposed types from the given assemblies. + + + + Provides a set of static (Shared in Visual Basic) methods for registration many concrete types at + once that implement the same open generic service types in the . + + + + + Registers all concrete, non-generic, public and internal types in the given set of + that implement the given + with a transient lifetime. + + The container to make the registrations in. + The definition of the open generic type. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic, public and internal types that are located in the given + that implement the given + with a transient lifetime. + + The container to make the registrations in. + The definition of the open generic type. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic, public and internal types in the given set of + that implement the given + with the supplied . When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will point at the same registration and return the same instance based on the caching + behavior of the supplied . + + The container to make the registrations in. + The definition of the open generic type. + The lifestyle that will be used for the registration of the types. + A list of assemblies that will be searched. + Thrown when , + , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic, public and internal types that are located in the given + that implement the given + with the supplied . When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will point at the same registration and return the same instance based on the caching + behavior of the supplied . + + The container to make the registrations in. + The definition of the open generic type. + The lifestyle that will be used for the registration of the types. + A list of assemblies that will be searched. + Thrown when , + , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Allows registration of all concrete, public and internal, non-generic types that are located in the given set of + that implement the given , + by supplying a delegate, that will be called for each + found closed generic implementation of the given . + + The container to make the registrations in. + The definition of the open generic type. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + A list of assemblies that will be searched. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type. + + + + Allows registration of all concrete, public and internal, non-generic types that are located in the given set of + that implement the given , + by supplying a delegate, that will be called for each + found closed generic implementation of the given . + + The container to make the registrations in. + The definition of the open generic type. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + A list of assemblies that will be searched. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type. + + + + Registers all concrete, non-generic, public and internal types that are located in the given + that implement the given + with a singleton lifetime. + + The container to make the registrations in. + The definition of the open generic type. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic, public and internal types that are located in the given + that implement the given + with a singleton lifetime. + + The container to make the registrations in. + The definition of the open generic type. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all supplied by a closed generic definition of the + given with a transient lifetime. + + The container to make the registrations in. + The definition of the open generic type. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all supplied by a closed generic definition of the + given with a transient lifetime. + + The container to make the registrations in. + The definition of the open generic type. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Allows registration of all supplied by a closed generic + definition of the given , by supplying a + delegate, that will be called for each found closed generic + implementation. + If the list contains open generic types, matching closed generic versions of each open generic + type will be added to the list of implementations that is passed on to the + delegate. + + The container to make the registrations in. + The definition of the open generic type. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + The list of types that must be registered according to the given + definition. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + + + + Registers all supplied by a closed generic definition of the + given with a singleton lifetime. + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will return the exact same instance. + + The container to make the registrations in. + The definition of the open generic type. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all supplied by a closed generic definition of the + given with the supplied . + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will return the exact same instance. + + The container to make the registrations in. + The definition of the open generic type. + The lifestyle the registrations are made in. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all supplied by a closed generic definition of the + given with a singleton lifetime. + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will return the exact same instance. + + The container to make the registrations in. + The definition of the open generic type. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all supplied by a closed generic definition of the + given with the supplied + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will return the exact same instance. + + The container to make the registrations in. + The definition of the open generic type. + The lifestyle the registrations are made in. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with a transient lifetime. + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same closed generic + version of the given . + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with a transient lifetime. + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type or when the argument contains an invalid + value. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with the supplied . + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will point at the same registration and return the same instance based on the caching + behavior of the supplied . + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + The lifestyle that will be used for the registration of the types. + A list of assemblies that will be searched. + Thrown when , + , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same closed generic + version of the given . + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with the supplied . + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will point at the same registration and return the same instance based on the caching + behavior of the supplied . + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + The lifestyle that will be used for the registration of the types. + A list of assemblies that will be searched. + Thrown when , + , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Allows registration of all concrete, non-generic types with the given + that are located in the given set of + that implement the given , by supplying a + delegate, that will be called for each found closed generic + implementation of the given . + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + A list of assemblies that will be searched. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + + + + Allows registration of all concrete, non-generic types with the given + that are located in the given set of + that implement the given , by supplying a + delegate, that will be called for each found closed generic + implementation of the given . + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + A list of assemblies that will be searched. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with a singleton lifetime. + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same closed generic + version of the given . + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with a singleton lifetime. + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Returns all types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), AccessibilityOption.PublicTypesOnly, + typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the + registration. + + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + A list of types. + Thrown when + contains an invalid value. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), AccessibilityOption.PublicTypesOnly, + typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the registration. + + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + A list of types. + Thrown when + contains an invalid value. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), AccessibilityOption.PublicTypesOnly, + typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the + registration. + + The container to use. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + A list of types. + Thrown when + contains an invalid value. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), AccessibilityOption.PublicTypesOnly, + typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the registration. + + The container to use. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + A list of types. + Thrown when + contains an invalid value. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all public and internal types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the + registration. + + The definition of the open generic type. + A list of assemblies that will be searched. + A list of types. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all public and internal types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the registration. + + The definition of the open generic type. + A list of assemblies that will be searched. + A list of types. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all public and internal types that are located in the supplied + and implement or inherit from the supplied . + Types that are considered to be decorators are not returned. + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the + registration. + + The container to use. + The definition of the open generic type. + A list of assemblies that will be searched. + A list of types. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all public and internal types that are located in the supplied + and implement or inherit from the supplied . + Types that are considered to be decorators are not returned. + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the registration. + + The container to use. + The definition of the open generic type. + A list of assemblies that will be searched. + A list of types. + Thrown when , or + contain a null reference (Nothing in VB). + + + + An instance of this type will be supplied to the + delegate that is that is supplied to the + RegisterOpenGeneric + overload that takes this delegate. This type contains information about the open generic service that is about + to be created and it allows the user to examine the given instance to decide whether this implementation should + be created or not. + + + Please see the + RegisterOpenGeneric + method for more information. + + + + Gets the closed generic service type that is to be created. + The closed generic service type. + + + Gets the closed generic implementation type that will be created by the container. + The implementation type. + + + Gets a value indicating whether a previous RegisterOpenGeneric registration has already + been applied for the given . + The indication whether the event has been handled. + + + + Provides a set of static (Shared in Visual Basic) methods for registration of open generic service + types in the . + + + + + Registers that a new instance of will be returned + every time a is requested. + + + Please see the + RegisterOpenGeneric(Container,Type,Type,Lifestyle) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The definition of the open generic implementation type + that will be returned when a is requested. + + + + Registers that the same instance of will be returned + every time a is requested. + + + Please see the + RegisterOpenGeneric(Container,Type,Type,Lifestyle) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances.. + The definition of the open generic implementation type + that will be returned when a is requested. + + + + Registers that a closed generic instance of the supplied + will be returned when a closed generic version of + the is requested. The instance will be cached + according to the specified . + + + Types registered using the RegisterOpenGeneric are resolved using unregistered type + resolution. This means that an explicit registration made for a closed generic version of the + always gets resolved first and the given + only gets resolved when there is no such registration. + + + The following example shows the definition of a generic IValidator<T> interface + and, a NullValidator<T> implementation and a specific validator for Orders. + The registration ensures a OrderValidator is returned when a + IValidator<Order> is requested. For all requests for a + IValidator<T> other than a IValidator<Order>, an + implementation of NullValidator<T> will be returned. + + { + void Validate(T instance); + } + + public class NullValidator : IValidator + { + public void Validate(T instance) + { + } + } + + public class OrderValidator : IValidator + { + public void Validate(Order instance) + { + if (instance.Total < 0) + { + throw new ValidationException("Total can not be negative."); + } + } + } + + [TestMethod] + public static void TestRegisterOpenGeneric() + { + // Arrange + var container = new Container(); + + container.Register, OrderValidator>(Lifestyle.Transient); + container.RegisterOpenGeneric(typeof(IValidator<>), typeof(NullValidator<>), Lifestyle.Singleton); + + // Act + var orderValidator = container.GetInstance>(); + var customerValidator = container.GetInstance>(); + var productValidator = container.GetInstance>(); + + // Assert + Assert.IsInstanceOfType(orderValidator, typeof(OrderValidator)); + Assert.IsInstanceOfType(customerValidator, typeof(NullValidator)); + Assert.IsInstanceOfType(productValidator, typeof(NullValidator)); + } + ]]> + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The definition of the open generic implementation type + that will be returned when a is requested. + The lifestyle that defines how returned instances are cached. + + + + Registers that the same instance of will be returned + every time a is requested. + + + Please see the + RegisterOpenGeneric(Container,Type,Type,Lifestyle) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances.. + The definition of the open generic implementation type + that will be returned when a is requested. + The lifestyle that defines how returned instances are cached. + The predicate that determines whether the + can implement the service type. + + + + Registers that instances of will be returned + when a collection of is requested. New instances of + the registered will be returned whenever the + resolved collection is iterated. + + + Please see the + RegisterAllOpenGeneric(Container,Type,Lifestyle,IEnumerable<Type>) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The list of open generic implementation types + that will be returned when a collection of is requested. + + + + + Registers that instances of will be returned + when a collection of is requested. New instances of + the registered will be returned whenever the + resolved collection is iterated. + + + Please see the + RegisterAllOpenGeneric(Container,Type,Lifestyle,IEnumerable<Type>) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The list of open generic implementation types + that will be returned when a collection of is requested. + + + + + Registers that instances of will be returned + when a collection of is requested. The instances will be + cached according to the specified . + + + Please see the + RegisterAllOpenGeneric(Container,Type,Lifestyle,IEnumerable<Type>) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The lifestyle that defines how returned instances are cached. + The list of open generic implementation types + that will be returned when a collection of is requested. + + + + + Registers that instances of will be returned + when a collection of is requested. The instances will be + cached according to the specified . + + + + Collections registered using the RegisterAllOpenGeneric are resolved using unregistered type + resolution. This means that an explicit registration made for a collection of the closed generic + version of the always gets resolved first and a + collection of only gets resolved when there is no + such registration. + + + + The following example shows the definition of a generic IValidator<T> interface + and, a NullValidator<T> implementation and a specific validator for Orders. + The registration ensures a OrderValidator is returned when a + IValidator<Order> is requested. For all requests for a + IValidator<T> other than a IValidator<Order>, an + implementation of NullValidator<T> will be returned. + + { + void Validate(T instance); + } + + public class DefaultValidator : IValidator + { + public void Validate(T instance) + { + // some default validation + } + } + + [TestMethod] + public static void TestRegisterAllOpenGeneric() + { + // Arrange + var container = new Container(); + + Type[] types = new[] { typeof(OrderValidator), typeof(DefaultValidator<>) }; + + container.RegisterManyForOpenGeneric(typeof(IValidator<>), + (serviceType, implementationTypes) => container.RegisterAll(serviceType, implementationTypes), + types); + + container.RegisterAllOpenGeneric(typeof(IValidator<>), typeof(DefaultValidator<>)); + + // Act + var orderValidators = container.GetAllInstances>(); + var customerValidators = container.GetAllInstances>(); + + // Assert + Assert.IsTrue(orderValidators.SequenceEqual( + new[] { typeof(OrderValidator), typeof(DefaultValidator) })); + + // Without the call to RegisterAllOpenGeneric this customerValidators would be empty. + Assert.IsTrue(customerValidators.SequenceEqual(new[] { typeof(DefaultValidator) })); + } + ]]> + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The lifestyle that defines how returned instances are cached. + The list of open generic implementation types + that will be returned when a collection of is requested. + + + + Resolves a given open generic type. + + + + Allows validating an ArgumentMapping. + + + + + Instances returned from the container can be cached. The contains several + overloads of the Register method that take a Lifestyle instance as argument to define + how returned instances should be cached. The core library contains two lifestyles out of the box. By + supplying Lifestyle.Transient, the registered instance is not + cached; a new instance is returned every time it is requested or injected. By supplying + Lifestyle.Singleton instances can be cached indefinitely; only + a single instance of the registered component will be returned by that container instance. Other + lifestyles are defined in integration and extension packages. The + CreateCustom method allows defining a custom lifestyle and + the CreateHybrid method + allows creating a lifestyle that mixes multiple other lifestyles. + + + This type is abstract and can be overridden to implement a custom lifestyle. + + + + + The lifestyle instance that doesn't cache instances. A new instance of the specified + component is created every time the registered service it is requested or injected. + + + The following example registers the SomeServiceImpl implementation for the + ISomeService service type using the Transient lifestyle: + (Lifestyle.Transient); + ]]> + Note that Transient is the default lifestyle, the previous registration can be reduced to + the following: + (); + ]]> + + + + + The lifestyle that caches components during the lifetime of the instance + and guarantees that only a single instance of that component is created for that instance. Since + general use is to create a single Container instance for the lifetime of the application / + AppDomain, this would mean that only a single instance of that component would exist during the + lifetime of the application. In a multi-threaded applications, implementations registered using + this lifestyle must be thread-safe. + + + The following example registers the RealTimeProvider implementation for the + ITimeProvider service type using the Singleton lifestyle: + (Lifestyle.Singleton); + ]]> + Note that using the + RegisterSingle method has + the same effect: + (); + ]]> + + + + Initializes a new instance of the class. + The user friendly name of this lifestyle. + Thrown when is null (Nothing in VB) + or an empty string. + + + + The hybrid lifestyle allows mixing two lifestyles in a single registration. Based on the supplied + delegate the hybrid lifestyle will redirect the creation of + the instance to the correct lifestyle. The result of the + delegate will not be cached; it is invoked each time an instance is requested or injected. By + nesting hybrid lifestyles, any number of lifestyles can be mixed. + + The delegate that determines which + lifestyle should be used. The will be used if true is + returned; the otherwise. This delegate will be called every + time an instance needs to be resolved or injected. + The lifestyle to use when + returns true. + The lifestyle to use when + returns false. + A new hybrid lifestyle that wraps the supplied lifestyles. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + The following example shows the creation of a HybridLifestyle that mixes an + WebRequestLifestyle and LifetimeScopeLifestyle: + + HttpContext.Current != null, + new WebRequestLifestyle(), + new LifetimeScopeLifestyle()); + + // The created lifestyle can be reused for many registrations. + container.Register(mixedScopeLifestyle); + container.Register(mixedScopeLifestyle); + ]]> + + Hybrid lifestyles can be nested: + + container.GetCurrentLifetimeScope() != null, + new LifetimeScopeLifestyle(), + Lifestyle.Transient); + + var mixedScopeLifestyle = Lifestyle.CreateHybrid( + () => HttpContext.Current != null, + new WebRequestLifestyle(), + mixedLifetimeTransientLifestyle); + ]]> + + The mixedScopeLifestyle now mixed three lifestyles: Web Request, Lifetime Scope and + Transient. + + + + + + The hybrid lifestyle allows mixing two lifestyles in a single registration. Based on the supplied + delegate the hybrid lifestyle will redirect the creation of + the instance to the correct lifestyle. The result of the + delegate will not be cached; it is invoked each time an instance is requested or injected. By + nesting hybrid lifestyles, any number of lifestyles can be mixed. + + The delegate that determines which + lifestyle should be used. The will be used if true is + returned; the otherwise. This delegate will be called every + time an instance needs to be resolved or injected. + The scoped lifestyle to use when + returns true. + The scoped lifestyle to use when + returns false. + A new scoped hybrid lifestyle that wraps the supplied lifestyles. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + The following example shows the creation of a HybridLifestyle that mixes an + WebRequestLifestyle and LifetimeScopeLifestyle: + + HttpContext.Current != null, + new WebRequestLifestyle(), + new LifetimeScopeLifestyle()); + + // The created lifestyle can be reused for many registrations. + container.Register(mixedScopeLifestyle); + container.Register(mixedScopeLifestyle); + ]]> + + + + + Creates a custom lifestyle using the supplied delegate. + + + The supplied will be called just once per registered + service. The supplied will be called by the framework + when the type is resolved for the first time, and the framework will supply the factory with a + Func<object> for creating new (transient) instances of that type (that might + have been intercepted and + initializers might have been applied). + It is the job of the to return a Func<object> + that applies the proper caching. The Func<object> that is returned by the + will be stored for that registration (every + registration will store its own Func<object> delegate) and this delegate will be + called every time the service is resolved (by calling + container.GetInstance<TService> or when that service is injected into another + type). + + The name of the lifestyle to create. The name is used to display the lifestyle + in the debugger. + A factory delegate that takes a Func<object> delegate + that will produce a transient instance and returns a delegate that returns cached instances. + A new . + Thrown when one of the arguments is a null reference + (Nothing in VB). + Thrown when is an empty string. + + The following example shows the creation of a lifestyle that caches registered instances for 10 + minutes: + + { + TimeSpan timeout = TimeSpan.FromMinutes(10); + var syncRoot = new object(); + var expirationTime = DateTime.MinValue; + object instance = null; + + // If the application has multiple registrations using this lifestyle, each registration + // will get its own Func delegate (created here) and therefore get its own set + // of variables as defined above. + return () => + { + lock (syncRoot) + { + if (expirationTime < DateTime.UtcNow) + { + instance = instanceCreator(); + expirationTime = DateTime.UtcNow.Add(timeout); + } + + return instance; + } + }; + }); + + var container = new Container(); + + // We can reuse the created lifestyle for multiple registrations. + container.Register(customLifestyle); + container.Register(customLifestyle); + ]]> + + + + + Creates a new instance for the given + that will create new instances of specified with the + caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be created. + The instance for which a + must be created. + A new instance. + Thrown when is a null + reference (Nothing in VB). + + + + Creates a new instance for the given + that will create new instances instance using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + A delegate that will create a new instance of + every time it is called. + The instance for which a + must be created. + A new instance. + Thrown when either or + are null references (Nothing in VB). + + + + Creates a new instance for the given + that will create new instances of specified with the + caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + Thrown when on of the supplied arguments is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + Thrown when is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be created. + The instance for which a + must be created. + A new instance. + Thrown when is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + A delegate that will create a new instance of + every time it is called. + The instance for which a + must be created. + A new instance. + Thrown when either or + are null references (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + This method might fail when run in a partial trust sandbox when + is an internal type. + + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + Thrown when on of the supplied arguments is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + This method might fail when run in a partial trust sandbox when + is an internal type. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + Thrown when on of the supplied arguments is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The delegate that will be responsible for creating new instances. + The instance for which a + must be created. + A new instance. + Thrown when on of the supplied arguments is a null + reference (Nothing in VB). + + + + When overridden in a derived class, + creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + + If you are implementing your own lifestyle, override this method to implement the code necessary + to create and return a new . Note that you should always create + a new instance. They should never be cached. + + + + + When overridden in a derived class, + creates a new instance defining the creation of the + specified using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + A delegate that will create a new instance of + every time it is called. + The instance for which a + must be created. + A new instance. + + If you are implementing your own lifestyle, override this method to implement the code necessary + to create and return a new . Note that you should always create + a new instance. They should never be cached. + + + + Gets the user friendly name of this lifestyle. + The user friendly name of this lifestyle. + + + + Gets the length of the lifestyle. Implementers must implement this property. The diagnostic + services use this value to compare lifestyles with each other to determine lifestyle + misconfigurations. + + The representing the length of this lifestyle. + + + + A known relationship defines a relationship between two types. The Diagnostics Debug View uses this + information to spot possible misconfigurations. + + + + Initializes a new instance of the class. + The implementation type of the parent type. + The lifestyle of the parent type. + The type that the parent depends on (it is injected into the parent). + + + Serves as a hash function for a particular type. + A hash code for the current . + + + + Determines whether the specified is equal to the current + . + + The object to compare with the current object. + True if the specified is equal to the current + ; otherwise, false. + + + Gets the implementation type of the parent type of the relationship. + The implementation type of the parent type of the relationship. + + + Gets the lifestyle of the parent type of the relationship. + The lifestyle of the parent type of the relationship. + + + Gets the type that the parent depends on (it is injected into the parent). + The type that the parent depends on. + + + + Factory for the creation of a delegate that applies caching to the supplied + . + + A factory for creating new instances. + A factory that returns cached instances. + + + + Forwards CreateRegistration calls to the lifestyle that is returned from the registered + container.Options.LifestyleSelectionBehavior. + + + + + Base class for scoped lifestyles. A scoped lifestyle caches instances for the duration of an implicitly + or explicitly defined scope. Such scope can be an (implicitly defined) web request or an explicitly + defined Lifetime Scope. The lifetime of instances registered with a scoped lifestyle is always equal + or bigger than one-instance-per-object-graph. In other words, a call to GetInstance() will never create + more than one instance of such registered type. + + + + Initializes a new instance of the class. + The user friendly name of this lifestyle. + Thrown when is null (Nothing in VB) + or an empty string. + + + Initializes a new instance of the class. + The user friendly name of this lifestyle. + Signals the lifestyle whether instances should be + disposed or not. + Thrown when is null (Nothing in VB) + or an empty string. + + + + Allows registering an delegate that will be called when the scope ends, + but before the scope disposes any instances. + + + During the call to all registered delegates are + processed in the order of registration. Do note that registered actions are not guaranteed + to run. In case an exception is thrown during the call to , the + will stop running any actions that might not have been invoked at that point. + Instances that are registered for disposal using on the other + hand, are guaranteed to be disposed. Note that registered actions won't be invoked during a call + to . + + The instance. + The delegate to run when the scope ends. + Thrown when one of the arguments is a null reference + (Nothing in VB). + Will be thrown when there is currently no active + scope for the supplied . + + + + Adds the to the list of items that will get disposed when the + scope ends. + + + Note to implementers: Instances registered for disposal will have to be disposed in the opposite + order of registration, since disposable components might still need to call disposable dependencies + in their Dispose() method. + + The instance. + The instance that should be disposed when the scope ends. + Thrown when one of the arguments is a null reference + (Nothing in VB). + Will be thrown when there is currently no active + scope for the supplied . + + + + Returns the current for this lifestyle and the given + , or null when this method is executed outside the context of a scope. + + The container instance that is related to the scope to return. + A instance or null when there is no scope active in this context. + + + + Creates a delegate that upon invocation return the current for this + lifestyle and the given , or null when the delegate is executed outside + the context of such scope. + + The container for which the delegate gets created. + A delegate. This method never returns null. + + + + Returns the current for this lifestyle and the given + , or null when this method is executed outside the context of a scope. + + The container instance that is related to the scope to return. + A instance or null when there is no scope active in this context. + + + + Creates a new instance defining the creation of the + specified using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + A delegate that will create a new instance of + every time it is called. + The instance for which a + must be created. + A new instance. + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + + + + Disposes the list of supplied . The list is iterated in reverse + order (the first element in the list will be disposed last) and the method ensures that the + Dispose method of each element is called, regardless of any exceptions raised from any previously + called Dispose methods. If multiple exceptions are thrown, the last thrown exception will bubble + up the call stack. + + The list of objects to be disposed. + Thrown when the is a null + reference. + + + + Helper methods for the container. + + + + + Produces instances for a given registration. Instances of this type are generally created by the + container when calling one of the Register overloads. Instances can be retrieved by calling + or . + + + The Register method overloads create InstanceProducer instances internally, but + InstanceProducers can be created manually to implement special scenarios. An + InstanceProducer wraps instance. The Registration builds an + that describes the intend to create the instance according to a certain + lifestyle. The InstanceProducer on the other hand transforms this Expression to a + delegate and allows the actual instance to be created. A Registration itself can't create any + instance. The InsanceProducer allows intercepting created instances by hooking onto the + Container.ExpressionBuilt event. The + RegisterDecorator + extension methods for instance work by hooking onto the ExpressionBuilt event and allow + wrapping the returned instance with a decorator. + + + The following example shows the creation of two different InstanceProducer instances that wrap + the same Registration instance. Since the Registration is created using the + Singleton lifestyle, both producers will return + the same instance. The InstanceProducer for the Interface1 however, will wrap that + instance in a (transient) Interface1Decorator. + (container); + + var producer1 = new InstanceProducer(typeof(Interface1), registration); + var producer2 = new InstanceProducer(typeof(Interface2), registration); + + container.RegisterDecorator(typeof(Interface1), typeof(Interface1Decorator)); + + var instance1 = (Interface1)producer1.GetInstance(); + var instance2 = (Interface2)producer2.GetInstance(); + + Assert.IsInstanceOfType(instance1, typeof(Interface1Decorator)); + Assert.IsInstanceOfType(instance2, typeof(ServiceImpl)); + + Assert.AreSame(((Interface1Decorator)instance1).DecoratedInstance, instance2); + ]]> + + + + Initializes a new instance of the class. + The service type for which this instance is created. + The . + + + Produces an instance. + An instance. Will never return null. + When the instance could not be retrieved or is null. + + + + Builds an expression that expresses the intent to get an instance by the current producer. A call + to this method locks the container. No new registrations can't be made after a call to this method. + + An Expression. + + + + Gets the collection of relationships for this instance that the container knows about. + This includes relationships between the registered type and its dependencies and relationships + between applied decorators and their dependencies. Note that types that are not newed up by the + container, property dependencies that are injected using the (legacy) + InjectProperties method, and + properties that are injected inside a custom delegate that is registered using the + RegisterInitializer method are unknown + to the container and are not returned from this method. + Also note that this method will return an empty collection when called before the the + registered type is requested from the container (or before Verify + is called). + + An array of instances. + + + + Builds a string representation of the object graph with the current instance as root of the + graph. + + A string representation of the object graph. + Thrown when this method is called before + or have been called. These calls can be + done directly and explicitly by the user on this instance, indirectly by calling + or on an instance that depends on this + instance, or by calling Verify on the container. + + + + Gets the for this registration. The returned lifestyle can differ from the + lifestyle that is used during the registration. This can happen for instance when the registration + is changed by an ExpressionBuilt registration or + gets decorated. + + The for this registration. + + + Gets the service type for which this producer produces instances. + A instance. + + + Gets the instance for this instance. + The . + + + Internal helper for string resources. + + + + Provides data for and interaction with the + ResolveUnregisteredType event of + the . An observer can check the + to see whether the unregistered type can be handled. The + method can be called to register a delegate + that allows creation of instances of the unregistered for this and future requests. + + + + Initializes a new instance of the UnregisteredTypeEventArgs class. + The unregistered service type. + + + + Registers a delegate that allows creation of instances of the type + expressed by the for this and future requests. The delegate + will be caches and future requests will directly call that delegate. + + The delegate that allows creation of instances of the type + expressed by the . + Thrown when the is a + null reference. + Thrown when multiple observers that have registered to + the ResolveUnregisteredType event + called this method for the same type. + + + + Registers an that describes the creation of instances of the type + expressed by the for this and future requests. The delegate + will be cached and future requests will directly use that expression or the compiled delegate. + + + NOTE: If possible, use the Register(Registration) overload, + since this allows the analysis services to determine any configuration errors on the lifestyle of + the registration. + + The expression that describes the creation of instances of the type + expressed by the . + Thrown when the is a + null reference. + Thrown when multiple observers that have registered to + the ResolveUnregisteredType event + called this method for the same type. + + + + Registers a that describes the creation of instances of the type + expressed by the for this and future requests. The + registration will be cached and future requests will directly call unon that registration, the + expression that it generates or the delegate that gets compiled from that expression. + + The registration that describes the creation of instances according to + the registration's lifestyle of the type expressed by the . + Thrown when the is a + null reference. + Thrown when the is a + not exactly of type where T equals the . + + Thrown when multiple observers that have registered to + the ResolveUnregisteredType event + called this method for the same type. + + + Gets the unregistered service type that is currently requested. + The unregistered service type that is currently requested. + + + + Gets a value indicating whether the event represented by this instance has been handled. + This property will return true when has been called on + this instance. + + The indication whether the event has been handled. + + + diff --git a/packages/SimpleInjector.2.6.1/lib/net45/SimpleInjector.Diagnostics.xml b/packages/SimpleInjector.2.6.1/lib/net45/SimpleInjector.Diagnostics.xml new file mode 100644 index 0000000..254c1bd --- /dev/null +++ b/packages/SimpleInjector.2.6.1/lib/net45/SimpleInjector.Diagnostics.xml @@ -0,0 +1,193 @@ + + + + SimpleInjector.Diagnostics + + + + + Entry point for doing diagnostic analysis on instances. + + + The following example shows the usage of the Analyzer class: + + + + + + Analyzes the supplied instance. + + The container instance to analyze. + A collection of sub types that describe the diagnostic + warnings and messages. + + + + Diagnostic result for a warning about a concrete type that was not registered explicitly and was not + resolved using unregistered type resolution, but was created by the container using the transient + lifestyle. + For more information, see: https://simpleinjector.org/diaut. + + + + + Base class for types that hold information about a single diagnostic message or warning for a + particular type or part of the configuration. + + + + Gets the diagnostic type of this result. + The . + + + Gets the service type to which this warning is related. + A . + + + Gets the description of the diagnostic result. + A with the description. + + + Gets the hierarchical group to which this diagnostic result belongs. + The . + + + Gets a collection of instances that describe all + container-registered dependencies for the given component. + List of objects. + + + + A hierarchical group of . + + + + + Gets the base that describes the service types of its + . The value often be either (in case this is a + root group) or a partial generic type to allow hierarchical grouping of a large number of related + generic types. + + The . + + + Gets the friendly name of the group. + The name. + + + Gets the description of the group. + The description. + + + Gets the diagnostic type of all grouped instances. + The . + + + Gets the parent or null (Nothing in VB) when this is the + root group. + The . + + + Gets the collection of child s. + A collection of elements. + + + Gets the collection of instances. + /// A collection of elements. + + + + Specifies the list of diagnostic types that are currently supported by the diagnostic + . Note that new diagnostic types might be added in future versions. + For more information, please read the + Diagnosing your configuration using the Diagnostic + Services wiki documentation. + + + + + Diagnostic type that warns about + a concrete type that was not registered explicitly and was not resolved using unregistered type + resolution, but was created by the container using the transient lifestyle. + For more information, see: https://simpleinjector.org/diaut. + + + + + Diagnostic type that warns when a + component depends on a service with a lifestyle that is shorter than that of the component. + For more information, see: https://simpleinjector.org/dialm. + + + + + Diagnostic type that warns when a + component depends on an unregistered concrete type and this concrete type has a lifestyle that is + different than the lifestyle of an explicitly registered type that uses this concrete type as its + implementation. + For more information, see: https://simpleinjector.org/diasc. + + + + + Diagnostic type that warns when a + component depends on (too) many services. + For more information, see: https://simpleinjector.org/diasr. + + + + + Diagnostic result for a warning about a + component that depends on a service with a lifestyle that is shorter than that of the component. + For more information, see: https://simpleinjector.codeplex.com/wikipage?title=PotentialLifestyleMismatches. + + + + Gets the object that describes the relationship between the component and its dependency. + A instance. + + + + Diagnostic result that warns about a + component that depends on an unregistered concrete type and this concrete type has a lifestyle that is + different than the lifestyle of an explicitly registered type that uses this concrete type as its + implementation. + For more information, see: https://simpleinjector.codeplex.com/wikipage?title=ShortCircuitedDependencies. + + + + Gets the instance that describes the current relationship between the checked component + and the short-circuited dependency. + The . + + + + Gets the collection of registrations that have the component's current dependency as + implementation type, but have a lifestyle that is different than the current dependency. + + A collection of instances. + + + + Diagnostic result that warns about a component that depends on (too) many services. + For more information, see: https://simpleinjector.codeplex.com/wikipage?title=PotentialSingleResponsibilityViolations. + + + + Gets the created type. + A . + + + Gets the list of registrations that are dependencies of the . + A collection of instances. + + + diff --git a/packages/SimpleInjector.2.6.1/lib/net45/SimpleInjector.xml b/packages/SimpleInjector.2.6.1/lib/net45/SimpleInjector.xml new file mode 100644 index 0000000..18de2a3 --- /dev/null +++ b/packages/SimpleInjector.2.6.1/lib/net45/SimpleInjector.xml @@ -0,0 +1,4583 @@ + + + + SimpleInjector + + + + + The standard exception thrown when a container has an error in resolving an object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error + message. + + The message that describes the error. + + + + Initializes a new instance of the class with a specified error + message and a reference to the inner exception that is the cause of this exception. + + + The error message that explains the reason for the exception. + + + The exception that is the cause of the current exception, or a null reference (Nothing in Visual + Basic) if no inner exception is specified. + + + + + Initializes a new instance of the class with serialized data. + + + The that holds the serialized object data about the exception + being thrown. + + + The that contains contextual information about the source or + destination. + + + The parameter is null. + + + The class name is null or hresult is zero (0). + + + + + Extension methods for enable advanced scenarios. + + + + + Determines whether the specified container is locked making any new registrations. The container + is automatically locked when GetInstance is called for the + first time. + + The container. + + true if the specified container is locked; otherwise, false. + + Thrown when is null. + + + Determines whether the specified container is currently verifying its configuration. + The container. + true if the specified container is verifying; otherwise, false. + Thrown when is null. + + + + Builds up an delegate wrapping all delegates that + are registered using RegisterInitializer and + that apply to the given (including delegates that are registered + for interfaces implements and base types that + inherits from). Null will be returned when no delegates are + registered that apply to this type. + + The container. + + This method has a performance caracteristic of O(n). Prevent from calling this in a performance + critical path of the application. + + The type for with an initializer must be built. + An delegate or null. + + + + Retrieves an item from the container stored by the given or null when no + item is stored by that key. + + + Thread-safety: Calls to this method are thread-safe, but users should take proper + percausions when they call both GetItem and . + + The container. + The key of the item to retrieve. + The stored item or null (Nothing in VB). + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + + Stores an item by the given in the container. + + + Thread-safety: Calls to this method are thread-safe, but users should take proper + percausions when they call both and SetItem. + + The container. + The key of the item to insert or override. + The actual item. May be null. + Thrown when either or + is a null reference (Nothing in VB). + + + + Allows appending new registrations to existing registrations made using one of the + RegisterAll overloads. + + The container. + The service type of the collection. + The registration to append. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + Thrown when the is not a + reference type, is open generic, or ambiguous. + Thrown when the container is locked. + Thrown when the method is called for a registration + that is made with one of the RegisterAll overloads that accepts a dynamic collection + (an IEnumerable or IEnumerable<TService>). + + + + Defines the container's behavior for building an expression tree based on the supplied constructor of + a given type. + Set the ConstructorInjectionBehavior + property of the container's property to change the default behavior + of the container. + + + + + Builds an for the supplied , based on the + container's configuration. + + The parameter. + An that describes the intend of creating that + . This method never returns null. + + + + Defines the container's behavior for finding a suitable constructor for the creation of a type. + Set the ConstructorResolutionBehavior + property of the container's property to change the default behavior + of the container. + + + + + Gets the given 's constructor that can be used by the + container to create that instance. + + Type of the abstraction that is requested. + Type of the implementation to find a suitable constructor for. + + The . This method never returns null. + + Thrown when no suitable constructor could be found. + + + + Defines the container's behavior for verifying the constructor that will be picked by the + . + Set the ConstructorVerificationBehavior + property of the container's property to change the default behavior + of the container. + + + + Verifies the specified . + The parameter. + Thrown when the cannot be + used for auto wiring. + + Thrown when the is a + null reference. + + + + Defines the container's behavior for selecting the lifestyle for a registration in case no lifestyle + is explicitly supplied. + Set the LifestyleSelectionBehavior + property of the container's property to change the default behavior + of the container. By default, when no lifestyle is explicitly supplied, the + Transient lifestyle is used. + + + + Selects the lifestyle based on the supplied type information. + Type of the abstraction that is registered. + Type of the implementation to that is registered. + The suited for the given type. + Thrown when either one of the arguments is a null reference. + + + + Defines the container's behavior for selecting properties to inject during the creation of a type. + Set the PropertySelectionBehavior + property of the container's property to change the default behavior + of the container. By default, no properties will be injected by the container. + + + + + Determines whether a property should be injected by the container upon creation of its type. + + Type of the abstraction that is requested. + The property to check. + True when the property should be injected. + + + + An instance of this type will be supplied to the + delegate that is that is supplied to the + RegisterInitializer + overload that takes this delegate. This type contains contextual information about the creation and it + allows the user to examine the given instance to decide whether the instance should be initialized or + not. + + + + + Gets the that is responsible for the initialization of the created + instance. + + The or null (Nothing in VB) when the instance producer is + unknown. + + + + Gets the that is responsible for the initialization of the created + instance. + + /// The . + + + + Contains data that can be used to initialize a created instance. This data includes the actual + created and the information about the created instance. + + + + Returns the hash code for this instance. + A 32-bit signed integer that is the hash code for this instance. + + + Indicates whether this instance and a specified object are equal. + Another object to compare to. + True if the current object is equal to the other parameter; otherwise, false. + + + + Indicates whether the current object is equal to another object of the same type. + + An object to compare with this object. + True if the current object is equal to the other parameter; otherwise, false. + + + + Indicates whether the values of two specified objects are equal. + + The first object to compare. + The second object to compare. + True if a and b are equal; otherwise, false. + + + + Indicates whether the values of two specified objects are + not equal. + + The first object to compare. + The second object to compare. + True if a and b are not equal; otherwise, false. + + + Gets the with contextual information about the + created instance. + The . + + + Gets the created instance. + The created instance. + + + + This is an internal type. Only depend on this type when you want to be absolutely sure a future + version of the framework will break your code. + + + + Initializes a new instance of the struct. + The scope factory. + The container. + + + Gets the lazily initialized Scope of the current LazyScope instance. + The current Scope or null. + + + + This is an internal type. Only depend on this type when you want to be absolutely sure a future + version of the framework will break your code. + + Service type. + Implementation type. + + + + Initializes a new instance of the + struct. + The registration. + + + Gets the lazily initialized instance for the of the current LazyScopedRegistration. + The scope that is used to retrieve the instance. + The cached instance. + + + + The container. Create an instance of this type for registration of dependencies. + + + + Thread-safety: + Resolving instances can be done safely from multiple threads concurrently, but registration needs to + be done from one single thread. + + + It is therefore safe to call , , + GetService, and + and anything related to resolving instances from multiple thread + concurrently. It is however unsafe to call + RegisterXXX, + , , , + or anything related to registering from multiple threads concurrently. + + + + + + Registers that a new instance of will be returned every time it + is requested (transient). + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The concrete type that will be registered. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + Thrown when the is a type + that can not be created by the container. + + + + Registers that an instance of will be returned when it + is requested. The instance is cached according to the supplied . + + The concrete type that will be registered. + The lifestyle that specifies how the returned instance will be cached. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + Thrown when the is a type + that can not be created by the container. + + + + Registers that a new instance of will be returned every time a + is requested (transient). + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + Thrown when the given + type is not a type that can be created by the container. + + + + + Registers the specified delegate that allows returning transient instances of + . The delegate is expected to always return a new instance on + each call. + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The interface or base type that can be used to retrieve instances. + The delegate that allows building or creating new instances. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + + Thrown when is a null reference. + + + + Registers that a new instance of will be returned every time it + is requested (transient). + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The concrete type that will be registered. + Thrown when is a null + references (Nothing in VB). + Thrown when represents an + open generic type or is a type that can not be created by the container. + + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers that a new instance of will be returned every time a + is requested. If and + represent the same type, the type is registered by itself. + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The base type or interface to register. + The actual type that will be returned when requested. + Thrown when or + are null references (Nothing in VB). + Thrown when is + no sub type from (or the same type), or one of them represents an + open generic type. + + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers the specified delegate that allows returning instances of . + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The base type or interface to register. + The delegate that will be used for creating new instances. + Thrown when either or + are null references (Nothing in VB). + Thrown when represents an + open generic type. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers a single concrete instance that will be constructed using constructor injection and will + be returned when this instance is requested by type . + This must be thread-safe when working in a multi-threaded + environment. + + The concrete type that will be registered. + + Thrown when this container instance is locked and can not be altered, or when + has already been registered. + + Thrown when the is a type + that can not be created by the container. + + + + Registers that the same a single instance of type will be + returned every time an type is requested. If + and represent the same + type, the type is registered by itself. must be thread-safe + when working in a multi-threaded environment. + + + The interface or base type that can be used to retrieve the instances. + + The concrete type that will be registered. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + Thrown when the given + type is not a type that can be created by the container. + + + + + Registers a single instance that will be returned when an instance of type + is requested. This must be thread-safe + when working in a multi-threaded environment. + + The interface or base type that can be used to retrieve the instance. + The instance to register. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + + Thrown when is a null reference. + + + + + Registers the specified delegate that allows constructing a single instance of + . This delegate will be called at most once during the lifetime of + the application. The returned instance must be thread-safe when working in a multi-threaded + environment. + + The interface or base type that can be used to retrieve instances. + The delegate that allows building or creating this single + instance. + + Thrown when this container instance is locked and can not be altered, or when a + for has already been registered. + + Thrown when is a + null reference. + + + + Registers that the same instance of type will be returned every + time an instance of type type is requested. If + and represent the same type, the + type is registered by itself. must be thread-safe when working + in a multi-threaded environment. + + The base type or interface to register. + The actual type that will be returned when requested. + Thrown when either or + are null references (Nothing in VB). + Thrown when is + no sub type from , or when one of them represents an open generic + type. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers the specified delegate that allows constructing a single + instance. The container will call this delegate at most once during the lifetime of the application. + + The base type or interface to register. + The delegate that will be used for creating that single instance. + Thrown when represents an open + generic type. + Thrown when either or + are null references (Nothing in + VB). + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers a single instance that will be returned when an instance of type + is requested. This must be thread-safe + when working in a multi-threaded environment. + + The base type or interface to register. + The instance to register. + Thrown when either or + are null references (Nothing in VB). + Thrown when is + no sub type from . + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers that an instance of will be returned when an + instance of type is requested. The instance is cached according to + the supplied . + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The lifestyle that specifies how the returned instance will be cached. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + Thrown when the given + type is not a type that can be created by the container. + + + + + Registers the specified delegate that will produce instances of + type and will be returned when an instance of type + is requested. The delegate is expected to produce new instances on + each call. The instances are cached according to the supplied . + + The interface or base type that can be used to retrieve instances. + The delegate that allows building or creating new instances. + The lifestyle that specifies how the returned instance will be cached. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + + Thrown when one of the supplied arguments is a null reference (Nothing in VB). + + + + Registers that an instance of type will be returned when an + instance of type is requested. The instance is cached according to + the supplied . + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The lifestyle that specifies how the returned instance will be cached. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + Thrown when the given + type is not a type that can be created by the container, when either + or are open generic types, or when + is not assignable from the . + + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + + Registers the specified delegate that will produce instances of + type and will be returned when an instance of type + is requested. The delegate is expected to produce new instances on + each call. The instances are cached according to the supplied . + + The interface or base type that can be used to retrieve instances. + The delegate that allows building or creating new instances. + The lifestyle that specifies how the returned instance will be cached. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + + Thrown when one of the supplied arguments is a null reference (Nothing in VB). + + + + Registers an delegate that runs after the creation of instances that + implement or derive from the given . Please note that only instances + that are created by the container (using constructor injection) can be initialized this way. + + The type for which the initializer will be registered. + The delegate that will be called after the instance has been + constructed and before it is returned. + + Thrown when the is a null reference. + + + Thrown when this container instance is locked and can not be altered. + + + Multiple delegates can be registered per + and multiple initializers can be applied on a created instance, + before it is returned. For instance, when registering a + for type , the delegate will be called for every instance created by + the container, which can be nice for debugging purposes. + + + Note: Initializers are guaranteed to be executed in the order they are registered. + + + The following example shows the usage of the + RegisterInitializer method: + + (); + + // Configuring property injection for types that implement ICommand: + container.RegisterInitializer(command => + { + command.SendAsync = true; + }); + + // Configuring property injection for types that implement CommandBase: + container.RegisterInitializer(command => + { + command.Clock = container.GetInstance(); + }); + + // Act + var command = (ConcreteCommand)container.GetInstance(); + + // Assert + // Because ConcreteCommand implements both ICommand and CommandBase, + // both the initializers will have been executed. + Assert.IsTrue(command.SendAsync); + Assert.IsNotNull(command.Clock); + } + ]]> + + The container does not use the type information of the requested service type, but it uses the + type information of the actual implementation to find all initialized that apply for that + type. This makes it possible to have multiple initializers to be applied on a single returned + instance while keeping performance high. + + + Registered initializers will only be applied to instances that are created by the container self + (using constructor injection). Types that are newed up manually by supplying a + delegate to the container (using the + and + methods) or registered as single instance + (using ) will not trigger initialization. + When initialization of these instances is needed, this must be done manually, as can be seen in + the following example: + commandInitializer = command => + { + initializerCallCount++; + }); + + // Configuring that initializer. + container.RegisterInitializer(commandInitializer); + + container.Register(() => + { + // Create a ConcreteCommand manually: will not be initialized. + var command = new ConcreteCommand("Data Source=.;Initial Catalog=db;"); + + // Run the initializer manually. + commandInitializer(command); + + return command; + }); + + // Act + var command = container.GetInstance(); + + // Assert + // The initializer will only be called once. + Assert.AreEqual(1, initializerCallCount); + } + ]]> + The previous example shows how a manually created instance can still be initialized. Try to + prevent creating types manually, by changing the design of those classes. If possible, create a + single public constructor that only contains dependencies that can be resolved. + + + + + + Registers an delegate that runs after the + creation of instances for which the supplied returns true. Please + note that only instances that are created by the container can be initialized this way. + + The delegate that will be called after the instance has been + constructed and before it is returned. + The predicate that will be used to check whether the given delegate must + be applied to a registration or not. The given predicate will be called once for each registration + in the container. + + Thrown when either the or are + null references. + + + Thrown when this container instance is locked and can not be altered. + + + Note: Initializers are guaranteed to be executed in the order they are registered. + + + Note: The is not guaranteed to be called once per registration; + when a registration's instance is requested for the first time simultaneously over multiple thread, + the predicate might be called multiple times. The caller of this method is responsible of supplying + a predicate that is thread-safe. + + + + + + Registers a dynamic (container uncontrolled) collection of elements of type + . A call to will return the + itself, and updates to the collection will be reflected in the + result. If updates are allowed, make sure the collection can be iterated safely if you're running + a multi-threaded application. + + The interface or base type that can be used to retrieve instances. + The collection to register. + + Thrown when this container instance is locked and can not be altered, or when a + for has already been registered. + + Thrown when is a null + reference. + + + + Registers a collection of singleton elements of type . + + The interface or base type that can be used to retrieve instances. + The collection to register. + + Thrown when this container instance is locked and can not be altered, or when a + for has already been registered. + + Thrown when is a null + reference. + Thrown when one of the elements of + is a null reference. + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, a generic type definition, or the is + not assignable from one of the given elements. + + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, a generic type definition, or the is + not assignable from one of the given elements. + + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, a generic type definition, or the is + not assignable from one of the given elements. + + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, the is a generic type definition, or when + is + not assignable from one of the given elements. + + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, the is a generic type definition, or when + is + not assignable from one of the given elements. + + + + + Registers a dynamic (container uncontrolled) collection of elements of type + . A call to will return the + itself, and updates to the collection will be reflected in the + result. If updates are allowed, make sure the collection can be iterated safely if you're running + a multi-threaded application. + + The base type or interface for elements in the collection. + The collection of items to register. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + Thrown when represents an + open generic type. + + + + Verifies the Container. This method will call all registered delegates, + iterate registered collections and throws an exception if there was an error. + + Thrown when the registration of instances was + invalid. + + + + Adds the for the supplied . This + method can be used to apply the same to multiple different service + types. + + The base type or interface to register. + The registration that should be stored for the given + . + + (container); + + container.AddRegistration(typeof(IFoo), registration); + container.AddRegistration(typeof(IBar), registration); + + // Act + IFoo foo = container.GetInstance(); + IBar bar = container.GetInstance(); + + // Assert + bool fooAndBareAreTheSameInstance = object.ReferenceEquals(foo, bar); + Assert.IsTrue(fooAndBareAreTheSameInstance); + } + ]]> + + In the example above a singleton registration is created for type FooBar and this + registration is added to the container for each interface (IFoo and IBar) that it + implements. Since both services use the same singleton registration, requesting those services + will result in the return of the same (singleton) instance. + + + events are applied to the of the + instance and are therefore applied once. + events on the other hand get applied to the Expression of the . + Since each AddRegistration gets its own instance producer (that wraps the + Registration instance), this means that the ExpressionBuilt events will be + applied for each registered service type. + + + The most practical example of this is the use of decorators using one of the + RegisterDecorator overloads + (decorator registration use the + ExpressionBuilt event under the covers). Take a look at the following example: + + (container); + + container.AddRegistration(typeof(IFoo), registration); + container.AddRegistration(typeof(IBar), registration); + + // Registere a decorator for IBar, but not for IFoo + container.RegisterDecorator(typeof(IBar), typeof(BarDecorator)); + + // Act + var foo = container.GetInstance(); + var decorator = container.GetInstance() as BarDecorator; + var bar = decorator.DecoratedBar; + + // Assert + bool fooAndBareAreTheSameInstance = object.ReferenceEquals(foo, bar); + Assert.IsTrue(fooAndBareAreTheSameInstance); + } + ]]> + The example shows that the decorator gets applied to IBar but not to IFoo, but that + the decorated IBar is still the same instance as the resolved IFoo instance. + + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + Thrown when is not a reference + type, is open generic, is ambiguous, when it is not assignable from the + 's ImplementationType + or when the supplied is created for a different + instance. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + Gets an instance of the given . + Type of object requested. + The requested service instance. + Thrown when there are errors resolving the service instance. + + + Gets an instance of the given . + Type of object requested. + The requested service instance. + Thrown when there are errors resolving the service instance. + + + + Gets all instances of the given currently registered in the container. + + Type of object requested. + A sequence of instances of the requested TService. + Thrown when there are errors resolving the service instance. + + + + Gets all instances of the given currently registered in the container. + + Type of object requested. + A sequence of instances of the requested serviceType. + Thrown when there are errors resolving the service instance. + + + Gets the service object of the specified type. + An object that specifies the type of service object to get. + A service object of type serviceType. -or- null if there is no service object of type + . + + + + Gets the for the given . When no + registration exists, the container will try creating a new producer. A producer can be created + when the type is a concrete reference type, there is an + event registered that acts on that type, or when the service type is an . + Otherwise null (Nothing in VB) is returned. + + + + A call to this method locks the container. No new registrations can't be made after a call to this + method. + + + Note: This method is not guaranteed to always return the same + instance for a given . It will however either + always return null or always return a producer that is able to return the expected instance. + + + The that the returned instance producer should produce. + An or null (Nothing in VB). + + + + Gets the for the given . When no + registration exists, the container will try creating a new producer. A producer can be created + when the type is a concrete reference type, there is an + event registered that acts on that type, or when the service type is an . + Otherwise null (Nothing in VB) is returned, or an exception is throw when + is set to true. + + + + A call to this method locks the container. No new registrations can't be made after a call to this + method. + + + Note: This method is not guaranteed to always return the same + instance for a given . It will however either + always return null or always return a producer that is able to return the expected instance. + + + The that the returned instance producer should produce. + The indication whether the method should return null or throw + an exception when the type is not registered. + An or null (Nothing in VB). + + + + Injects all public writable properties of the given that have a type + that can be resolved by this container instance. + NOTE: This method will be removed in a future release. To use property injection, + implement a custom the instead. For more information, + read the + extendibility points wiki. + + The instance whose properties will be injected. + + Thrown when the is null (Nothing in VB). + Throw when injecting properties on the given instance + failed due to security constraints of the sandbox. This can happen when injecting properties + on an internal type in a Silverlight sandbox, or when running in partial trust. + + + Initializes a new instance of the class. + + + Initializes a new instance of the class. + The container options. + Thrown when the is a null + reference. + Thrown when supplied is an instance + that already is supplied to another instance. Every container must get + its own instance. + + + + Returns an array with the current registrations. This list contains all explicitly registered + types, and all implicitly registered instances. Implicit registrations are all concrete + unregistered types that have been requested, all types that have been resolved using + unregistered type resolution (using the event), and + requested unregistered collections. Note that the result of this method may change over time, + because of these implicit registrations. + + + + This method has a performance characteristic of O(n). Prevent from calling this in a performance + critical path of the application. + + + Note: This method is not guaranteed to always return the same + instance for a given registration. It will however either + always return a producer that is able to return the expected instance. Because of this, do not + compare sets of instances returned by different calls to + by reference. The way of comparing lists is by the actual type. The type of each instance is + guaranteed to be unique in the returned list. + + + An array of instances. + + + + Returns an array with the current registrations for root objects. Root objects are registrations + that are in the root of the object graph, meaning that no other registration is depending on it. + + + + This method has a performance characteristic of O(n). Prevent from calling this in a performance + critical path of the application. + + + This list contains the root objects of all explicitly registered types, and all implicitly + registered instances. Implicit registrations are all concrete unregistered types that have been + requested, all types that have been resolved using unregistered type resolution (using the + event), and requested unregistered collections. Note that + the result of this method may change over time, because of these implicit registrations. + + + Note: This method is not guaranteed to always return the same + instance for a given registration. It will however either + always return a producer that is able to return the expected instance. Because of this, do not + compare sets of instances returned by different calls to + by reference. The way of comparing lists is by the actual type. The type of each instance is + guaranteed to be unique in the returned list. + + + An array of instances. + Thrown when this method is called before + has been successfully called. + + + Determines whether the specified System.Object is equal to the current System.Object. + + The System.Object to compare with the current System.Object. + + True if the specified System.Object is equal to the current System.Object; otherwise, false. + + + + Returns the hash code of the current instance. + The hash code of the current instance. + + + + Returns a that represents the . + + + A that represents the . + + + + Gets the of the current instance. + The instance that represents the exact runtime + type of the current instance. + + + Prevents any new registrations to be made to the container. + + + + Occurs when an instance of a type is requested that has not been registered explicitly, allowing + resolution of unregistered types before the container tries to create the type. + + + + The event is called by the container every time an + unregistered type is requested for the first time, allowing a developer to do unregistered type + resolution. By calling the + Register method on the + , a , or + delegate can be registered allowing the container to retrieve + instances of the requested type. This registration is cached and it prevents the + ResolveUnregisteredType event from being called again for the same type. + + + When no registered event handled the registration of an unregistered type, the container will try + to create the type when this type is either concrete or is the + interface. Concrete types will be registered with the Transient + lifestyle and registrations will return an empty collection. When no + even handled the registration and the container could not create it, an exception is thrown. + + + Thread-safety: Please note that the container will not ensure that the hooked delegates + are executed only once. While the calls to for a given type + are finite (and will in most cases happen just once), a container can call the delegate multiple + times and make parallel calls to the delegate. You must make sure that the code can be called + multiple times and is thread-safe. + + + + The following example shows the usage of the event: + + { + void Validate(T instance); + } + + // Implementation of the null object pattern. + public class EmptyValidator : IValidator + { + public void Validate(T instance) + { + // Does nothing. + } + } + + [TestMethod] + public void TestResolveUnregisteredType() + { + // Arrange + var container = new Container(); + + // Register an EmptyValidator to be returned when a IValidator is requested: + container.ResolveUnregisteredType += (sender, e) => + { + if (e.UnregisteredServiceType.IsGenericType && + e.UnregisteredServiceType.GetGenericTypeDefinition() == typeof(IValidator<>)) + { + var validatorType = typeof(EmptyValidator<>).MakeGenericType( + e.UnregisteredServiceType.GetGenericArguments()); + + object emptyValidator = container.GetInstance(validatorType); + + // Register the instance as singleton. + e.Register(() => emptyValidator); + } + }; + + // Act + var orderValidator = container.GetInstance>(); + var customerValidator = container.GetInstance>(); + + // Assert + Assert.IsInstanceOfType(orderValidator, typeof(EmptyValidator)); + Assert.IsInstanceOfType(customerValidator, typeof(EmptyValidator)); + } + ]]> + + The example above registers a delegate that is raised every time an unregistered type is requested + from the container. The delegate checks whether the requested type is a closed generic + implementation of the IValidator<T> interface (such as + IValidator<Order> or IValidator<Customer>). In that case it + will request the container for a concrete EmptyValidator<T> implementation that + implements the given + UnregisteredServiceType, and + registers a delegate that will return this created instance. The e.Register call + registers the method in the container, preventing the from + being called again for the exact same service type, preventing any performance penalties. + + + Please note that given example is just an uhhmm... example. In the case of the example the + EmptyValidator<T> can be better registered using of the built-in + RegisterOpenGeneric + extension methods instead. These extension methods take care of any given generic type constraint + and allow the implementation to be integrated into the container's pipeline, which allows + it to be intercepted using the event and allow any registered + initializers to be applied. + + + + + + Occurs after the creation of the of a registered type is complete (the + lifestyle has been applied), allowing the created to be wrapped, + changed, or replaced. Multiple delegates may handle the same service type. + + + + The ExpressionBuilt event is called by the container every time an registered type is + getting compiled, allowing a developer to change the way the type is created. The delegate that + hooks to the ExpressionBuilt event, can change the + property on the + , which allows changing the way the type is constructed. + + + Thread-safety: Please note that the container will not ensure that the hooked delegates + are executed only once per service type. While the calls to for a + given type are finite (and will in most cases happen just once), a container can call the delegate + multiple times and make parallel calls to the delegate. You must make sure that the code can be + called multiple times and is thread-safe. + + + + The following example shows the usage of the ExpressionBuilt event: + + { + void Validate(T instance); + } + + public interface ILogger + { + void Write(string message); + } + + // Implementation of the decorator pattern. + public class MonitoringValidator : IValidator + { + private readonly IValidator validator; + private readonly ILogger logger; + + public MonitoringValidator(IValidator validator, ILogger logger) + { + this.validator = validator; + this.logger = logger; + } + + public void Validate(T instance) + { + this.logger.Write("Validating " + typeof(T).Name); + this.validator.Validate(instance); + this.logger.Write("Validated " + typeof(T).Name); + } + } + + [TestMethod] + public void TestExpressionBuilt() + { + // Arrange + var container = new Container(); + + container.RegisterSingle(); + container.Register, OrderValidator>(); + container.Register, CustomerValidator>(); + + // Intercept the creation of IValidator instances and wrap them in a MonitoringValidator: + container.ExpressionBuilt += (sender, e) => + { + if (e.RegisteredServiceType.IsGenericType && + e.RegisteredServiceType.GetGenericTypeDefinition() == typeof(IValidator<>)) + { + var decoratorType = typeof(MonitoringValidator<>) + .MakeGenericType(e.RegisteredServiceType.GetGenericArguments()); + + // Wrap the IValidator in a MonitoringValidator. + e.Expression = Expression.New(decoratorType.GetConstructors()[0], new Expression[] + { + e.Expression, + container.GetRegistration(typeof(ILogger)).BuildExpression(), + }); + } + }; + + // Act + var orderValidator = container.GetInstance>(); + var customerValidator = container.GetInstance>(); + + // Assert + Assert.IsInstanceOfType(orderValidator, typeof(MonitoringValidator)); + Assert.IsInstanceOfType(customerValidator, typeof(MonitoringValidator)); + } + ]]> + + The example above registers a delegate that is raised every time the container compiles the + expression for an registered type. The delegate checks whether the requested type is a closed generic + implementation of the IValidator<T> interface (such as + IValidator<Order> or IValidator<Customer>). In that case it + will changes the current with a new one that creates + a new MonitoringValidator<T> that takes the current validator (and an ILogger) + as an dependency. + + + Please note that given example is just an uhhmm... example. In the case of the example the + MonitoringValidator<T> is a decorator and instead of manually writing this code that + many limitations, you can use one of the built-in + RegisterDecorator extension methods instead. + These extension methods take care of any given generic type constraint, allow to register decorators + conditionally and allow the decorator to be integrated into the container's pipeline, which allows + it to be intercepted using the event and allow any registered + initializers to be applied. + + + + + + Occurs directly after the creation of the of a registered type is made, + but before any initializer and lifestyle specific caching + has been applied, allowing the created to be altered. Multiple delegates + may handle the same service type. + + + + The ExpressionBuilding event is called by the container every time an registered type is + getting compiled, allowing a developer to change the way the type is created. The delegate that + hooks to the ExpressionBuilding event, can change the + property on the + , which allows changing the way the type is constructed. + + + The exact type supplied depends on the type of registration. + Registrations that explicitly supply the implementation type (such as + Register<TService, TImplementation>()) + will result in an , while registrations that take a delegate (such as + Register<TService>(Func<TService>)) + will result in an . Singletons that are passed in using their + value (RegisterSingle<TService>(TService)) + will result in an . Note that other ExpressionBuilding + registrations might have changed the + property and might have supplied an of a different type. The order in + which these events are registered might be of importance to you. + + + Thread-safety: Please note that the container will not ensure that the hooked delegates + are executed only once per service type. While the calls to registered ExpressionBuilding + events for a given type are finite (and will in most cases happen just once), a container can + call the delegate multiple times and make parallel calls to the delegate. You must make sure that + the code can be called multiple times and is thread-safe. + + + + The following example shows the usage of the ExpressionBuilding event: + + { + var expression = e.Expression as NewExpression; + + if (expression != null) + { + var propertiesToInject = + from property in expression.Constructor.DeclaringType.GetProperties() + where property.GetCustomAttributes(typeof(MyInjectPropertyAttribute), true).Any() + let registration = container.GetRegistration(property.PropertyType, true) + select Tuple.Create(property, registration); + + if (propertiesToInject.Any()) + { + Func[], object> injectorDelegate = + (instance, dependencies) => + { + foreach (var dependency in dependencies) + { + dependency.Item1.SetValue(instance, dependency.Item2.GetInstance(), null); + } + + return instance; + }; + + e.Expression = Expression.Convert( + Expression.Invoke( + Expression.Constant(injectorDelegate), + e.Expression, + Expression.Constant(propertiesToInject.ToArray())), + expression.Constructor.DeclaringType); + } + } + }; + } + ]]> + + The example above registers a delegate that is raised every time the container compiles the + expression for an registered type. The delegate checks if the type contains properties that are + decorated with the supplied MyInjectPropertyAttribute. If decorated properties are found, + the given expression is replaced with an expression that injects decorated properties. + + + The example differs from the container's built-in method in that + it will fail when one of the decorated properties can not be injected. The built-in + will look at all properties of a given class and will simply skip + over any properties that can not be injected, making the use of the + method often verify fragile and error prone. + + + + + Gets the container options. + The instance for this container. + + + + Gets the intermediate lifestyle that forwards CreateRegistration calls to the lifestyle that is + returned from the registered container.Options.LifestyleSelectionBehavior. + + + + Implements a cache for implementations. + + is thread-safe can be used over multiple threads concurrently. + + + + + Allows registering an delegate that will be called when the scope ends, + but before the scope disposes any instances. + + + During the call to all registered delegates are + processed in the order of registration. Do note that registered actions are not guaranteed + to run. In case an exception is thrown during the call to , the + will stop running any actions that might not have been invoked at that point. + Instances that are registered for disposal using on the other + hand, are guaranteed to be disposed. Note that registered actions won't be invoked during a call + to . + + The delegate to run when the scope ends. + Thrown when one of the arguments is a null reference + (Nothing in VB). + Thrown when the scope has been disposed. + + + + Adds the to the list of items that will get disposed when the + scope ends. + + + Instances that are registered for disposal, will be disposed in opposite order of registration and + they are guaranteed to be disposed when is called (even when + exceptions are thrown). This mimics the behavior of the C# and VB using statements, + where the method is called inside the finally block. + + The instance that should be disposed when the scope ends. + Thrown when one of the arguments is a null reference + (Nothing in VB). + Thrown when the scope has been disposed. + + + Releases all instances that are cached by the object. + + + + Releases all instances that are cached by the object. + + False when only unmanaged resources should be released. + + + Configuration options for the . + + The following example shows the typical usage of the ContainerOptions class. + (); + + // Use of ContainerOptions class here. + container.Options.AllowOverridingRegistrations = true; + + // Replaces the previous registration of ITimeProvider + container.Register(); + ]]> + + + + Initializes a new instance of the class. + + + + Gets or sets a value indicating whether the container allows overriding registrations. The default + is false. + + The value indicating whether the container allows overriding registrations. + + + + Gets or sets the constructor resolution behavior. By default, the container only supports types + that have a single public constructor. + + The constructor resolution behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + + Gets or sets the constructor verification behavior. The container's default behavior is to + disallow constructors with value types and strings. + + The constructor resolution behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + Gets or sets the constructor injection behavior. + The constructor injection behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + + Gets or sets the property selection behavior. The container's default behavior is to do no + property injection. + + The property selection behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + + Gets or sets the lifestyle selection behavior. The container's default behavior is to make + registrations using the lifestyle. + The lifestyle selection behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + + Gets the container to which this ContainerOptions instance belongs to or null when + this instance hasn't been applied to a yet. + + The current . + + + + Gets or sets a value indicating whether the container will use dynamic assemblies for compilation. + By default, this value is true for the first few containers that are created in an app + domain and false for all other containers. You can set this value explicitly to false + to prevent the use of dynamic assemblies or you can set this value explicitly to true to + force more container instances to use dynamic assemblies. Note that creating an infinite number + of instances (for instance one per web request) with this property set to + true will result in a memory leak; dynamic assemblies take up memory and will only be + unloaded when the AppDomain is unloaded. + + A boolean indicating whether the container should use a dynamic assembly for compilation. + + + + + Allows verifying whether a given type has a direct or indirect dependency on itself. Verifying is done + by preventing recursive calls to a IInstanceProvider. An instance of this type is related to a single + instance of a IInstanceProvider. A RecursiveDependencyValidator instance checks a single + IInstanceProvider and therefore a single service type. + + + + + Extension methods for the RecursiveDependencyValidator class. + + + + + Provides data for and interaction with the + ExpressionBuilding event of + the . An observer can change the + property to change the component that is + currently being built. + + + + Gets the registered service type that is currently requested. + The registered service type that is currently requested. + + + + Gets the type that is known to be returned by the + Expression (most often the implementation + type used in the Register call). This type will be a derivative of + RegisteredServiceType (or + or RegisteredServiceType itself). If the Expression is changed, the new expression + must also return an instance of type KnownImplementationType or a sub type. + This information must be described in the new Expression. + + A . + + + + Gets the lifestyle for the component that is currently being built. + + The . + + + Gets or sets the currently registered . + The current registration. + Thrown when the supplied value is a null reference. + + + + Gets the collection of currently known relationships. This information is used by the Diagnostics + Debug View. Change the contents of this collection to represent the changes made to the + Expression property (if any). This allows + the Diagnostics Debug View to analyze those new relationships as well. + + The collection of instances. + + + + Provides data for and interaction with the + ExpressionBuilt event of + the . An observer can change the + property to change the component that is currently + being built. + + + + Initializes a new instance of the class. + Type of the registered service. + The registered expression. + + + Gets the registered service type that is currently requested. + The registered service type that is currently requested. + + + Gets or sets the currently registered . + The current registration. + Thrown when the supplied value is a null reference. + + + Gets or sets the current lifestyle of the registration. + The original lifestyle of the registration. + + + + Gets the collection of currently known relationships. This information is used by the Diagnostics + Debug View. Change the contents of this collection to represent the changes made to the + Expression property (if any). This allows + the Diagnostics Debug View to analyze those new relationships as well. + + The collection of instances. + + + + A map containing a generic argument (such as T) and the concrete type (such as Int32) that it + represents. + + + + Implements equality. Needed for doing LINQ distinct operations. + The other to compare to. + True or false. + + + Overrides the default hash code. Needed for doing LINQ distinct operations. + An 32 bit integer. + + + + An instance of this type can be injected into constructors of decorator classes that are registered + using RegisterDecorator. This type contains + contextual information about the applied decoration and it allows users to examine the given instance + to make runtime decisions. + + + + + Gets the closed generic service type for which the decorator is about to be applied. The original + service type will be returned, even if other decorators have already been applied to this type. + + The closed generic service type. + + + + Gets the type of the implementation that is created by the container and for which the decorator + is about to be applied. The original implementation type will be returned, even if other decorators + have already been applied to this type. Please not that the implementation type can not always be + determined. In that case the closed generic service type will be returned. + + The implementation type. + + + + Gets the list of the types of decorators that have already been applied to this instance. + + The applied decorators. + + + + Gets the current object that describes the intention to create a new + instance with its currently applied decorators. + + The current expression that is about to be decorated. + + + + Extension methods for applying decorators. + + + + + Ensures that the supplied decorator is returned and cached with + the given , wrapping the original registered + , by injecting that service type into the constructor of the + supplied . Multiple decorators may be applied to the same + . Decorators can be applied to both open, closed, and non-generic + service types. + + + + The RegisterOpenGenericDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterOpenGenericDecorator on the same service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The registered may have a constructor with an argument of type + where T is . In this case, the + will not inject the decorated itself into the + instance, but it will inject a that allows + creating instances of the decorated type, according to the lifestyle of that type. This enables + more advanced scenarios, such as executing the decorated types on a different thread, or executing + decorated instance within a certain scope (such as a lifetime scope). + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + The lifestyle that specifies how the returned decorator will be cached. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or + implement , when + does not have a single public constructor, or when does + not contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that the supplied decorator is returned when the supplied + returns true and cached with the given + , wrapping the original registered , by + injecting that service type into the constructor of the supplied . + Multiple decorators may be applied to the same . Decorators can be + applied to both open, closed, and non-generic service types. + + + + The RegisterOpenGenericDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterOpenGenericDecorator on the same service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The registered may have a constructor with an argument of type + where T is . In this case, the + will not inject the decorated itself into the + instance, but it will inject a that allows + creating instances of the decorated type, according to the lifestyle of that type. This enables + more advanced scenarios, such as executing the decorated types on a different thread, or executing + decorated instance within a certain scope (such as a lifetime scope). + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + The lifestyle that specifies how the returned decorator will be cached. + The predicate that determines whether the + must be applied to a service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or + implement , when + does not have a single public constructor, or when does + not contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that the decorator type that is returned from is + supplied when the supplied returns true and cached with the given + , wrapping the original registered , by + injecting that service type into the constructor of the decorator type that is returned by the + supplied . + Multiple decorators may be applied to the same . Decorators can be + applied to both open, closed, and non-generic service types. + + + + The types returned from the may be open-generic. The + container will try to fill in the generic parameters based on the resolved service type. + + + The RegisterOpenGenericDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterOpenGenericDecorator on the same service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The type returned from may have a constructor with an + argument of type where T is . In this + case, the framework will not inject the decorated itself into the + decorator instance, but it will inject a that allows + creating instances of the decorated type, according to the lifestyle of that type. This enables + more advanced scenarios, such as executing the decorated types on a different thread, or executing + decorated instance within a certain scope (such as a lifetime scope). + + + + The following is an example of the registration of a decorator through the factory delegate: + , MoveCustomerCommandHandler>(); + + container.RegisterDecorator( + typeof(ICommandHandler<>), + context => typeof(LoggingCommandHandler<,>).MakeGenericType( + typeof(LoggingCommandHandler<,>).GetGenericArguments().First(), + context.ImplementationType), + Lifestyle.Transient, + context => true); + + var handler = container.GetInstance>(); + + Assert.IsInstanceOfType(handler, + typeof(LoggingCommandHandler)); + + ]]> + The code above allows a generic LoggingCommandHandler<TCommand, TImplementation> to + be applied to command handlers, where the second generic argument will be filled in using the + contextual information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the decorator type returned by the supplied . + A factory that allows building Type objects that define the + decorators to inject, based on the given contextual information. The delegate is allowed to return + open-generic types. + The lifestyle that specifies how the returned decorator will be cached. + The predicate that determines whether the decorator must be applied to a + service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type. + + + + Ensures that the supplied decorator is returned, wrapping the + original registered , by injecting that service type into the + constructor of the supplied . Multiple decorators may be applied + to the same . Decorators can be applied to both open, closed, and + non-generic service types. By default, a new instance will be + returned on each request (according the Transient lifestyle), + independently of the lifestyle of the wrapped service. + + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + + The RegisterDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterDecorator on the same generic service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The registered may have a constructor with an argument of type + where T is . In this case, an decorated + instance will not injected into the , but it will inject a + that allows creating instances of the decorated type, according to the + lifestyle of that type. This enables more advanced scenarios, such as executing the decorated + types on a different thread, or executing decorated instance within a certain scope (such as a + lifetime scope). + + + + The following example shows the definition of a generic ICommandHandler<T> interface, + a CustomerMovedCommandHandler implementing that interface, and a + ValidatorCommandHandlerDecorator<T> that acts as a decorator for that interface. + + { + void Handle(TCommand command); + } + + public class CustomerMovedCommand + { + [Required] + public int CustomerId { get; set; } + + [Required] + public Address Address { get; set; } + } + + public class CustomerMovedCommandHandler + : ICommandHandler + { + public void Handle(CustomerMovedCommand command) + { + // some logic + } + } + + // Decorator that validates commands before they get executed. + public class ValidatorCommandHandlerDecorator + : ICommandHandler + { + private readonly ICommandHandler decoratedHandler; + private readonly Container container; + + public ValidatorCommandHandlerDecorator( + ICommandHandler decoratedHandler, + Container container) + { + this.decoratedHandler = decoratedHandler; + this.container = container; + } + + public void Handle(TCommand command) + { + this.Validate(command); + + this.decoratedHandler.Handle(command); + } + + private void Validate(TCommand command) + { + var validationContext = + new ValidationContext(command, this.container, null); + + Validator.ValidateObject(command, validationContext); + } + } + + // Decorator that measures the time it takes to execute a command. + public class MonitoringCommandHandlerDecorator + : ICommandHandler + { + private readonly ICommandHandler decoratedHandler; + private readonly ILogger logger; + + public MonitoringCommandHandlerDecorator( + ICommandHandler decoratedHandler, + ILogger logger) + { + this.decoratedHandler = decoratedHandler; + this.logger = logger; + } + + public void Handle(TCommand command) + { + var watch = Stopwatch.StartNew(); + + this.decoratedHandler.Handle(command); + + this.logger.Log(string.Format("{0} executed in {1} ms.", + command.GetType().Name, watch.ElapsedMilliseconds)); + } + } + + [TestMethod] + public static void TestRegisterOpenGenericDecorator() + { + // Arrange + var container = new Container(); + + container.RegisterSingle(); + + // Search the given assembly and register all concrete types that + // implement ICommandHandler. + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), + typeof(ICommandHandler<>).Assembly); + + // Wrap all ICommandHandler service types with a decorator + // that measures and logs the duration of that handler. + container.RegisterDecorator(typeof(ICommandHandler<>), + typeof(MonitoringCommandHandlerDecorator<>)); + + // Wrap all ICommandHandler types (in this case it will + // wrap the monitoring decorator), but only if the TCommand contains + // any properties. + container.RegisterDecorator(typeof(ICommandHandler<>), + typeof(ValidatorCommandHandlerDecorator<>), context => + { + var commandType = context.ServiceType.GetGenericArguments()[0]; + bool mustDecorate = commandType.GetProperties().Any(); + return mustDecorate; + }); + + // Act + var handler = + container.GetInstance>(); + + // Assert + Assert.IsInstanceOfType(handler, + typeof(ValidatorCommandHandlerDecorator)); + } + ]]> + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or implement + , when does not + have a single public constructor, or when does not + contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that the supplied decorator is returned when the supplied + returns true, wrapping the original registered + , by injecting that service type into the constructor of the + supplied . Multiple decorators may be applied to the same + . Decorators can be applied to both open, closed, and non-generic + service types. By default, a new instance will be returned on + each request (according the Transient lifestyle), + independently of the lifestyle of the wrapped service. + + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + + The RegisterOpenGenericDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterOpenGenericDecorator on the same service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The registered may have a constructor with an argument of type + where T is . In this case, the + will not inject the decorated itself into the + instance, but it will inject a that allows + creating instances of the decorated type, according to the lifestyle of that type. This enables + more advanced scenarios, such as executing the decorated types on a different thread, or executing + decorated instance within a certain scope (such as a lifetime scope). + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + The predicate that determines whether the + must be applied to a service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or + implement , when + does not have a single public constructor, or when does + not contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that a single instance of the supplied decorator is + returned, wrapping the original registered , by injecting that + service type into the constructor of the supplied . Multiple + decorators may be applied to the same . Decorators can be applied + to both open, closed, and non-generic service types. + + + + This method ensures that a single instance of the supplied is + returned, no matter what the lifestyle of the wrapped service type is. Use with care, because the + wrapped service type will also become a singleton. This method is especially useful when use for + injecting factory methods, which will allow the wrapped service type to get + it's own lifestyle back. + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or implement + , when does not + have a single public constructor, or when does not + contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that the supplied decorator is returned when the supplied + returns true, wrapping the original registered + , by injecting that service type into the constructor of the + supplied . Multiple decorators may be applied to the same + . Decorators can be applied to both open, closed, and non-generic + service types. + + + + This method ensures that a single instance of the supplied is + returned, no matter what the lifestyle of the wrapped service type is. Use with care, because the + wrapped service type will also become a singleton. This method is especially useful when use for + injecting factory methods, which will allow the wrapped service type to get + it's own lifestyle back. + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + The predicate that determines whether the + must be applied to a service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or + implement , when + does not have a single public constructor, or when does + not contain a constructor that has exactly one argument of type + or where T is + . + + + + An instance of this type will be supplied to the + delegate that is that is supplied to the + RegisterDecorator + overload that takes this delegate. This type contains information about the decoration that is about + to be applied and it allows users to examine the given instance to see whether the decorator should + be applied or not. + + + Please see the + RegisterDecorator + method for more information. + + + + + Gets the closed generic service type for which the decorator is about to be applied. The original + service type will be returned, even if other decorators have already been applied to this type. + + The closed generic service type. + + + + Gets the type of the implementation that is created by the container and for which the decorator + is about to be applied. The original implementation type will be returned, even if other decorators + have already been applied to this type. Please not that the implementation type can not always be + determined. In that case the closed generic service type will be returned. + + The implementation type. + + + + Gets the list of the types of decorators that have already been applied to this instance. + + The applied decorators. + + + + Gets the current object that describes the intention to create a new + instance with its currently applied decorators. + + The current expression that is about to be decorated. + + + + Hooks into the building process and adds a decorator if needed. + + + + This interface is not meant for public use. + + + Please do not use. + Do not use. + + + PLease do not use. + Do not use. + + + + A Registration implements lifestyle based caching for a single service and allows building an + that describes the creation of the service. + + + implementations create a new Registration instance for each registered + service type. s returned from the + BuildExpression method can be intercepted by any event + registered with , have + initializers + applied, and the caching particular to its lifestyle have been applied. Interception using the + Container.ExpressionBuilt will not + be applied in the Registration, but will be applied in . + + See the documentation for an example. + + + + + Initializes a new instance of the class. + + The this that created this registration. + The instance for this registration. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + + Builds a new with the correct caching (according to the specifications of + its ) applied. + + An . + + + + Gets the list of instances. Note that the list is only available + after calling . + + A new array containing the instances. + + + + Initializes an already created instance and applies properties and initializers to that instance. + + + This method is especially useful in integration scenarios where the given platform is in control + of creating certain types. By passing the instance created by the platform to this method, the + container is still able to apply any properties (as defined using a custom + ) and by applying any initializers. + + The instance to initialize. + Thrown when is a null reference + (Nothing in VB). + Thrown when the supplied is not + of type . + + + + Builds a delegate for the creation of the + using the supplied . The returned might + be intercepted by a + Container.ExpressionBuilding event, + and the will have been wrapped with a delegate that executes the + registered initializers + that are applicable to the given (if any). + + The interface or base type that can be used to retrieve instances. + + The delegate supplied by the user that allows building or creating new instances. + A delegate. + + + + Builds a delegate for the creation of . + The returned might be intercepted by a + Container.ExpressionBuilding event, + and the creation of the will have been wrapped with a + delegate that executes the registered + initializers + that are applicable to the given (if any). + + The interface or base type that can be used to retrieve instances. + The concrete type that will be registered. + A delegate. + + + + Builds an that describes the creation of the + using the supplied . The returned might + be intercepted by a + Container.ExpressionBuilding event, + and the will have been wrapped with a delegate that executes the + registered initializers that are + applicable to the given (if any). + + The interface or base type that can be used to retrieve instances. + + The delegate supplied by the user that allows building or creating new instances. + An . + + + + Builds an that describes the creation of + . The returned might be intercepted + by a Container.ExpressionBuilding + event, and the creation of the will have been wrapped with + a delegate that executes the registered + initializers + that are applicable to the given (if any). + + The interface or base type that can be used to retrieve instances. + The concrete type that will be registered. + An . + + + Gets the type that this instance will create. + The type that this instance will create. + + + Gets the this that created this registration. + The this that created this registration. + + + Gets the instance for this registration. + The instance for this registration. + + + + Allows retrieving the concrete types of the generic type arguments of that must be used to create a + closed generic implementation of a given open generic implementation, based on on the concrete + arguments of the given closed base type. + + + + + Helper class for building closed generic type for a given open generic type and a closed generic base. + + + + Result of the GenericTypeBuilder. + + + + A open generic type with the concrete arguments that can be used to create a closed generic type. + + + + + Helper methods for the extensions. + + + + + Represents the method that will called to register one or multiple concrete non-generic + of the given closed generic type + . + + The service type that needs to be registered. + One or more concrete types that implement the given + . + + + { + foreach (Type implementation in implementations) + { + container.RegisterSingle(implementation); + } + + container.RegisterAll(closedServiceType, implementations); + }; + + container.RegisterManyForOpenGeneric( + typeof(ICommandHandler<>), + registerAsCollectionAsSingletons, + typeof(ICommandHandler<>).Assembly); + ]]> + The BatchRegistrationCallback can be supplied to some overloads of the + RegisterManyForOpenGeneric extension methods. + The default behavior of the RegisterManyForOpenGeneric methods is to register a closed generic + type with the corresponding implementation (and will throw when multiple implementations are found for + a single closed generic service type). The given example overrides this default registration by + registering the found list of implementations (one or more) as collection of singletons for the given + closed generic service type. + + + + Defines the accessibility of the types to search. + This type is not available in Silverlight. + + + Load both public as internal types from the given assemblies. + + + Only load publicly exposed types from the given assemblies. + + + + Provides a set of static (Shared in Visual Basic) methods for registration many concrete types at + once that implement the same open generic service types in the . + + + + + Registers all concrete, non-generic, public and internal types in the given set of + that implement the given + with a transient lifetime. + + The container to make the registrations in. + The definition of the open generic type. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic, public and internal types that are located in the given + that implement the given + with a transient lifetime. + + The container to make the registrations in. + The definition of the open generic type. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic, public and internal types in the given set of + that implement the given + with the supplied . When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will point at the same registration and return the same instance based on the caching + behavior of the supplied . + + The container to make the registrations in. + The definition of the open generic type. + The lifestyle that will be used for the registration of the types. + A list of assemblies that will be searched. + Thrown when , + , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic, public and internal types that are located in the given + that implement the given + with the supplied . When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will point at the same registration and return the same instance based on the caching + behavior of the supplied . + + The container to make the registrations in. + The definition of the open generic type. + The lifestyle that will be used for the registration of the types. + A list of assemblies that will be searched. + Thrown when , + , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Allows registration of all concrete, public and internal, non-generic types that are located in the given set of + that implement the given , + by supplying a delegate, that will be called for each + found closed generic implementation of the given . + + The container to make the registrations in. + The definition of the open generic type. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + A list of assemblies that will be searched. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type. + + + + Allows registration of all concrete, public and internal, non-generic types that are located in the given set of + that implement the given , + by supplying a delegate, that will be called for each + found closed generic implementation of the given . + + The container to make the registrations in. + The definition of the open generic type. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + A list of assemblies that will be searched. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type. + + + + Registers all concrete, non-generic, public and internal types that are located in the given + that implement the given + with a singleton lifetime. + + The container to make the registrations in. + The definition of the open generic type. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic, public and internal types that are located in the given + that implement the given + with a singleton lifetime. + + The container to make the registrations in. + The definition of the open generic type. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all supplied by a closed generic definition of the + given with a transient lifetime. + + The container to make the registrations in. + The definition of the open generic type. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all supplied by a closed generic definition of the + given with a transient lifetime. + + The container to make the registrations in. + The definition of the open generic type. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Allows registration of all supplied by a closed generic + definition of the given , by supplying a + delegate, that will be called for each found closed generic + implementation. + If the list contains open generic types, matching closed generic versions of each open generic + type will be added to the list of implementations that is passed on to the + delegate. + + The container to make the registrations in. + The definition of the open generic type. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + The list of types that must be registered according to the given + definition. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + + + + Registers all supplied by a closed generic definition of the + given with a singleton lifetime. + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will return the exact same instance. + + The container to make the registrations in. + The definition of the open generic type. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all supplied by a closed generic definition of the + given with the supplied . + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will return the exact same instance. + + The container to make the registrations in. + The definition of the open generic type. + The lifestyle the registrations are made in. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all supplied by a closed generic definition of the + given with a singleton lifetime. + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will return the exact same instance. + + The container to make the registrations in. + The definition of the open generic type. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all supplied by a closed generic definition of the + given with the supplied + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will return the exact same instance. + + The container to make the registrations in. + The definition of the open generic type. + The lifestyle the registrations are made in. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with a transient lifetime. + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same closed generic + version of the given . + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with a transient lifetime. + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type or when the argument contains an invalid + value. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with the supplied . + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will point at the same registration and return the same instance based on the caching + behavior of the supplied . + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + The lifestyle that will be used for the registration of the types. + A list of assemblies that will be searched. + Thrown when , + , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same closed generic + version of the given . + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with the supplied . + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will point at the same registration and return the same instance based on the caching + behavior of the supplied . + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + The lifestyle that will be used for the registration of the types. + A list of assemblies that will be searched. + Thrown when , + , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Allows registration of all concrete, non-generic types with the given + that are located in the given set of + that implement the given , by supplying a + delegate, that will be called for each found closed generic + implementation of the given . + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + A list of assemblies that will be searched. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + + + + Allows registration of all concrete, non-generic types with the given + that are located in the given set of + that implement the given , by supplying a + delegate, that will be called for each found closed generic + implementation of the given . + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + A list of assemblies that will be searched. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with a singleton lifetime. + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same closed generic + version of the given . + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with a singleton lifetime. + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Returns all types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), AccessibilityOption.PublicTypesOnly, + typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the + registration. + + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + A list of types. + Thrown when + contains an invalid value. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), AccessibilityOption.PublicTypesOnly, + typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the registration. + + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + A list of types. + Thrown when + contains an invalid value. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), AccessibilityOption.PublicTypesOnly, + typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the + registration. + + The container to use. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + A list of types. + Thrown when + contains an invalid value. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), AccessibilityOption.PublicTypesOnly, + typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the registration. + + The container to use. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + A list of types. + Thrown when + contains an invalid value. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all public and internal types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the + registration. + + The definition of the open generic type. + A list of assemblies that will be searched. + A list of types. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all public and internal types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the registration. + + The definition of the open generic type. + A list of assemblies that will be searched. + A list of types. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all public and internal types that are located in the supplied + and implement or inherit from the supplied . + Types that are considered to be decorators are not returned. + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the + registration. + + The container to use. + The definition of the open generic type. + A list of assemblies that will be searched. + A list of types. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all public and internal types that are located in the supplied + and implement or inherit from the supplied . + Types that are considered to be decorators are not returned. + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the registration. + + The container to use. + The definition of the open generic type. + A list of assemblies that will be searched. + A list of types. + Thrown when , or + contain a null reference (Nothing in VB). + + + + An instance of this type will be supplied to the + delegate that is that is supplied to the + RegisterOpenGeneric + overload that takes this delegate. This type contains information about the open generic service that is about + to be created and it allows the user to examine the given instance to decide whether this implementation should + be created or not. + + + Please see the + RegisterOpenGeneric + method for more information. + + + + Gets the closed generic service type that is to be created. + The closed generic service type. + + + Gets the closed generic implementation type that will be created by the container. + The implementation type. + + + Gets a value indicating whether a previous RegisterOpenGeneric registration has already + been applied for the given . + The indication whether the event has been handled. + + + + Provides a set of static (Shared in Visual Basic) methods for registration of open generic service + types in the . + + + + + Registers that a new instance of will be returned + every time a is requested. + + + Please see the + RegisterOpenGeneric(Container,Type,Type,Lifestyle) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The definition of the open generic implementation type + that will be returned when a is requested. + + + + Registers that the same instance of will be returned + every time a is requested. + + + Please see the + RegisterOpenGeneric(Container,Type,Type,Lifestyle) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances.. + The definition of the open generic implementation type + that will be returned when a is requested. + + + + Registers that a closed generic instance of the supplied + will be returned when a closed generic version of + the is requested. The instance will be cached + according to the specified . + + + Types registered using the RegisterOpenGeneric are resolved using unregistered type + resolution. This means that an explicit registration made for a closed generic version of the + always gets resolved first and the given + only gets resolved when there is no such registration. + + + The following example shows the definition of a generic IValidator<T> interface + and, a NullValidator<T> implementation and a specific validator for Orders. + The registration ensures a OrderValidator is returned when a + IValidator<Order> is requested. For all requests for a + IValidator<T> other than a IValidator<Order>, an + implementation of NullValidator<T> will be returned. + + { + void Validate(T instance); + } + + public class NullValidator : IValidator + { + public void Validate(T instance) + { + } + } + + public class OrderValidator : IValidator + { + public void Validate(Order instance) + { + if (instance.Total < 0) + { + throw new ValidationException("Total can not be negative."); + } + } + } + + [TestMethod] + public static void TestRegisterOpenGeneric() + { + // Arrange + var container = new Container(); + + container.Register, OrderValidator>(Lifestyle.Transient); + container.RegisterOpenGeneric(typeof(IValidator<>), typeof(NullValidator<>), Lifestyle.Singleton); + + // Act + var orderValidator = container.GetInstance>(); + var customerValidator = container.GetInstance>(); + var productValidator = container.GetInstance>(); + + // Assert + Assert.IsInstanceOfType(orderValidator, typeof(OrderValidator)); + Assert.IsInstanceOfType(customerValidator, typeof(NullValidator)); + Assert.IsInstanceOfType(productValidator, typeof(NullValidator)); + } + ]]> + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The definition of the open generic implementation type + that will be returned when a is requested. + The lifestyle that defines how returned instances are cached. + + + + Registers that the same instance of will be returned + every time a is requested. + + + Please see the + RegisterOpenGeneric(Container,Type,Type,Lifestyle) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances.. + The definition of the open generic implementation type + that will be returned when a is requested. + The lifestyle that defines how returned instances are cached. + The predicate that determines whether the + can implement the service type. + + + + Registers that instances of will be returned + when a collection of is requested. New instances of + the registered will be returned whenever the + resolved collection is iterated. + + + Please see the + RegisterAllOpenGeneric(Container,Type,Lifestyle,IEnumerable<Type>) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The list of open generic implementation types + that will be returned when a collection of is requested. + + + + + Registers that instances of will be returned + when a collection of is requested. New instances of + the registered will be returned whenever the + resolved collection is iterated. + + + Please see the + RegisterAllOpenGeneric(Container,Type,Lifestyle,IEnumerable<Type>) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The list of open generic implementation types + that will be returned when a collection of is requested. + + + + + Registers that instances of will be returned + when a collection of is requested. The instances will be + cached according to the specified . + + + Please see the + RegisterAllOpenGeneric(Container,Type,Lifestyle,IEnumerable<Type>) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The lifestyle that defines how returned instances are cached. + The list of open generic implementation types + that will be returned when a collection of is requested. + + + + + Registers that instances of will be returned + when a collection of is requested. The instances will be + cached according to the specified . + + + + Collections registered using the RegisterAllOpenGeneric are resolved using unregistered type + resolution. This means that an explicit registration made for a collection of the closed generic + version of the always gets resolved first and a + collection of only gets resolved when there is no + such registration. + + + + The following example shows the definition of a generic IValidator<T> interface + and, a NullValidator<T> implementation and a specific validator for Orders. + The registration ensures a OrderValidator is returned when a + IValidator<Order> is requested. For all requests for a + IValidator<T> other than a IValidator<Order>, an + implementation of NullValidator<T> will be returned. + + { + void Validate(T instance); + } + + public class DefaultValidator : IValidator + { + public void Validate(T instance) + { + // some default validation + } + } + + [TestMethod] + public static void TestRegisterAllOpenGeneric() + { + // Arrange + var container = new Container(); + + Type[] types = new[] { typeof(OrderValidator), typeof(DefaultValidator<>) }; + + container.RegisterManyForOpenGeneric(typeof(IValidator<>), + (serviceType, implementationTypes) => container.RegisterAll(serviceType, implementationTypes), + types); + + container.RegisterAllOpenGeneric(typeof(IValidator<>), typeof(DefaultValidator<>)); + + // Act + var orderValidators = container.GetAllInstances>(); + var customerValidators = container.GetAllInstances>(); + + // Assert + Assert.IsTrue(orderValidators.SequenceEqual( + new[] { typeof(OrderValidator), typeof(DefaultValidator) })); + + // Without the call to RegisterAllOpenGeneric this customerValidators would be empty. + Assert.IsTrue(customerValidators.SequenceEqual(new[] { typeof(DefaultValidator) })); + } + ]]> + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The lifestyle that defines how returned instances are cached. + The list of open generic implementation types + that will be returned when a collection of is requested. + + + + Resolves a given open generic type. + + + + Allows validating an ArgumentMapping. + + + + + Instances returned from the container can be cached. The contains several + overloads of the Register method that take a Lifestyle instance as argument to define + how returned instances should be cached. The core library contains two lifestyles out of the box. By + supplying Lifestyle.Transient, the registered instance is not + cached; a new instance is returned every time it is requested or injected. By supplying + Lifestyle.Singleton instances can be cached indefinitely; only + a single instance of the registered component will be returned by that container instance. Other + lifestyles are defined in integration and extension packages. The + CreateCustom method allows defining a custom lifestyle and + the CreateHybrid method + allows creating a lifestyle that mixes multiple other lifestyles. + + + This type is abstract and can be overridden to implement a custom lifestyle. + + + + + The lifestyle instance that doesn't cache instances. A new instance of the specified + component is created every time the registered service it is requested or injected. + + + The following example registers the SomeServiceImpl implementation for the + ISomeService service type using the Transient lifestyle: + (Lifestyle.Transient); + ]]> + Note that Transient is the default lifestyle, the previous registration can be reduced to + the following: + (); + ]]> + + + + + The lifestyle that caches components during the lifetime of the instance + and guarantees that only a single instance of that component is created for that instance. Since + general use is to create a single Container instance for the lifetime of the application / + AppDomain, this would mean that only a single instance of that component would exist during the + lifetime of the application. In a multi-threaded applications, implementations registered using + this lifestyle must be thread-safe. + + + The following example registers the RealTimeProvider implementation for the + ITimeProvider service type using the Singleton lifestyle: + (Lifestyle.Singleton); + ]]> + Note that using the + RegisterSingle method has + the same effect: + (); + ]]> + + + + Initializes a new instance of the class. + The user friendly name of this lifestyle. + Thrown when is null (Nothing in VB) + or an empty string. + + + + The hybrid lifestyle allows mixing two lifestyles in a single registration. Based on the supplied + delegate the hybrid lifestyle will redirect the creation of + the instance to the correct lifestyle. The result of the + delegate will not be cached; it is invoked each time an instance is requested or injected. By + nesting hybrid lifestyles, any number of lifestyles can be mixed. + + The delegate that determines which + lifestyle should be used. The will be used if true is + returned; the otherwise. This delegate will be called every + time an instance needs to be resolved or injected. + The lifestyle to use when + returns true. + The lifestyle to use when + returns false. + A new hybrid lifestyle that wraps the supplied lifestyles. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + The following example shows the creation of a HybridLifestyle that mixes an + WebRequestLifestyle and LifetimeScopeLifestyle: + + HttpContext.Current != null, + new WebRequestLifestyle(), + new LifetimeScopeLifestyle()); + + // The created lifestyle can be reused for many registrations. + container.Register(mixedScopeLifestyle); + container.Register(mixedScopeLifestyle); + ]]> + + Hybrid lifestyles can be nested: + + container.GetCurrentLifetimeScope() != null, + new LifetimeScopeLifestyle(), + Lifestyle.Transient); + + var mixedScopeLifestyle = Lifestyle.CreateHybrid( + () => HttpContext.Current != null, + new WebRequestLifestyle(), + mixedLifetimeTransientLifestyle); + ]]> + + The mixedScopeLifestyle now mixed three lifestyles: Web Request, Lifetime Scope and + Transient. + + + + + + The hybrid lifestyle allows mixing two lifestyles in a single registration. Based on the supplied + delegate the hybrid lifestyle will redirect the creation of + the instance to the correct lifestyle. The result of the + delegate will not be cached; it is invoked each time an instance is requested or injected. By + nesting hybrid lifestyles, any number of lifestyles can be mixed. + + The delegate that determines which + lifestyle should be used. The will be used if true is + returned; the otherwise. This delegate will be called every + time an instance needs to be resolved or injected. + The scoped lifestyle to use when + returns true. + The scoped lifestyle to use when + returns false. + A new scoped hybrid lifestyle that wraps the supplied lifestyles. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + The following example shows the creation of a HybridLifestyle that mixes an + WebRequestLifestyle and LifetimeScopeLifestyle: + + HttpContext.Current != null, + new WebRequestLifestyle(), + new LifetimeScopeLifestyle()); + + // The created lifestyle can be reused for many registrations. + container.Register(mixedScopeLifestyle); + container.Register(mixedScopeLifestyle); + ]]> + + + + + Creates a custom lifestyle using the supplied delegate. + + + The supplied will be called just once per registered + service. The supplied will be called by the framework + when the type is resolved for the first time, and the framework will supply the factory with a + Func<object> for creating new (transient) instances of that type (that might + have been intercepted and + initializers might have been applied). + It is the job of the to return a Func<object> + that applies the proper caching. The Func<object> that is returned by the + will be stored for that registration (every + registration will store its own Func<object> delegate) and this delegate will be + called every time the service is resolved (by calling + container.GetInstance<TService> or when that service is injected into another + type). + + The name of the lifestyle to create. The name is used to display the lifestyle + in the debugger. + A factory delegate that takes a Func<object> delegate + that will produce a transient instance and returns a delegate that returns cached instances. + A new . + Thrown when one of the arguments is a null reference + (Nothing in VB). + Thrown when is an empty string. + + The following example shows the creation of a lifestyle that caches registered instances for 10 + minutes: + + { + TimeSpan timeout = TimeSpan.FromMinutes(10); + var syncRoot = new object(); + var expirationTime = DateTime.MinValue; + object instance = null; + + // If the application has multiple registrations using this lifestyle, each registration + // will get its own Func delegate (created here) and therefore get its own set + // of variables as defined above. + return () => + { + lock (syncRoot) + { + if (expirationTime < DateTime.UtcNow) + { + instance = instanceCreator(); + expirationTime = DateTime.UtcNow.Add(timeout); + } + + return instance; + } + }; + }); + + var container = new Container(); + + // We can reuse the created lifestyle for multiple registrations. + container.Register(customLifestyle); + container.Register(customLifestyle); + ]]> + + + + + Creates a new instance for the given + that will create new instances of specified with the + caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be created. + The instance for which a + must be created. + A new instance. + Thrown when is a null + reference (Nothing in VB). + + + + Creates a new instance for the given + that will create new instances instance using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + A delegate that will create a new instance of + every time it is called. + The instance for which a + must be created. + A new instance. + Thrown when either or + are null references (Nothing in VB). + + + + Creates a new instance for the given + that will create new instances of specified with the + caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + Thrown when on of the supplied arguments is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + Thrown when is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be created. + The instance for which a + must be created. + A new instance. + Thrown when is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + A delegate that will create a new instance of + every time it is called. + The instance for which a + must be created. + A new instance. + Thrown when either or + are null references (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + This method might fail when run in a partial trust sandbox when + is an internal type. + + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + Thrown when on of the supplied arguments is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + This method might fail when run in a partial trust sandbox when + is an internal type. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + Thrown when on of the supplied arguments is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The delegate that will be responsible for creating new instances. + The instance for which a + must be created. + A new instance. + Thrown when on of the supplied arguments is a null + reference (Nothing in VB). + + + + When overridden in a derived class, + creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + + If you are implementing your own lifestyle, override this method to implement the code necessary + to create and return a new . Note that you should always create + a new instance. They should never be cached. + + + + + When overridden in a derived class, + creates a new instance defining the creation of the + specified using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + A delegate that will create a new instance of + every time it is called. + The instance for which a + must be created. + A new instance. + + If you are implementing your own lifestyle, override this method to implement the code necessary + to create and return a new . Note that you should always create + a new instance. They should never be cached. + + + + Gets the user friendly name of this lifestyle. + The user friendly name of this lifestyle. + + + + Gets the length of the lifestyle. Implementers must implement this property. The diagnostic + services use this value to compare lifestyles with each other to determine lifestyle + misconfigurations. + + The representing the length of this lifestyle. + + + + A known relationship defines a relationship between two types. The Diagnostics Debug View uses this + information to spot possible misconfigurations. + + + + Initializes a new instance of the class. + The implementation type of the parent type. + The lifestyle of the parent type. + The type that the parent depends on (it is injected into the parent). + + + Serves as a hash function for a particular type. + A hash code for the current . + + + + Determines whether the specified is equal to the current + . + + The object to compare with the current object. + True if the specified is equal to the current + ; otherwise, false. + + + Gets the implementation type of the parent type of the relationship. + The implementation type of the parent type of the relationship. + + + Gets the lifestyle of the parent type of the relationship. + The lifestyle of the parent type of the relationship. + + + Gets the type that the parent depends on (it is injected into the parent). + The type that the parent depends on. + + + + Factory for the creation of a delegate that applies caching to the supplied + . + + A factory for creating new instances. + A factory that returns cached instances. + + + + Forwards CreateRegistration calls to the lifestyle that is returned from the registered + container.Options.LifestyleSelectionBehavior. + + + + + Base class for scoped lifestyles. A scoped lifestyle caches instances for the duration of an implicitly + or explicitly defined scope. Such scope can be an (implicitly defined) web request or an explicitly + defined Lifetime Scope. The lifetime of instances registered with a scoped lifestyle is always equal + or bigger than one-instance-per-object-graph. In other words, a call to GetInstance() will never create + more than one instance of such registered type. + + + + Initializes a new instance of the class. + The user friendly name of this lifestyle. + Thrown when is null (Nothing in VB) + or an empty string. + + + Initializes a new instance of the class. + The user friendly name of this lifestyle. + Signals the lifestyle whether instances should be + disposed or not. + Thrown when is null (Nothing in VB) + or an empty string. + + + + Allows registering an delegate that will be called when the scope ends, + but before the scope disposes any instances. + + + During the call to all registered delegates are + processed in the order of registration. Do note that registered actions are not guaranteed + to run. In case an exception is thrown during the call to , the + will stop running any actions that might not have been invoked at that point. + Instances that are registered for disposal using on the other + hand, are guaranteed to be disposed. Note that registered actions won't be invoked during a call + to . + + The instance. + The delegate to run when the scope ends. + Thrown when one of the arguments is a null reference + (Nothing in VB). + Will be thrown when there is currently no active + scope for the supplied . + + + + Adds the to the list of items that will get disposed when the + scope ends. + + + Note to implementers: Instances registered for disposal will have to be disposed in the opposite + order of registration, since disposable components might still need to call disposable dependencies + in their Dispose() method. + + The instance. + The instance that should be disposed when the scope ends. + Thrown when one of the arguments is a null reference + (Nothing in VB). + Will be thrown when there is currently no active + scope for the supplied . + + + + Returns the current for this lifestyle and the given + , or null when this method is executed outside the context of a scope. + + The container instance that is related to the scope to return. + A instance or null when there is no scope active in this context. + + + + Creates a delegate that upon invocation return the current for this + lifestyle and the given , or null when the delegate is executed outside + the context of such scope. + + The container for which the delegate gets created. + A delegate. This method never returns null. + + + + Returns the current for this lifestyle and the given + , or null when this method is executed outside the context of a scope. + + The container instance that is related to the scope to return. + A instance or null when there is no scope active in this context. + + + + Creates a new instance defining the creation of the + specified using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + A delegate that will create a new instance of + every time it is called. + The instance for which a + must be created. + A new instance. + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + + + + Disposes the list of supplied . The list is iterated in reverse + order (the first element in the list will be disposed last) and the method ensures that the + Dispose method of each element is called, regardless of any exceptions raised from any previously + called Dispose methods. If multiple exceptions are thrown, the last thrown exception will bubble + up the call stack. + + The list of objects to be disposed. + Thrown when the is a null + reference. + + + + Helper methods for the container. + + + + + Produces instances for a given registration. Instances of this type are generally created by the + container when calling one of the Register overloads. Instances can be retrieved by calling + or . + + + The Register method overloads create InstanceProducer instances internally, but + InstanceProducers can be created manually to implement special scenarios. An + InstanceProducer wraps instance. The Registration builds an + that describes the intend to create the instance according to a certain + lifestyle. The InstanceProducer on the other hand transforms this Expression to a + delegate and allows the actual instance to be created. A Registration itself can't create any + instance. The InsanceProducer allows intercepting created instances by hooking onto the + Container.ExpressionBuilt event. The + RegisterDecorator + extension methods for instance work by hooking onto the ExpressionBuilt event and allow + wrapping the returned instance with a decorator. + + + The following example shows the creation of two different InstanceProducer instances that wrap + the same Registration instance. Since the Registration is created using the + Singleton lifestyle, both producers will return + the same instance. The InstanceProducer for the Interface1 however, will wrap that + instance in a (transient) Interface1Decorator. + (container); + + var producer1 = new InstanceProducer(typeof(Interface1), registration); + var producer2 = new InstanceProducer(typeof(Interface2), registration); + + container.RegisterDecorator(typeof(Interface1), typeof(Interface1Decorator)); + + var instance1 = (Interface1)producer1.GetInstance(); + var instance2 = (Interface2)producer2.GetInstance(); + + Assert.IsInstanceOfType(instance1, typeof(Interface1Decorator)); + Assert.IsInstanceOfType(instance2, typeof(ServiceImpl)); + + Assert.AreSame(((Interface1Decorator)instance1).DecoratedInstance, instance2); + ]]> + + + + Initializes a new instance of the class. + The service type for which this instance is created. + The . + + + Produces an instance. + An instance. Will never return null. + When the instance could not be retrieved or is null. + + + + Builds an expression that expresses the intent to get an instance by the current producer. A call + to this method locks the container. No new registrations can't be made after a call to this method. + + An Expression. + + + + Gets the collection of relationships for this instance that the container knows about. + This includes relationships between the registered type and its dependencies and relationships + between applied decorators and their dependencies. Note that types that are not newed up by the + container, property dependencies that are injected using the (legacy) + InjectProperties method, and + properties that are injected inside a custom delegate that is registered using the + RegisterInitializer method are unknown + to the container and are not returned from this method. + Also note that this method will return an empty collection when called before the the + registered type is requested from the container (or before Verify + is called). + + An array of instances. + + + + Builds a string representation of the object graph with the current instance as root of the + graph. + + A string representation of the object graph. + Thrown when this method is called before + or have been called. These calls can be + done directly and explicitly by the user on this instance, indirectly by calling + or on an instance that depends on this + instance, or by calling Verify on the container. + + + + Gets the for this registration. The returned lifestyle can differ from the + lifestyle that is used during the registration. This can happen for instance when the registration + is changed by an ExpressionBuilt registration or + gets decorated. + + The for this registration. + + + Gets the service type for which this producer produces instances. + A instance. + + + Gets the instance for this instance. + The . + + + Internal helper for string resources. + + + + Provides data for and interaction with the + ResolveUnregisteredType event of + the . An observer can check the + to see whether the unregistered type can be handled. The + method can be called to register a delegate + that allows creation of instances of the unregistered for this and future requests. + + + + Initializes a new instance of the UnregisteredTypeEventArgs class. + The unregistered service type. + + + + Registers a delegate that allows creation of instances of the type + expressed by the for this and future requests. The delegate + will be caches and future requests will directly call that delegate. + + The delegate that allows creation of instances of the type + expressed by the . + Thrown when the is a + null reference. + Thrown when multiple observers that have registered to + the ResolveUnregisteredType event + called this method for the same type. + + + + Registers an that describes the creation of instances of the type + expressed by the for this and future requests. The delegate + will be cached and future requests will directly use that expression or the compiled delegate. + + + NOTE: If possible, use the Register(Registration) overload, + since this allows the analysis services to determine any configuration errors on the lifestyle of + the registration. + + The expression that describes the creation of instances of the type + expressed by the . + Thrown when the is a + null reference. + Thrown when multiple observers that have registered to + the ResolveUnregisteredType event + called this method for the same type. + + + + Registers a that describes the creation of instances of the type + expressed by the for this and future requests. The + registration will be cached and future requests will directly call unon that registration, the + expression that it generates or the delegate that gets compiled from that expression. + + The registration that describes the creation of instances according to + the registration's lifestyle of the type expressed by the . + Thrown when the is a + null reference. + Thrown when the is a + not exactly of type where T equals the . + + Thrown when multiple observers that have registered to + the ResolveUnregisteredType event + called this method for the same type. + + + Gets the unregistered service type that is currently requested. + The unregistered service type that is currently requested. + + + + Gets a value indicating whether the event represented by this instance has been handled. + This property will return true when has been called on + this instance. + + The indication whether the event has been handled. + + + diff --git a/packages/SimpleInjector.2.6.1/lib/portable-net4+sl4+wp8+win8+wpa81/SimpleInjector.Diagnostics.xml b/packages/SimpleInjector.2.6.1/lib/portable-net4+sl4+wp8+win8+wpa81/SimpleInjector.Diagnostics.xml new file mode 100644 index 0000000..254c1bd --- /dev/null +++ b/packages/SimpleInjector.2.6.1/lib/portable-net4+sl4+wp8+win8+wpa81/SimpleInjector.Diagnostics.xml @@ -0,0 +1,193 @@ + + + + SimpleInjector.Diagnostics + + + + + Entry point for doing diagnostic analysis on instances. + + + The following example shows the usage of the Analyzer class: + + + + + + Analyzes the supplied instance. + + The container instance to analyze. + A collection of sub types that describe the diagnostic + warnings and messages. + + + + Diagnostic result for a warning about a concrete type that was not registered explicitly and was not + resolved using unregistered type resolution, but was created by the container using the transient + lifestyle. + For more information, see: https://simpleinjector.org/diaut. + + + + + Base class for types that hold information about a single diagnostic message or warning for a + particular type or part of the configuration. + + + + Gets the diagnostic type of this result. + The . + + + Gets the service type to which this warning is related. + A . + + + Gets the description of the diagnostic result. + A with the description. + + + Gets the hierarchical group to which this diagnostic result belongs. + The . + + + Gets a collection of instances that describe all + container-registered dependencies for the given component. + List of objects. + + + + A hierarchical group of . + + + + + Gets the base that describes the service types of its + . The value often be either (in case this is a + root group) or a partial generic type to allow hierarchical grouping of a large number of related + generic types. + + The . + + + Gets the friendly name of the group. + The name. + + + Gets the description of the group. + The description. + + + Gets the diagnostic type of all grouped instances. + The . + + + Gets the parent or null (Nothing in VB) when this is the + root group. + The . + + + Gets the collection of child s. + A collection of elements. + + + Gets the collection of instances. + /// A collection of elements. + + + + Specifies the list of diagnostic types that are currently supported by the diagnostic + . Note that new diagnostic types might be added in future versions. + For more information, please read the + Diagnosing your configuration using the Diagnostic + Services wiki documentation. + + + + + Diagnostic type that warns about + a concrete type that was not registered explicitly and was not resolved using unregistered type + resolution, but was created by the container using the transient lifestyle. + For more information, see: https://simpleinjector.org/diaut. + + + + + Diagnostic type that warns when a + component depends on a service with a lifestyle that is shorter than that of the component. + For more information, see: https://simpleinjector.org/dialm. + + + + + Diagnostic type that warns when a + component depends on an unregistered concrete type and this concrete type has a lifestyle that is + different than the lifestyle of an explicitly registered type that uses this concrete type as its + implementation. + For more information, see: https://simpleinjector.org/diasc. + + + + + Diagnostic type that warns when a + component depends on (too) many services. + For more information, see: https://simpleinjector.org/diasr. + + + + + Diagnostic result for a warning about a + component that depends on a service with a lifestyle that is shorter than that of the component. + For more information, see: https://simpleinjector.codeplex.com/wikipage?title=PotentialLifestyleMismatches. + + + + Gets the object that describes the relationship between the component and its dependency. + A instance. + + + + Diagnostic result that warns about a + component that depends on an unregistered concrete type and this concrete type has a lifestyle that is + different than the lifestyle of an explicitly registered type that uses this concrete type as its + implementation. + For more information, see: https://simpleinjector.codeplex.com/wikipage?title=ShortCircuitedDependencies. + + + + Gets the instance that describes the current relationship between the checked component + and the short-circuited dependency. + The . + + + + Gets the collection of registrations that have the component's current dependency as + implementation type, but have a lifestyle that is different than the current dependency. + + A collection of instances. + + + + Diagnostic result that warns about a component that depends on (too) many services. + For more information, see: https://simpleinjector.codeplex.com/wikipage?title=PotentialSingleResponsibilityViolations. + + + + Gets the created type. + A . + + + Gets the list of registrations that are dependencies of the . + A collection of instances. + + + diff --git a/packages/SimpleInjector.2.6.1/lib/portable-net4+sl4+wp8+win8+wpa81/SimpleInjector.xml b/packages/SimpleInjector.2.6.1/lib/portable-net4+sl4+wp8+win8+wpa81/SimpleInjector.xml new file mode 100644 index 0000000..41d5f1f --- /dev/null +++ b/packages/SimpleInjector.2.6.1/lib/portable-net4+sl4+wp8+win8+wpa81/SimpleInjector.xml @@ -0,0 +1,4573 @@ + + + + SimpleInjector + + + + + The standard exception thrown when a container has an error in resolving an object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a specified error + message. + + The message that describes the error. + + + + Initializes a new instance of the class with a specified error + message and a reference to the inner exception that is the cause of this exception. + + + The error message that explains the reason for the exception. + + + The exception that is the cause of the current exception, or a null reference (Nothing in Visual + Basic) if no inner exception is specified. + + + + + Extension methods for enable advanced scenarios. + + + + + Determines whether the specified container is locked making any new registrations. The container + is automatically locked when GetInstance is called for the + first time. + + The container. + + true if the specified container is locked; otherwise, false. + + Thrown when is null. + + + Determines whether the specified container is currently verifying its configuration. + The container. + true if the specified container is verifying; otherwise, false. + Thrown when is null. + + + + Builds up an delegate wrapping all delegates that + are registered using RegisterInitializer and + that apply to the given (including delegates that are registered + for interfaces implements and base types that + inherits from). Null will be returned when no delegates are + registered that apply to this type. + + The container. + + This method has a performance caracteristic of O(n). Prevent from calling this in a performance + critical path of the application. + + The type for with an initializer must be built. + An delegate or null. + + + + Retrieves an item from the container stored by the given or null when no + item is stored by that key. + + + Thread-safety: Calls to this method are thread-safe, but users should take proper + percausions when they call both GetItem and . + + The container. + The key of the item to retrieve. + The stored item or null (Nothing in VB). + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + + Stores an item by the given in the container. + + + Thread-safety: Calls to this method are thread-safe, but users should take proper + percausions when they call both and SetItem. + + The container. + The key of the item to insert or override. + The actual item. May be null. + Thrown when either or + is a null reference (Nothing in VB). + + + + Allows appending new registrations to existing registrations made using one of the + RegisterAll overloads. + + The container. + The service type of the collection. + The registration to append. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + Thrown when the is not a + reference type, is open generic, or ambiguous. + Thrown when the container is locked. + Thrown when the method is called for a registration + that is made with one of the RegisterAll overloads that accepts a dynamic collection + (an IEnumerable or IEnumerable<TService>). + + + This interface is not meant for public use. + + + Please do not use. + Do not use. + + + PLease do not use. + Do not use. + + + + Defines the container's behavior for building an expression tree based on the supplied constructor of + a given type. + Set the ConstructorInjectionBehavior + property of the container's property to change the default behavior + of the container. + + + + + Builds an for the supplied , based on the + container's configuration. + + The parameter. + An that describes the intend of creating that + . This method never returns null. + + + + Defines the container's behavior for finding a suitable constructor for the creation of a type. + Set the ConstructorResolutionBehavior + property of the container's property to change the default behavior + of the container. + + + + + Gets the given 's constructor that can be used by the + container to create that instance. + + Type of the abstraction that is requested. + Type of the implementation to find a suitable constructor for. + + The . This method never returns null. + + Thrown when no suitable constructor could be found. + + + + Defines the container's behavior for verifying the constructor that will be picked by the + . + Set the ConstructorVerificationBehavior + property of the container's property to change the default behavior + of the container. + + + + Verifies the specified . + The parameter. + Thrown when the cannot be + used for auto wiring. + + Thrown when the is a + null reference. + + + + Defines the container's behavior for selecting properties to inject during the creation of a type. + Set the PropertySelectionBehavior + property of the container's property to change the default behavior + of the container. By default, no properties will be injected by the container. + + + + + Determines whether a property should be injected by the container upon creation of its type. + + Type of the abstraction that is requested. + The property to check. + True when the property should be injected. + + + + Defines the container's behavior for selecting the lifestyle for a registration in case no lifestyle + is explicitly supplied. + Set the LifestyleSelectionBehavior + property of the container's property to change the default behavior + of the container. By default, when no lifestyle is explicitly supplied, the + Transient lifestyle is used. + + + + Selects the lifestyle based on the supplied type information. + Type of the abstraction that is registered. + Type of the implementation to that is registered. + The suited for the given type. + Thrown when either one of the arguments is a null reference. + + + + An instance of this type will be supplied to the + delegate that is that is supplied to the + RegisterInitializer + overload that takes this delegate. This type contains contextual information about the creation and it + allows the user to examine the given instance to decide whether the instance should be initialized or + not. + + + + + Gets the that is responsible for the initialization of the created + instance. + + The or null (Nothing in VB) when the instance producer is + unknown. + + + + Gets the that is responsible for the initialization of the created + instance. + + /// The . + + + + Contains data that can be used to initialize a created instance. This data includes the actual + created and the information about the created instance. + + + + Returns the hash code for this instance. + A 32-bit signed integer that is the hash code for this instance. + + + Indicates whether this instance and a specified object are equal. + Another object to compare to. + True if the current object is equal to the other parameter; otherwise, false. + + + + Indicates whether the current object is equal to another object of the same type. + + An object to compare with this object. + True if the current object is equal to the other parameter; otherwise, false. + + + + Indicates whether the values of two specified objects are equal. + + The first object to compare. + The second object to compare. + True if a and b are equal; otherwise, false. + + + + Indicates whether the values of two specified objects are + not equal. + + The first object to compare. + The second object to compare. + True if a and b are not equal; otherwise, false. + + + Gets the with contextual information about the + created instance. + The . + + + Gets the created instance. + The created instance. + + + + This is an internal type. Only depend on this type when you want to be absolutely sure a future + version of the framework will break your code. + + + + Initializes a new instance of the struct. + The scope factory. + The container. + + + Gets the lazily initialized Scope of the current LazyScope instance. + The current Scope or null. + + + + This is an internal type. Only depend on this type when you want to be absolutely sure a future + version of the framework will break your code. + + Service type. + Implementation type. + + + + Initializes a new instance of the + struct. + The registration. + + + Gets the lazily initialized instance for the of the current LazyScopedRegistration. + The scope that is used to retrieve the instance. + The cached instance. + + + + A known relationship defines a relationship between two types. The Diagnostics Debug View uses this + information to spot possible misconfigurations. + + + + Initializes a new instance of the class. + The implementation type of the parent type. + The lifestyle of the parent type. + The type that the parent depends on (it is injected into the parent). + + + Serves as a hash function for a particular type. + A hash code for the current . + + + + Determines whether the specified is equal to the current + . + + The object to compare with the current object. + True if the specified is equal to the current + ; otherwise, false. + + + Gets the implementation type of the parent type of the relationship. + The implementation type of the parent type of the relationship. + + + Gets the lifestyle of the parent type of the relationship. + The lifestyle of the parent type of the relationship. + + + Gets the type that the parent depends on (it is injected into the parent). + The type that the parent depends on. + + + + The container. Create an instance of this type for registration of dependencies. + + + + Thread-safety: + Resolving instances can be done safely from multiple threads concurrently, but registration needs to + be done from one single thread. + + + It is therefore safe to call , , + GetService, and + and anything related to resolving instances from multiple thread + concurrently. It is however unsafe to call + RegisterXXX, + , , , + or anything related to registering from multiple threads concurrently. + + + + + Initializes a new instance of the class. + + + Initializes a new instance of the class. + The container options. + Thrown when the is a null + reference. + Thrown when supplied is an instance + that already is supplied to another instance. Every container must get + its own instance. + + + + Returns an array with the current registrations. This list contains all explicitly registered + types, and all implicitly registered instances. Implicit registrations are all concrete + unregistered types that have been requested, all types that have been resolved using + unregistered type resolution (using the event), and + requested unregistered collections. Note that the result of this method may change over time, + because of these implicit registrations. + + + + This method has a performance characteristic of O(n). Prevent from calling this in a performance + critical path of the application. + + + Note: This method is not guaranteed to always return the same + instance for a given registration. It will however either + always return a producer that is able to return the expected instance. Because of this, do not + compare sets of instances returned by different calls to + by reference. The way of comparing lists is by the actual type. The type of each instance is + guaranteed to be unique in the returned list. + + + An array of instances. + + + + Returns an array with the current registrations for root objects. Root objects are registrations + that are in the root of the object graph, meaning that no other registration is depending on it. + + + + This method has a performance characteristic of O(n). Prevent from calling this in a performance + critical path of the application. + + + This list contains the root objects of all explicitly registered types, and all implicitly + registered instances. Implicit registrations are all concrete unregistered types that have been + requested, all types that have been resolved using unregistered type resolution (using the + event), and requested unregistered collections. Note that + the result of this method may change over time, because of these implicit registrations. + + + Note: This method is not guaranteed to always return the same + instance for a given registration. It will however either + always return a producer that is able to return the expected instance. Because of this, do not + compare sets of instances returned by different calls to + by reference. The way of comparing lists is by the actual type. The type of each instance is + guaranteed to be unique in the returned list. + + + An array of instances. + Thrown when this method is called before + has been successfully called. + + + Determines whether the specified System.Object is equal to the current System.Object. + + The System.Object to compare with the current System.Object. + + True if the specified System.Object is equal to the current System.Object; otherwise, false. + + + + Returns the hash code of the current instance. + The hash code of the current instance. + + + + Returns a that represents the . + + + A that represents the . + + + + Gets the of the current instance. + The instance that represents the exact runtime + type of the current instance. + + + Prevents any new registrations to be made to the container. + + + + Registers that a new instance of will be returned every time it + is requested (transient). + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The concrete type that will be registered. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + Thrown when the is a type + that can not be created by the container. + + + + Registers that an instance of will be returned when it + is requested. The instance is cached according to the supplied . + + The concrete type that will be registered. + The lifestyle that specifies how the returned instance will be cached. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + Thrown when the is a type + that can not be created by the container. + + + + Registers that a new instance of will be returned every time a + is requested (transient). + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + Thrown when the given + type is not a type that can be created by the container. + + + + + Registers the specified delegate that allows returning transient instances of + . The delegate is expected to always return a new instance on + each call. + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The interface or base type that can be used to retrieve instances. + The delegate that allows building or creating new instances. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + + Thrown when is a null reference. + + + + Registers that a new instance of will be returned every time it + is requested (transient). + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The concrete type that will be registered. + Thrown when is a null + references (Nothing in VB). + Thrown when represents an + open generic type or is a type that can not be created by the container. + + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers that a new instance of will be returned every time a + is requested. If and + represent the same type, the type is registered by itself. + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The base type or interface to register. + The actual type that will be returned when requested. + Thrown when or + are null references (Nothing in VB). + Thrown when is + no sub type from (or the same type), or one of them represents an + open generic type. + + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers the specified delegate that allows returning instances of . + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + The base type or interface to register. + The delegate that will be used for creating new instances. + Thrown when either or + are null references (Nothing in VB). + Thrown when represents an + open generic type. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers a single concrete instance that will be constructed using constructor injection and will + be returned when this instance is requested by type . + This must be thread-safe when working in a multi-threaded + environment. + + The concrete type that will be registered. + + Thrown when this container instance is locked and can not be altered, or when + has already been registered. + + Thrown when the is a type + that can not be created by the container. + + + + Registers that the same a single instance of type will be + returned every time an type is requested. If + and represent the same + type, the type is registered by itself. must be thread-safe + when working in a multi-threaded environment. + + + The interface or base type that can be used to retrieve the instances. + + The concrete type that will be registered. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + Thrown when the given + type is not a type that can be created by the container. + + + + + Registers a single instance that will be returned when an instance of type + is requested. This must be thread-safe + when working in a multi-threaded environment. + + The interface or base type that can be used to retrieve the instance. + The instance to register. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + + Thrown when is a null reference. + + + + + Registers the specified delegate that allows constructing a single instance of + . This delegate will be called at most once during the lifetime of + the application. The returned instance must be thread-safe when working in a multi-threaded + environment. + + The interface or base type that can be used to retrieve instances. + The delegate that allows building or creating this single + instance. + + Thrown when this container instance is locked and can not be altered, or when a + for has already been registered. + + Thrown when is a + null reference. + + + + Registers that the same instance of type will be returned every + time an instance of type type is requested. If + and represent the same type, the + type is registered by itself. must be thread-safe when working + in a multi-threaded environment. + + The base type or interface to register. + The actual type that will be returned when requested. + Thrown when either or + are null references (Nothing in VB). + Thrown when is + no sub type from , or when one of them represents an open generic + type. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers the specified delegate that allows constructing a single + instance. The container will call this delegate at most once during the lifetime of the application. + + The base type or interface to register. + The delegate that will be used for creating that single instance. + Thrown when represents an open + generic type. + Thrown when either or + are null references (Nothing in + VB). + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers a single instance that will be returned when an instance of type + is requested. This must be thread-safe + when working in a multi-threaded environment. + + The base type or interface to register. + The instance to register. + Thrown when either or + are null references (Nothing in VB). + Thrown when is + no sub type from . + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + + Registers that an instance of will be returned when an + instance of type is requested. The instance is cached according to + the supplied . + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The lifestyle that specifies how the returned instance will be cached. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + Thrown when the given + type is not a type that can be created by the container. + + + + + Registers the specified delegate that will produce instances of + type and will be returned when an instance of type + is requested. The delegate is expected to produce new instances on + each call. The instances are cached according to the supplied . + + The interface or base type that can be used to retrieve instances. + The delegate that allows building or creating new instances. + The lifestyle that specifies how the returned instance will be cached. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + + Thrown when one of the supplied arguments is a null reference (Nothing in VB). + + + + Registers that an instance of type will be returned when an + instance of type is requested. The instance is cached according to + the supplied . + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The lifestyle that specifies how the returned instance will be cached. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + Thrown when the given + type is not a type that can be created by the container, when either + or are open generic types, or when + is not assignable from the . + + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + + Registers the specified delegate that will produce instances of + type and will be returned when an instance of type + is requested. The delegate is expected to produce new instances on + each call. The instances are cached according to the supplied . + + The interface or base type that can be used to retrieve instances. + The delegate that allows building or creating new instances. + The lifestyle that specifies how the returned instance will be cached. + + Thrown when this container instance is locked and can not be altered, or when the + has already been registered. + + Thrown when one of the supplied arguments is a null reference (Nothing in VB). + + + + Registers an delegate that runs after the creation of instances that + implement or derive from the given . Please note that only instances + that are created by the container (using constructor injection) can be initialized this way. + + The type for which the initializer will be registered. + The delegate that will be called after the instance has been + constructed and before it is returned. + + Thrown when the is a null reference. + + + Thrown when this container instance is locked and can not be altered. + + + Multiple delegates can be registered per + and multiple initializers can be applied on a created instance, + before it is returned. For instance, when registering a + for type , the delegate will be called for every instance created by + the container, which can be nice for debugging purposes. + + + Note: Initializers are guaranteed to be executed in the order they are registered. + + + The following example shows the usage of the + RegisterInitializer method: + + (); + + // Configuring property injection for types that implement ICommand: + container.RegisterInitializer(command => + { + command.SendAsync = true; + }); + + // Configuring property injection for types that implement CommandBase: + container.RegisterInitializer(command => + { + command.Clock = container.GetInstance(); + }); + + // Act + var command = (ConcreteCommand)container.GetInstance(); + + // Assert + // Because ConcreteCommand implements both ICommand and CommandBase, + // both the initializers will have been executed. + Assert.IsTrue(command.SendAsync); + Assert.IsNotNull(command.Clock); + } + ]]> + + The container does not use the type information of the requested service type, but it uses the + type information of the actual implementation to find all initialized that apply for that + type. This makes it possible to have multiple initializers to be applied on a single returned + instance while keeping performance high. + + + Registered initializers will only be applied to instances that are created by the container self + (using constructor injection). Types that are newed up manually by supplying a + delegate to the container (using the + and + methods) or registered as single instance + (using ) will not trigger initialization. + When initialization of these instances is needed, this must be done manually, as can be seen in + the following example: + commandInitializer = command => + { + initializerCallCount++; + }); + + // Configuring that initializer. + container.RegisterInitializer(commandInitializer); + + container.Register(() => + { + // Create a ConcreteCommand manually: will not be initialized. + var command = new ConcreteCommand("Data Source=.;Initial Catalog=db;"); + + // Run the initializer manually. + commandInitializer(command); + + return command; + }); + + // Act + var command = container.GetInstance(); + + // Assert + // The initializer will only be called once. + Assert.AreEqual(1, initializerCallCount); + } + ]]> + The previous example shows how a manually created instance can still be initialized. Try to + prevent creating types manually, by changing the design of those classes. If possible, create a + single public constructor that only contains dependencies that can be resolved. + + + + + + Registers an delegate that runs after the + creation of instances for which the supplied returns true. Please + note that only instances that are created by the container can be initialized this way. + + The delegate that will be called after the instance has been + constructed and before it is returned. + The predicate that will be used to check whether the given delegate must + be applied to a registration or not. The given predicate will be called once for each registration + in the container. + + Thrown when either the or are + null references. + + + Thrown when this container instance is locked and can not be altered. + + + Note: Initializers are guaranteed to be executed in the order they are registered. + + + Note: The is not guaranteed to be called once per registration; + when a registration's instance is requested for the first time simultaneously over multiple thread, + the predicate might be called multiple times. The caller of this method is responsible of supplying + a predicate that is thread-safe. + + + + + + Registers a dynamic (container uncontrolled) collection of elements of type + . A call to will return the + itself, and updates to the collection will be reflected in the + result. If updates are allowed, make sure the collection can be iterated safely if you're running + a multi-threaded application. + + The interface or base type that can be used to retrieve instances. + The collection to register. + + Thrown when this container instance is locked and can not be altered, or when a + for has already been registered. + + Thrown when is a null + reference. + + + + Registers a collection of singleton elements of type . + + The interface or base type that can be used to retrieve instances. + The collection to register. + + Thrown when this container instance is locked and can not be altered, or when a + for has already been registered. + + Thrown when is a null + reference. + Thrown when one of the elements of + is a null reference. + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, a generic type definition, or the is + not assignable from one of the given elements. + + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, a generic type definition, or the is + not assignable from one of the given elements. + + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, a generic type definition, or the is + not assignable from one of the given elements. + + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, the is a generic type definition, or when + is + not assignable from one of the given elements. + + + + + Registers a collection of , whose instances will be resolved lazily + each time the resolved collection of is enumerated. + The underlying collection is a stream that will return individual instances based on their + specific registered lifestyle, for each call to . + The order in which the types appear in the collection is the exact same order that the items were + registered, i.e the resolved collection is deterministic. + + The base type or interface for elements in the collection. + The collection of objects whose instances + will be requested from the container. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + Thrown when contains a null + (Nothing in VB) element, the is a generic type definition, or when + is + not assignable from one of the given elements. + + + + + Registers a dynamic (container uncontrolled) collection of elements of type + . A call to will return the + itself, and updates to the collection will be reflected in the + result. If updates are allowed, make sure the collection can be iterated safely if you're running + a multi-threaded application. + + The base type or interface for elements in the collection. + The collection of items to register. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + Thrown when represents an + open generic type. + + + + Verifies the Container. This method will call all registered delegates, + iterate registered collections and throws an exception if there was an error. + + Thrown when the registration of instances was + invalid. + + + + Adds the for the supplied . This + method can be used to apply the same to multiple different service + types. + + The base type or interface to register. + The registration that should be stored for the given + . + + (container); + + container.AddRegistration(typeof(IFoo), registration); + container.AddRegistration(typeof(IBar), registration); + + // Act + IFoo foo = container.GetInstance(); + IBar bar = container.GetInstance(); + + // Assert + bool fooAndBareAreTheSameInstance = object.ReferenceEquals(foo, bar); + Assert.IsTrue(fooAndBareAreTheSameInstance); + } + ]]> + + In the example above a singleton registration is created for type FooBar and this + registration is added to the container for each interface (IFoo and IBar) that it + implements. Since both services use the same singleton registration, requesting those services + will result in the return of the same (singleton) instance. + + + events are applied to the of the + instance and are therefore applied once. + events on the other hand get applied to the Expression of the . + Since each AddRegistration gets its own instance producer (that wraps the + Registration instance), this means that the ExpressionBuilt events will be + applied for each registered service type. + + + The most practical example of this is the use of decorators using one of the + RegisterDecorator overloads + (decorator registration use the + ExpressionBuilt event under the covers). Take a look at the following example: + + (container); + + container.AddRegistration(typeof(IFoo), registration); + container.AddRegistration(typeof(IBar), registration); + + // Registere a decorator for IBar, but not for IFoo + container.RegisterDecorator(typeof(IBar), typeof(BarDecorator)); + + // Act + var foo = container.GetInstance(); + var decorator = container.GetInstance() as BarDecorator; + var bar = decorator.DecoratedBar; + + // Assert + bool fooAndBareAreTheSameInstance = object.ReferenceEquals(foo, bar); + Assert.IsTrue(fooAndBareAreTheSameInstance); + } + ]]> + The example shows that the decorator gets applied to IBar but not to IFoo, but that + the decorated IBar is still the same instance as the resolved IFoo instance. + + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + Thrown when is not a reference + type, is open generic, is ambiguous, when it is not assignable from the + 's ImplementationType + or when the supplied is created for a different + instance. + + Thrown when this container instance is locked and can not be altered, or when an + the has already been registered. + + + + Gets an instance of the given . + Type of object requested. + The requested service instance. + Thrown when there are errors resolving the service instance. + + + Gets an instance of the given . + Type of object requested. + The requested service instance. + Thrown when there are errors resolving the service instance. + + + + Gets all instances of the given currently registered in the container. + + Type of object requested. + A sequence of instances of the requested TService. + Thrown when there are errors resolving the service instance. + + + + Gets all instances of the given currently registered in the container. + + Type of object requested. + A sequence of instances of the requested serviceType. + Thrown when there are errors resolving the service instance. + + + Gets the service object of the specified type. + An object that specifies the type of service object to get. + A service object of type serviceType. -or- null if there is no service object of type + . + + + + Gets the for the given . When no + registration exists, the container will try creating a new producer. A producer can be created + when the type is a concrete reference type, there is an + event registered that acts on that type, or when the service type is an . + Otherwise null (Nothing in VB) is returned. + + + + A call to this method locks the container. No new registrations can't be made after a call to this + method. + + + Note: This method is not guaranteed to always return the same + instance for a given . It will however either + always return null or always return a producer that is able to return the expected instance. + + + The that the returned instance producer should produce. + An or null (Nothing in VB). + + + + Gets the for the given . When no + registration exists, the container will try creating a new producer. A producer can be created + when the type is a concrete reference type, there is an + event registered that acts on that type, or when the service type is an . + Otherwise null (Nothing in VB) is returned, or an exception is throw when + is set to true. + + + + A call to this method locks the container. No new registrations can't be made after a call to this + method. + + + Note: This method is not guaranteed to always return the same + instance for a given . It will however either + always return null or always return a producer that is able to return the expected instance. + + + The that the returned instance producer should produce. + The indication whether the method should return null or throw + an exception when the type is not registered. + An or null (Nothing in VB). + + + + Injects all public writable properties of the given that have a type + that can be resolved by this container instance. + NOTE: This method will be removed in a future release. To use property injection, + implement a custom the instead. For more information, + read the + extendibility points wiki. + + The instance whose properties will be injected. + + Thrown when the is null (Nothing in VB). + Throw when injecting properties on the given instance + failed due to security constraints of the sandbox. This can happen when injecting properties + on an internal type in a Silverlight sandbox, or when running in partial trust. + + + Gets the container options. + The instance for this container. + + + + Gets the intermediate lifestyle that forwards CreateRegistration calls to the lifestyle that is + returned from the registered container.Options.LifestyleSelectionBehavior. + + + + + Occurs when an instance of a type is requested that has not been registered explicitly, allowing + resolution of unregistered types before the container tries to create the type. + + + + The event is called by the container every time an + unregistered type is requested for the first time, allowing a developer to do unregistered type + resolution. By calling the + Register method on the + , a , or + delegate can be registered allowing the container to retrieve + instances of the requested type. This registration is cached and it prevents the + ResolveUnregisteredType event from being called again for the same type. + + + When no registered event handled the registration of an unregistered type, the container will try + to create the type when this type is either concrete or is the + interface. Concrete types will be registered with the Transient + lifestyle and registrations will return an empty collection. When no + even handled the registration and the container could not create it, an exception is thrown. + + + Thread-safety: Please note that the container will not ensure that the hooked delegates + are executed only once. While the calls to for a given type + are finite (and will in most cases happen just once), a container can call the delegate multiple + times and make parallel calls to the delegate. You must make sure that the code can be called + multiple times and is thread-safe. + + + + The following example shows the usage of the event: + + { + void Validate(T instance); + } + + // Implementation of the null object pattern. + public class EmptyValidator : IValidator + { + public void Validate(T instance) + { + // Does nothing. + } + } + + [TestMethod] + public void TestResolveUnregisteredType() + { + // Arrange + var container = new Container(); + + // Register an EmptyValidator to be returned when a IValidator is requested: + container.ResolveUnregisteredType += (sender, e) => + { + if (e.UnregisteredServiceType.IsGenericType && + e.UnregisteredServiceType.GetGenericTypeDefinition() == typeof(IValidator<>)) + { + var validatorType = typeof(EmptyValidator<>).MakeGenericType( + e.UnregisteredServiceType.GetGenericArguments()); + + object emptyValidator = container.GetInstance(validatorType); + + // Register the instance as singleton. + e.Register(() => emptyValidator); + } + }; + + // Act + var orderValidator = container.GetInstance>(); + var customerValidator = container.GetInstance>(); + + // Assert + Assert.IsInstanceOfType(orderValidator, typeof(EmptyValidator)); + Assert.IsInstanceOfType(customerValidator, typeof(EmptyValidator)); + } + ]]> + + The example above registers a delegate that is raised every time an unregistered type is requested + from the container. The delegate checks whether the requested type is a closed generic + implementation of the IValidator<T> interface (such as + IValidator<Order> or IValidator<Customer>). In that case it + will request the container for a concrete EmptyValidator<T> implementation that + implements the given + UnregisteredServiceType, and + registers a delegate that will return this created instance. The e.Register call + registers the method in the container, preventing the from + being called again for the exact same service type, preventing any performance penalties. + + + Please note that given example is just an uhhmm... example. In the case of the example the + EmptyValidator<T> can be better registered using of the built-in + RegisterOpenGeneric + extension methods instead. These extension methods take care of any given generic type constraint + and allow the implementation to be integrated into the container's pipeline, which allows + it to be intercepted using the event and allow any registered + initializers to be applied. + + + + + + Occurs after the creation of the of a registered type is complete (the + lifestyle has been applied), allowing the created to be wrapped, + changed, or replaced. Multiple delegates may handle the same service type. + + + + The ExpressionBuilt event is called by the container every time an registered type is + getting compiled, allowing a developer to change the way the type is created. The delegate that + hooks to the ExpressionBuilt event, can change the + property on the + , which allows changing the way the type is constructed. + + + Thread-safety: Please note that the container will not ensure that the hooked delegates + are executed only once per service type. While the calls to for a + given type are finite (and will in most cases happen just once), a container can call the delegate + multiple times and make parallel calls to the delegate. You must make sure that the code can be + called multiple times and is thread-safe. + + + + The following example shows the usage of the ExpressionBuilt event: + + { + void Validate(T instance); + } + + public interface ILogger + { + void Write(string message); + } + + // Implementation of the decorator pattern. + public class MonitoringValidator : IValidator + { + private readonly IValidator validator; + private readonly ILogger logger; + + public MonitoringValidator(IValidator validator, ILogger logger) + { + this.validator = validator; + this.logger = logger; + } + + public void Validate(T instance) + { + this.logger.Write("Validating " + typeof(T).Name); + this.validator.Validate(instance); + this.logger.Write("Validated " + typeof(T).Name); + } + } + + [TestMethod] + public void TestExpressionBuilt() + { + // Arrange + var container = new Container(); + + container.RegisterSingle(); + container.Register, OrderValidator>(); + container.Register, CustomerValidator>(); + + // Intercept the creation of IValidator instances and wrap them in a MonitoringValidator: + container.ExpressionBuilt += (sender, e) => + { + if (e.RegisteredServiceType.IsGenericType && + e.RegisteredServiceType.GetGenericTypeDefinition() == typeof(IValidator<>)) + { + var decoratorType = typeof(MonitoringValidator<>) + .MakeGenericType(e.RegisteredServiceType.GetGenericArguments()); + + // Wrap the IValidator in a MonitoringValidator. + e.Expression = Expression.New(decoratorType.GetConstructors()[0], new Expression[] + { + e.Expression, + container.GetRegistration(typeof(ILogger)).BuildExpression(), + }); + } + }; + + // Act + var orderValidator = container.GetInstance>(); + var customerValidator = container.GetInstance>(); + + // Assert + Assert.IsInstanceOfType(orderValidator, typeof(MonitoringValidator)); + Assert.IsInstanceOfType(customerValidator, typeof(MonitoringValidator)); + } + ]]> + + The example above registers a delegate that is raised every time the container compiles the + expression for an registered type. The delegate checks whether the requested type is a closed generic + implementation of the IValidator<T> interface (such as + IValidator<Order> or IValidator<Customer>). In that case it + will changes the current with a new one that creates + a new MonitoringValidator<T> that takes the current validator (and an ILogger) + as an dependency. + + + Please note that given example is just an uhhmm... example. In the case of the example the + MonitoringValidator<T> is a decorator and instead of manually writing this code that + many limitations, you can use one of the built-in + RegisterDecorator extension methods instead. + These extension methods take care of any given generic type constraint, allow to register decorators + conditionally and allow the decorator to be integrated into the container's pipeline, which allows + it to be intercepted using the event and allow any registered + initializers to be applied. + + + + + + Occurs directly after the creation of the of a registered type is made, + but before any initializer and lifestyle specific caching + has been applied, allowing the created to be altered. Multiple delegates + may handle the same service type. + + + + The ExpressionBuilding event is called by the container every time an registered type is + getting compiled, allowing a developer to change the way the type is created. The delegate that + hooks to the ExpressionBuilding event, can change the + property on the + , which allows changing the way the type is constructed. + + + The exact type supplied depends on the type of registration. + Registrations that explicitly supply the implementation type (such as + Register<TService, TImplementation>()) + will result in an , while registrations that take a delegate (such as + Register<TService>(Func<TService>)) + will result in an . Singletons that are passed in using their + value (RegisterSingle<TService>(TService)) + will result in an . Note that other ExpressionBuilding + registrations might have changed the + property and might have supplied an of a different type. The order in + which these events are registered might be of importance to you. + + + Thread-safety: Please note that the container will not ensure that the hooked delegates + are executed only once per service type. While the calls to registered ExpressionBuilding + events for a given type are finite (and will in most cases happen just once), a container can + call the delegate multiple times and make parallel calls to the delegate. You must make sure that + the code can be called multiple times and is thread-safe. + + + + The following example shows the usage of the ExpressionBuilding event: + + { + var expression = e.Expression as NewExpression; + + if (expression != null) + { + var propertiesToInject = + from property in expression.Constructor.DeclaringType.GetProperties() + where property.GetCustomAttributes(typeof(MyInjectPropertyAttribute), true).Any() + let registration = container.GetRegistration(property.PropertyType, true) + select Tuple.Create(property, registration); + + if (propertiesToInject.Any()) + { + Func[], object> injectorDelegate = + (instance, dependencies) => + { + foreach (var dependency in dependencies) + { + dependency.Item1.SetValue(instance, dependency.Item2.GetInstance(), null); + } + + return instance; + }; + + e.Expression = Expression.Convert( + Expression.Invoke( + Expression.Constant(injectorDelegate), + e.Expression, + Expression.Constant(propertiesToInject.ToArray())), + expression.Constructor.DeclaringType); + } + } + }; + } + ]]> + + The example above registers a delegate that is raised every time the container compiles the + expression for an registered type. The delegate checks if the type contains properties that are + decorated with the supplied MyInjectPropertyAttribute. If decorated properties are found, + the given expression is replaced with an expression that injects decorated properties. + + + The example differs from the container's built-in method in that + it will fail when one of the decorated properties can not be injected. The built-in + will look at all properties of a given class and will simply skip + over any properties that can not be injected, making the use of the + method often verify fragile and error prone. + + + + + Implements a cache for implementations. + + is thread-safe can be used over multiple threads concurrently. + + + + + Allows registering an delegate that will be called when the scope ends, + but before the scope disposes any instances. + + + During the call to all registered delegates are + processed in the order of registration. Do note that registered actions are not guaranteed + to run. In case an exception is thrown during the call to , the + will stop running any actions that might not have been invoked at that point. + Instances that are registered for disposal using on the other + hand, are guaranteed to be disposed. Note that registered actions won't be invoked during a call + to . + + The delegate to run when the scope ends. + Thrown when one of the arguments is a null reference + (Nothing in VB). + Thrown when the scope has been disposed. + + + + Adds the to the list of items that will get disposed when the + scope ends. + + + Instances that are registered for disposal, will be disposed in opposite order of registration and + they are guaranteed to be disposed when is called (even when + exceptions are thrown). This mimics the behavior of the C# and VB using statements, + where the method is called inside the finally block. + + The instance that should be disposed when the scope ends. + Thrown when one of the arguments is a null reference + (Nothing in VB). + Thrown when the scope has been disposed. + + + Releases all instances that are cached by the object. + + + + Releases all instances that are cached by the object. + + False when only unmanaged resources should be released. + + + Configuration options for the . + + The following example shows the typical usage of the ContainerOptions class. + (); + + // Use of ContainerOptions class here. + container.Options.AllowOverridingRegistrations = true; + + // Replaces the previous registration of ITimeProvider + container.Register(); + ]]> + + + + Initializes a new instance of the class. + + + + Gets or sets a value indicating whether the container allows overriding registrations. The default + is false. + + The value indicating whether the container allows overriding registrations. + + + + Gets or sets the constructor resolution behavior. By default, the container only supports types + that have a single public constructor. + + The constructor resolution behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + + Gets or sets the constructor verification behavior. The container's default behavior is to + disallow constructors with value types and strings. + + The constructor resolution behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + Gets or sets the constructor injection behavior. + The constructor injection behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + + Gets or sets the property selection behavior. The container's default behavior is to do no + property injection. + + The property selection behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + + Gets or sets the lifestyle selection behavior. The container's default behavior is to make + registrations using the lifestyle. + The lifestyle selection behavior. + Thrown when the supplied value is a null reference. + + Thrown when the container already contains registrations. + + + + + Gets the container to which this ContainerOptions instance belongs to or null when + this instance hasn't been applied to a yet. + + The current . + + + + Gets or sets a value indicating whether the container will use dynamic assemblies for compilation. + By default, this value is true for the first few containers that are created in an app + domain and false for all other containers. You can set this value explicitly to false + to prevent the use of dynamic assemblies or you can set this value explicitly to true to + force more container instances to use dynamic assemblies. Note that creating an infinite number + of instances (for instance one per web request) with this property set to + true will result in a memory leak; dynamic assemblies take up memory and will only be + unloaded when the AppDomain is unloaded. + + A boolean indicating whether the container should use a dynamic assembly for compilation. + + + + + Allows verifying whether a given type has a direct or indirect dependency on itself. Verifying is done + by preventing recursive calls to a IInstanceProvider. An instance of this type is related to a single + instance of a IInstanceProvider. A RecursiveDependencyValidator instance checks a single + IInstanceProvider and therefore a single service type. + + + + + Extension methods for the RecursiveDependencyValidator class. + + + + + Provides data for and interaction with the + ExpressionBuilding event of + the . An observer can change the + property to change the component that is + currently being built. + + + + Gets the registered service type that is currently requested. + The registered service type that is currently requested. + + + + Gets the type that is known to be returned by the + Expression (most often the implementation + type used in the Register call). This type will be a derivative of + RegisteredServiceType (or + or RegisteredServiceType itself). If the Expression is changed, the new expression + must also return an instance of type KnownImplementationType or a sub type. + This information must be described in the new Expression. + + A . + + + + Gets the lifestyle for the component that is currently being built. + + The . + + + Gets or sets the currently registered . + The current registration. + Thrown when the supplied value is a null reference. + + + + Gets the collection of currently known relationships. This information is used by the Diagnostics + Debug View. Change the contents of this collection to represent the changes made to the + Expression property (if any). This allows + the Diagnostics Debug View to analyze those new relationships as well. + + The collection of instances. + + + + Provides data for and interaction with the + ExpressionBuilt event of + the . An observer can change the + property to change the component that is currently + being built. + + + + Initializes a new instance of the class. + Type of the registered service. + The registered expression. + + + Gets the registered service type that is currently requested. + The registered service type that is currently requested. + + + Gets or sets the currently registered . + The current registration. + Thrown when the supplied value is a null reference. + + + Gets or sets the current lifestyle of the registration. + The original lifestyle of the registration. + + + + Gets the collection of currently known relationships. This information is used by the Diagnostics + Debug View. Change the contents of this collection to represent the changes made to the + Expression property (if any). This allows + the Diagnostics Debug View to analyze those new relationships as well. + + The collection of instances. + + + + A map containing a generic argument (such as T) and the concrete type (such as Int32) that it + represents. + + + + Implements equality. Needed for doing LINQ distinct operations. + The other to compare to. + True or false. + + + Overrides the default hash code. Needed for doing LINQ distinct operations. + An 32 bit integer. + + + + An instance of this type can be injected into constructors of decorator classes that are registered + using RegisterDecorator. This type contains + contextual information about the applied decoration and it allows users to examine the given instance + to make runtime decisions. + + + + + Gets the closed generic service type for which the decorator is about to be applied. The original + service type will be returned, even if other decorators have already been applied to this type. + + The closed generic service type. + + + + Gets the type of the implementation that is created by the container and for which the decorator + is about to be applied. The original implementation type will be returned, even if other decorators + have already been applied to this type. Please not that the implementation type can not always be + determined. In that case the closed generic service type will be returned. + + The implementation type. + + + + Gets the list of the types of decorators that have already been applied to this instance. + + The applied decorators. + + + + Gets the current object that describes the intention to create a new + instance with its currently applied decorators. + + The current expression that is about to be decorated. + + + + Extension methods for applying decorators. + + + + + Ensures that the supplied decorator is returned and cached with + the given , wrapping the original registered + , by injecting that service type into the constructor of the + supplied . Multiple decorators may be applied to the same + . Decorators can be applied to both open, closed, and non-generic + service types. + + + + The RegisterOpenGenericDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterOpenGenericDecorator on the same service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The registered may have a constructor with an argument of type + where T is . In this case, the + will not inject the decorated itself into the + instance, but it will inject a that allows + creating instances of the decorated type, according to the lifestyle of that type. This enables + more advanced scenarios, such as executing the decorated types on a different thread, or executing + decorated instance within a certain scope (such as a lifetime scope). + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + The lifestyle that specifies how the returned decorator will be cached. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or + implement , when + does not have a single public constructor, or when does + not contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that the supplied decorator is returned when the supplied + returns true and cached with the given + , wrapping the original registered , by + injecting that service type into the constructor of the supplied . + Multiple decorators may be applied to the same . Decorators can be + applied to both open, closed, and non-generic service types. + + + + The RegisterOpenGenericDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterOpenGenericDecorator on the same service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The registered may have a constructor with an argument of type + where T is . In this case, the + will not inject the decorated itself into the + instance, but it will inject a that allows + creating instances of the decorated type, according to the lifestyle of that type. This enables + more advanced scenarios, such as executing the decorated types on a different thread, or executing + decorated instance within a certain scope (such as a lifetime scope). + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + The lifestyle that specifies how the returned decorator will be cached. + The predicate that determines whether the + must be applied to a service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or + implement , when + does not have a single public constructor, or when does + not contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that the decorator type that is returned from is + supplied when the supplied returns true and cached with the given + , wrapping the original registered , by + injecting that service type into the constructor of the decorator type that is returned by the + supplied . + Multiple decorators may be applied to the same . Decorators can be + applied to both open, closed, and non-generic service types. + + + + The types returned from the may be open-generic. The + container will try to fill in the generic parameters based on the resolved service type. + + + The RegisterOpenGenericDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterOpenGenericDecorator on the same service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The type returned from may have a constructor with an + argument of type where T is . In this + case, the framework will not inject the decorated itself into the + decorator instance, but it will inject a that allows + creating instances of the decorated type, according to the lifestyle of that type. This enables + more advanced scenarios, such as executing the decorated types on a different thread, or executing + decorated instance within a certain scope (such as a lifetime scope). + + + + The following is an example of the registration of a decorator through the factory delegate: + , MoveCustomerCommandHandler>(); + + container.RegisterDecorator( + typeof(ICommandHandler<>), + context => typeof(LoggingCommandHandler<,>).MakeGenericType( + typeof(LoggingCommandHandler<,>).GetGenericArguments().First(), + context.ImplementationType), + Lifestyle.Transient, + context => true); + + var handler = container.GetInstance>(); + + Assert.IsInstanceOfType(handler, + typeof(LoggingCommandHandler)); + + ]]> + The code above allows a generic LoggingCommandHandler<TCommand, TImplementation> to + be applied to command handlers, where the second generic argument will be filled in using the + contextual information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the decorator type returned by the supplied . + A factory that allows building Type objects that define the + decorators to inject, based on the given contextual information. The delegate is allowed to return + open-generic types. + The lifestyle that specifies how the returned decorator will be cached. + The predicate that determines whether the decorator must be applied to a + service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type. + + + + Ensures that the supplied decorator is returned, wrapping the + original registered , by injecting that service type into the + constructor of the supplied . Multiple decorators may be applied + to the same . Decorators can be applied to both open, closed, and + non-generic service types. By default, a new instance will be + returned on each request (according the Transient lifestyle), + independently of the lifestyle of the wrapped service. + + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + + The RegisterDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterDecorator on the same generic service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The registered may have a constructor with an argument of type + where T is . In this case, an decorated + instance will not injected into the , but it will inject a + that allows creating instances of the decorated type, according to the + lifestyle of that type. This enables more advanced scenarios, such as executing the decorated + types on a different thread, or executing decorated instance within a certain scope (such as a + lifetime scope). + + + + The following example shows the definition of a generic ICommandHandler<T> interface, + a CustomerMovedCommandHandler implementing that interface, and a + ValidatorCommandHandlerDecorator<T> that acts as a decorator for that interface. + + { + void Handle(TCommand command); + } + + public class CustomerMovedCommand + { + [Required] + public int CustomerId { get; set; } + + [Required] + public Address Address { get; set; } + } + + public class CustomerMovedCommandHandler + : ICommandHandler + { + public void Handle(CustomerMovedCommand command) + { + // some logic + } + } + + // Decorator that validates commands before they get executed. + public class ValidatorCommandHandlerDecorator + : ICommandHandler + { + private readonly ICommandHandler decoratedHandler; + private readonly Container container; + + public ValidatorCommandHandlerDecorator( + ICommandHandler decoratedHandler, + Container container) + { + this.decoratedHandler = decoratedHandler; + this.container = container; + } + + public void Handle(TCommand command) + { + this.Validate(command); + + this.decoratedHandler.Handle(command); + } + + private void Validate(TCommand command) + { + var validationContext = + new ValidationContext(command, this.container, null); + + Validator.ValidateObject(command, validationContext); + } + } + + // Decorator that measures the time it takes to execute a command. + public class MonitoringCommandHandlerDecorator + : ICommandHandler + { + private readonly ICommandHandler decoratedHandler; + private readonly ILogger logger; + + public MonitoringCommandHandlerDecorator( + ICommandHandler decoratedHandler, + ILogger logger) + { + this.decoratedHandler = decoratedHandler; + this.logger = logger; + } + + public void Handle(TCommand command) + { + var watch = Stopwatch.StartNew(); + + this.decoratedHandler.Handle(command); + + this.logger.Log(string.Format("{0} executed in {1} ms.", + command.GetType().Name, watch.ElapsedMilliseconds)); + } + } + + [TestMethod] + public static void TestRegisterOpenGenericDecorator() + { + // Arrange + var container = new Container(); + + container.RegisterSingle(); + + // Search the given assembly and register all concrete types that + // implement ICommandHandler. + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), + typeof(ICommandHandler<>).Assembly); + + // Wrap all ICommandHandler service types with a decorator + // that measures and logs the duration of that handler. + container.RegisterDecorator(typeof(ICommandHandler<>), + typeof(MonitoringCommandHandlerDecorator<>)); + + // Wrap all ICommandHandler types (in this case it will + // wrap the monitoring decorator), but only if the TCommand contains + // any properties. + container.RegisterDecorator(typeof(ICommandHandler<>), + typeof(ValidatorCommandHandlerDecorator<>), context => + { + var commandType = context.ServiceType.GetGenericArguments()[0]; + bool mustDecorate = commandType.GetProperties().Any(); + return mustDecorate; + }); + + // Act + var handler = + container.GetInstance>(); + + // Assert + Assert.IsInstanceOfType(handler, + typeof(ValidatorCommandHandlerDecorator)); + } + ]]> + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or implement + , when does not + have a single public constructor, or when does not + contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that the supplied decorator is returned when the supplied + returns true, wrapping the original registered + , by injecting that service type into the constructor of the + supplied . Multiple decorators may be applied to the same + . Decorators can be applied to both open, closed, and non-generic + service types. By default, a new instance will be returned on + each request (according the Transient lifestyle), + independently of the lifestyle of the wrapped service. + + + + This method uses the container's + LifestyleSelectionBehavior to select + the exact lifestyle for the specified type. By default this will be + Transient. + + + The RegisterOpenGenericDecorator method works by hooking onto the container's + ExpressionBuilt event. This event fires after the + ResolveUnregisteredType event, which allows + decoration of types that are resolved using unregistered type resolution. The + RegisterOpenGeneric + extension method, for instance, hooks onto the ResolveUnregisteredType. This allows you to + use RegisterOpenGenericDecorator on the same service type as RegisterOpenGeneric. + + + Multiple decorators can be applied to the same service type. The order in which they are registered + is the order they get applied in. This means that the decorator that gets registered first, gets + applied first, which means that the next registered decorator, will wrap the first decorator, which + wraps the original service type. + + + Constructor injection will be used on that type, and although it may have many constructor + arguments, it must have exactly one argument of the type of , or an + argument of type where TResult is . + An exception will be thrown when this is not the case. + + + The registered may have a constructor with an argument of type + where T is . In this case, the + will not inject the decorated itself into the + instance, but it will inject a that allows + creating instances of the decorated type, according to the lifestyle of that type. This enables + more advanced scenarios, such as executing the decorated types on a different thread, or executing + decorated instance within a certain scope (such as a lifetime scope). + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + The predicate that determines whether the + must be applied to a service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or + implement , when + does not have a single public constructor, or when does + not contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that a single instance of the supplied decorator is + returned, wrapping the original registered , by injecting that + service type into the constructor of the supplied . Multiple + decorators may be applied to the same . Decorators can be applied + to both open, closed, and non-generic service types. + + + + This method ensures that a single instance of the supplied is + returned, no matter what the lifestyle of the wrapped service type is. Use with care, because the + wrapped service type will also become a singleton. This method is especially useful when use for + injecting factory methods, which will allow the wrapped service type to get + it's own lifestyle back. + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or implement + , when does not + have a single public constructor, or when does not + contain a constructor that has exactly one argument of type + or where T is + . + + + + Ensures that the supplied decorator is returned when the supplied + returns true, wrapping the original registered + , by injecting that service type into the constructor of the + supplied . Multiple decorators may be applied to the same + . Decorators can be applied to both open, closed, and non-generic + service types. + + + + This method ensures that a single instance of the supplied is + returned, no matter what the lifestyle of the wrapped service type is. Use with care, because the + wrapped service type will also become a singleton. This method is especially useful when use for + injecting factory methods, which will allow the wrapped service type to get + it's own lifestyle back. + + + + Please see the RegisterDecorator method + for more information. + + The container to make the registrations in. + The definition of the open generic service type that will + be wrapped by the given . + The definition of the open generic decorator type that will + be used to wrap the original service type. + The predicate that determines whether the + must be applied to a service type. + Thrown when one of the arguments is a null reference. + Thrown when is not + an open generic type, when does not inherit from or + implement , when + does not have a single public constructor, or when does + not contain a constructor that has exactly one argument of type + or where T is + . + + + + An instance of this type will be supplied to the + delegate that is that is supplied to the + RegisterDecorator + overload that takes this delegate. This type contains information about the decoration that is about + to be applied and it allows users to examine the given instance to see whether the decorator should + be applied or not. + + + Please see the + RegisterDecorator + method for more information. + + + + + Gets the closed generic service type for which the decorator is about to be applied. The original + service type will be returned, even if other decorators have already been applied to this type. + + The closed generic service type. + + + + Gets the type of the implementation that is created by the container and for which the decorator + is about to be applied. The original implementation type will be returned, even if other decorators + have already been applied to this type. Please not that the implementation type can not always be + determined. In that case the closed generic service type will be returned. + + The implementation type. + + + + Gets the list of the types of decorators that have already been applied to this instance. + + The applied decorators. + + + + Gets the current object that describes the intention to create a new + instance with its currently applied decorators. + + The current expression that is about to be decorated. + + + + Hooks into the building process and adds a decorator if needed. + + + + + A Registration implements lifestyle based caching for a single service and allows building an + that describes the creation of the service. + + + implementations create a new Registration instance for each registered + service type. s returned from the + BuildExpression method can be intercepted by any event + registered with , have + initializers + applied, and the caching particular to its lifestyle have been applied. Interception using the + Container.ExpressionBuilt will not + be applied in the Registration, but will be applied in . + + See the documentation for an example. + + + + + Initializes a new instance of the class. + + The this that created this registration. + The instance for this registration. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + + Builds a new with the correct caching (according to the specifications of + its ) applied. + + An . + + + + Gets the list of instances. Note that the list is only available + after calling . + + A new array containing the instances. + + + + Initializes an already created instance and applies properties and initializers to that instance. + + + This method is especially useful in integration scenarios where the given platform is in control + of creating certain types. By passing the instance created by the platform to this method, the + container is still able to apply any properties (as defined using a custom + ) and by applying any initializers. + + The instance to initialize. + Thrown when is a null reference + (Nothing in VB). + Thrown when the supplied is not + of type . + + + + Builds a delegate for the creation of the + using the supplied . The returned might + be intercepted by a + Container.ExpressionBuilding event, + and the will have been wrapped with a delegate that executes the + registered initializers + that are applicable to the given (if any). + + The interface or base type that can be used to retrieve instances. + + The delegate supplied by the user that allows building or creating new instances. + A delegate. + + + + Builds a delegate for the creation of . + The returned might be intercepted by a + Container.ExpressionBuilding event, + and the creation of the will have been wrapped with a + delegate that executes the registered + initializers + that are applicable to the given (if any). + + The interface or base type that can be used to retrieve instances. + The concrete type that will be registered. + A delegate. + + + + Builds an that describes the creation of the + using the supplied . The returned might + be intercepted by a + Container.ExpressionBuilding event, + and the will have been wrapped with a delegate that executes the + registered initializers that are + applicable to the given (if any). + + The interface or base type that can be used to retrieve instances. + + The delegate supplied by the user that allows building or creating new instances. + An . + + + + Builds an that describes the creation of + . The returned might be intercepted + by a Container.ExpressionBuilding + event, and the creation of the will have been wrapped with + a delegate that executes the registered + initializers + that are applicable to the given (if any). + + The interface or base type that can be used to retrieve instances. + The concrete type that will be registered. + An . + + + Gets the type that this instance will create. + The type that this instance will create. + + + Gets the this that created this registration. + The this that created this registration. + + + Gets the instance for this registration. + The instance for this registration. + + + + Helper methods for the extensions. + + + + + Allows retrieving the concrete types of the generic type arguments of that must be used to create a + closed generic implementation of a given open generic implementation, based on on the concrete + arguments of the given closed base type. + + + + + Helper class for building closed generic type for a given open generic type and a closed generic base. + + + + Result of the GenericTypeBuilder. + + + + A open generic type with the concrete arguments that can be used to create a closed generic type. + + + + + Represents the method that will called to register one or multiple concrete non-generic + of the given closed generic type + . + + The service type that needs to be registered. + One or more concrete types that implement the given + . + + + { + foreach (Type implementation in implementations) + { + container.RegisterSingle(implementation); + } + + container.RegisterAll(closedServiceType, implementations); + }; + + container.RegisterManyForOpenGeneric( + typeof(ICommandHandler<>), + registerAsCollectionAsSingletons, + typeof(ICommandHandler<>).Assembly); + ]]> + The BatchRegistrationCallback can be supplied to some overloads of the + RegisterManyForOpenGeneric extension methods. + The default behavior of the RegisterManyForOpenGeneric methods is to register a closed generic + type with the corresponding implementation (and will throw when multiple implementations are found for + a single closed generic service type). The given example overrides this default registration by + registering the found list of implementations (one or more) as collection of singletons for the given + closed generic service type. + + + + Defines the accessibility of the types to search. + This type is not available in Silverlight. + + + Load both public as internal types from the given assemblies. + + + Only load publicly exposed types from the given assemblies. + + + + Provides a set of static (Shared in Visual Basic) methods for registration many concrete types at + once that implement the same open generic service types in the . + + + + + Registers all concrete, non-generic, public and internal types in the given set of + that implement the given + with a transient lifetime. + + The container to make the registrations in. + The definition of the open generic type. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic, public and internal types that are located in the given + that implement the given + with a transient lifetime. + + The container to make the registrations in. + The definition of the open generic type. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic, public and internal types in the given set of + that implement the given + with the supplied . When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will point at the same registration and return the same instance based on the caching + behavior of the supplied . + + The container to make the registrations in. + The definition of the open generic type. + The lifestyle that will be used for the registration of the types. + A list of assemblies that will be searched. + Thrown when , + , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic, public and internal types that are located in the given + that implement the given + with the supplied . When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will point at the same registration and return the same instance based on the caching + behavior of the supplied . + + The container to make the registrations in. + The definition of the open generic type. + The lifestyle that will be used for the registration of the types. + A list of assemblies that will be searched. + Thrown when , + , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Allows registration of all concrete, public and internal, non-generic types that are located in the given set of + that implement the given , + by supplying a delegate, that will be called for each + found closed generic implementation of the given . + + The container to make the registrations in. + The definition of the open generic type. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + A list of assemblies that will be searched. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type. + + + + Allows registration of all concrete, public and internal, non-generic types that are located in the given set of + that implement the given , + by supplying a delegate, that will be called for each + found closed generic implementation of the given . + + The container to make the registrations in. + The definition of the open generic type. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + A list of assemblies that will be searched. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type. + + + + Registers all concrete, non-generic, public and internal types that are located in the given + that implement the given + with a singleton lifetime. + + The container to make the registrations in. + The definition of the open generic type. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic, public and internal types that are located in the given + that implement the given + with a singleton lifetime. + + The container to make the registrations in. + The definition of the open generic type. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all supplied by a closed generic definition of the + given with a transient lifetime. + + The container to make the registrations in. + The definition of the open generic type. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all supplied by a closed generic definition of the + given with a transient lifetime. + + The container to make the registrations in. + The definition of the open generic type. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Allows registration of all supplied by a closed generic + definition of the given , by supplying a + delegate, that will be called for each found closed generic + implementation. + If the list contains open generic types, matching closed generic versions of each open generic + type will be added to the list of implementations that is passed on to the + delegate. + + The container to make the registrations in. + The definition of the open generic type. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + The list of types that must be registered according to the given + definition. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + + + + Registers all supplied by a closed generic definition of the + given with a singleton lifetime. + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will return the exact same instance. + + The container to make the registrations in. + The definition of the open generic type. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all supplied by a closed generic definition of the + given with the supplied . + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will return the exact same instance. + + The container to make the registrations in. + The definition of the open generic type. + The lifestyle the registrations are made in. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all supplied by a closed generic definition of the + given with a singleton lifetime. + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will return the exact same instance. + + The container to make the registrations in. + The definition of the open generic type. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all supplied by a closed generic definition of the + given with the supplied + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will return the exact same instance. + + The container to make the registrations in. + The definition of the open generic type. + The lifestyle the registrations are made in. + The list of types that must be registered according to the given + definition. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when contains a null + (Nothing in VB) element, when the is not an open generic + type, or one of the types supplied in does not implement a + closed version of . + + Thrown when there are multiple types in the given + collection that implement the same closed version of the + supplied . + + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with a transient lifetime. + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same closed generic + version of the given . + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with a transient lifetime. + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type or when the argument contains an invalid + value. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with the supplied . + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will point at the same registration and return the same instance based on the caching + behavior of the supplied . + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + The lifestyle that will be used for the registration of the types. + A list of assemblies that will be searched. + Thrown when , + , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same closed generic + version of the given . + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with the supplied . + When a found type implements multiple + closed-generic versions of the given , both closed-generic + service types will point at the same registration and return the same instance based on the caching + behavior of the supplied . + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + The lifestyle that will be used for the registration of the types. + A list of assemblies that will be searched. + Thrown when , + , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Allows registration of all concrete, non-generic types with the given + that are located in the given set of + that implement the given , by supplying a + delegate, that will be called for each found closed generic + implementation of the given . + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + A list of assemblies that will be searched. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + + + + Allows registration of all concrete, non-generic types with the given + that are located in the given set of + that implement the given , by supplying a + delegate, that will be called for each found closed generic + implementation of the given . + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + The delegate that will be called for each found closed generic version of + the given open generic to do the actual registration. + A list of assemblies that will be searched. + Thrown when , + , , or + contain a null reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with a singleton lifetime. + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same closed generic + version of the given . + + + + Registers all concrete, non-generic types with the given + that are located in the given that implement the given + with a singleton lifetime. + + This method is not available in Silverlight. + The container to make the registrations in. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + Thrown when , + , or contain a null + reference (Nothing in VB). + Thrown when is not + an open generic type or when contains an invalid value. + Thrown when the given set of + contain multiple types that implement the same + closed generic version of the given . + + + + Returns all types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), AccessibilityOption.PublicTypesOnly, + typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the + registration. + + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + A list of types. + Thrown when + contains an invalid value. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), AccessibilityOption.PublicTypesOnly, + typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the registration. + + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + A list of types. + Thrown when + contains an invalid value. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), AccessibilityOption.PublicTypesOnly, + typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the + registration. + + The container to use. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + A list of types. + Thrown when + contains an invalid value. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), AccessibilityOption.PublicTypesOnly, + typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the registration. + + The container to use. + The definition of the open generic type. + Defines which types should be used from the given assemblies. + A list of assemblies that will be searched. + A list of types. + Thrown when + contains an invalid value. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all public and internal types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the + registration. + + The definition of the open generic type. + A list of assemblies that will be searched. + A list of types. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all public and internal types that are located in the supplied + and implement or inherit from the supplied . + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the registration. + + The definition of the open generic type. + A list of assemblies that will be searched. + A list of types. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all public and internal types that are located in the supplied + and implement or inherit from the supplied . + Types that are considered to be decorators are not returned. + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the + registration. + + The container to use. + The definition of the open generic type. + A list of assemblies that will be searched. + A list of types. + Thrown when , or + contain a null reference (Nothing in VB). + + + + Returns all public and internal types that are located in the supplied + and implement or inherit from the supplied . + Types that are considered to be decorators are not returned. + + + Use this method when you need influence the types that are registered using + RegisterManyForOpenGeneric. + The RegisterManyForOpenGeneric overloads that take a collection of + objects use this method to get the list of types that need to be registered. Instead of calling + such overload, you can call an overload that takes a list of objects and pass + in a filtered result from this GetTypesToRegister method. + ), typeof(ICommandHandler<>).Assembly) + .Where(type => !type.Name.EndsWith("Decorator")); + + container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), types); + ]]> + This example calls the GetTypesToRegister method to request a list of concrete implementations + of the ICommandHandler<T> interface from the assembly of that interface. After that + all types which name ends with 'Decorator' are filtered out. This list is supplied to an + RegisterManyForOpenGeneric + overload that takes a list of types to finish the registration. + + The container to use. + The definition of the open generic type. + A list of assemblies that will be searched. + A list of types. + Thrown when , or + contain a null reference (Nothing in VB). + + + + An instance of this type will be supplied to the + delegate that is that is supplied to the + RegisterOpenGeneric + overload that takes this delegate. This type contains information about the open generic service that is about + to be created and it allows the user to examine the given instance to decide whether this implementation should + be created or not. + + + Please see the + RegisterOpenGeneric + method for more information. + + + + Gets the closed generic service type that is to be created. + The closed generic service type. + + + Gets the closed generic implementation type that will be created by the container. + The implementation type. + + + Gets a value indicating whether a previous RegisterOpenGeneric registration has already + been applied for the given . + The indication whether the event has been handled. + + + + Provides a set of static (Shared in Visual Basic) methods for registration of open generic service + types in the . + + + + + Registers that a new instance of will be returned + every time a is requested. + + + Please see the + RegisterOpenGeneric(Container,Type,Type,Lifestyle) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The definition of the open generic implementation type + that will be returned when a is requested. + + + + Registers that the same instance of will be returned + every time a is requested. + + + Please see the + RegisterOpenGeneric(Container,Type,Type,Lifestyle) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances.. + The definition of the open generic implementation type + that will be returned when a is requested. + + + + Registers that a closed generic instance of the supplied + will be returned when a closed generic version of + the is requested. The instance will be cached + according to the specified . + + + Types registered using the RegisterOpenGeneric are resolved using unregistered type + resolution. This means that an explicit registration made for a closed generic version of the + always gets resolved first and the given + only gets resolved when there is no such registration. + + + The following example shows the definition of a generic IValidator<T> interface + and, a NullValidator<T> implementation and a specific validator for Orders. + The registration ensures a OrderValidator is returned when a + IValidator<Order> is requested. For all requests for a + IValidator<T> other than a IValidator<Order>, an + implementation of NullValidator<T> will be returned. + + { + void Validate(T instance); + } + + public class NullValidator : IValidator + { + public void Validate(T instance) + { + } + } + + public class OrderValidator : IValidator + { + public void Validate(Order instance) + { + if (instance.Total < 0) + { + throw new ValidationException("Total can not be negative."); + } + } + } + + [TestMethod] + public static void TestRegisterOpenGeneric() + { + // Arrange + var container = new Container(); + + container.Register, OrderValidator>(Lifestyle.Transient); + container.RegisterOpenGeneric(typeof(IValidator<>), typeof(NullValidator<>), Lifestyle.Singleton); + + // Act + var orderValidator = container.GetInstance>(); + var customerValidator = container.GetInstance>(); + var productValidator = container.GetInstance>(); + + // Assert + Assert.IsInstanceOfType(orderValidator, typeof(OrderValidator)); + Assert.IsInstanceOfType(customerValidator, typeof(NullValidator)); + Assert.IsInstanceOfType(productValidator, typeof(NullValidator)); + } + ]]> + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The definition of the open generic implementation type + that will be returned when a is requested. + The lifestyle that defines how returned instances are cached. + + + + Registers that the same instance of will be returned + every time a is requested. + + + Please see the + RegisterOpenGeneric(Container,Type,Type,Lifestyle) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances.. + The definition of the open generic implementation type + that will be returned when a is requested. + The lifestyle that defines how returned instances are cached. + The predicate that determines whether the + can implement the service type. + + + + Registers that instances of will be returned + when a collection of is requested. New instances of + the registered will be returned whenever the + resolved collection is iterated. + + + Please see the + RegisterAllOpenGeneric(Container,Type,Lifestyle,IEnumerable<Type>) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The list of open generic implementation types + that will be returned when a collection of is requested. + + + + + Registers that instances of will be returned + when a collection of is requested. New instances of + the registered will be returned whenever the + resolved collection is iterated. + + + Please see the + RegisterAllOpenGeneric(Container,Type,Lifestyle,IEnumerable<Type>) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The list of open generic implementation types + that will be returned when a collection of is requested. + + + + + Registers that instances of will be returned + when a collection of is requested. The instances will be + cached according to the specified . + + + Please see the + RegisterAllOpenGeneric(Container,Type,Lifestyle,IEnumerable<Type>) + overload for an example. + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The lifestyle that defines how returned instances are cached. + The list of open generic implementation types + that will be returned when a collection of is requested. + + + + + Registers that instances of will be returned + when a collection of is requested. The instances will be + cached according to the specified . + + + + Collections registered using the RegisterAllOpenGeneric are resolved using unregistered type + resolution. This means that an explicit registration made for a collection of the closed generic + version of the always gets resolved first and a + collection of only gets resolved when there is no + such registration. + + + + The following example shows the definition of a generic IValidator<T> interface + and, a NullValidator<T> implementation and a specific validator for Orders. + The registration ensures a OrderValidator is returned when a + IValidator<Order> is requested. For all requests for a + IValidator<T> other than a IValidator<Order>, an + implementation of NullValidator<T> will be returned. + + { + void Validate(T instance); + } + + public class DefaultValidator : IValidator + { + public void Validate(T instance) + { + // some default validation + } + } + + [TestMethod] + public static void TestRegisterAllOpenGeneric() + { + // Arrange + var container = new Container(); + + Type[] types = new[] { typeof(OrderValidator), typeof(DefaultValidator<>) }; + + container.RegisterManyForOpenGeneric(typeof(IValidator<>), + (serviceType, implementationTypes) => container.RegisterAll(serviceType, implementationTypes), + types); + + container.RegisterAllOpenGeneric(typeof(IValidator<>), typeof(DefaultValidator<>)); + + // Act + var orderValidators = container.GetAllInstances>(); + var customerValidators = container.GetAllInstances>(); + + // Assert + Assert.IsTrue(orderValidators.SequenceEqual( + new[] { typeof(OrderValidator), typeof(DefaultValidator) })); + + // Without the call to RegisterAllOpenGeneric this customerValidators would be empty. + Assert.IsTrue(customerValidators.SequenceEqual(new[] { typeof(DefaultValidator) })); + } + ]]> + + The container to make the registrations in. + The definition of the open generic service type that can be + used to retrieve instances. + The lifestyle that defines how returned instances are cached. + The list of open generic implementation types + that will be returned when a collection of is requested. + + + + Resolves a given open generic type. + + + + Allows validating an ArgumentMapping. + + + + + Helper methods for the container. + + + + + Produces instances for a given registration. Instances of this type are generally created by the + container when calling one of the Register overloads. Instances can be retrieved by calling + or . + + + The Register method overloads create InstanceProducer instances internally, but + InstanceProducers can be created manually to implement special scenarios. An + InstanceProducer wraps instance. The Registration builds an + that describes the intend to create the instance according to a certain + lifestyle. The InstanceProducer on the other hand transforms this Expression to a + delegate and allows the actual instance to be created. A Registration itself can't create any + instance. The InsanceProducer allows intercepting created instances by hooking onto the + Container.ExpressionBuilt event. The + RegisterDecorator + extension methods for instance work by hooking onto the ExpressionBuilt event and allow + wrapping the returned instance with a decorator. + + + The following example shows the creation of two different InstanceProducer instances that wrap + the same Registration instance. Since the Registration is created using the + Singleton lifestyle, both producers will return + the same instance. The InstanceProducer for the Interface1 however, will wrap that + instance in a (transient) Interface1Decorator. + (container); + + var producer1 = new InstanceProducer(typeof(Interface1), registration); + var producer2 = new InstanceProducer(typeof(Interface2), registration); + + container.RegisterDecorator(typeof(Interface1), typeof(Interface1Decorator)); + + var instance1 = (Interface1)producer1.GetInstance(); + var instance2 = (Interface2)producer2.GetInstance(); + + Assert.IsInstanceOfType(instance1, typeof(Interface1Decorator)); + Assert.IsInstanceOfType(instance2, typeof(ServiceImpl)); + + Assert.AreSame(((Interface1Decorator)instance1).DecoratedInstance, instance2); + ]]> + + + + Initializes a new instance of the class. + The service type for which this instance is created. + The . + + + Produces an instance. + An instance. Will never return null. + When the instance could not be retrieved or is null. + + + + Builds an expression that expresses the intent to get an instance by the current producer. A call + to this method locks the container. No new registrations can't be made after a call to this method. + + An Expression. + + + + Gets the collection of relationships for this instance that the container knows about. + This includes relationships between the registered type and its dependencies and relationships + between applied decorators and their dependencies. Note that types that are not newed up by the + container, property dependencies that are injected using the (legacy) + InjectProperties method, and + properties that are injected inside a custom delegate that is registered using the + RegisterInitializer method are unknown + to the container and are not returned from this method. + Also note that this method will return an empty collection when called before the the + registered type is requested from the container (or before Verify + is called). + + An array of instances. + + + + Builds a string representation of the object graph with the current instance as root of the + graph. + + A string representation of the object graph. + Thrown when this method is called before + or have been called. These calls can be + done directly and explicitly by the user on this instance, indirectly by calling + or on an instance that depends on this + instance, or by calling Verify on the container. + + + + Gets the for this registration. The returned lifestyle can differ from the + lifestyle that is used during the registration. This can happen for instance when the registration + is changed by an ExpressionBuilt registration or + gets decorated. + + The for this registration. + + + Gets the service type for which this producer produces instances. + A instance. + + + Gets the instance for this instance. + The . + + + + Factory for the creation of a delegate that applies caching to the supplied + . + + A factory for creating new instances. + A factory that returns cached instances. + + + + Instances returned from the container can be cached. The contains several + overloads of the Register method that take a Lifestyle instance as argument to define + how returned instances should be cached. The core library contains two lifestyles out of the box. By + supplying Lifestyle.Transient, the registered instance is not + cached; a new instance is returned every time it is requested or injected. By supplying + Lifestyle.Singleton instances can be cached indefinitely; only + a single instance of the registered component will be returned by that container instance. Other + lifestyles are defined in integration and extension packages. The + CreateCustom method allows defining a custom lifestyle and + the CreateHybrid method + allows creating a lifestyle that mixes multiple other lifestyles. + + + This type is abstract and can be overridden to implement a custom lifestyle. + + + + + The lifestyle instance that doesn't cache instances. A new instance of the specified + component is created every time the registered service it is requested or injected. + + + The following example registers the SomeServiceImpl implementation for the + ISomeService service type using the Transient lifestyle: + (Lifestyle.Transient); + ]]> + Note that Transient is the default lifestyle, the previous registration can be reduced to + the following: + (); + ]]> + + + + + The lifestyle that caches components during the lifetime of the instance + and guarantees that only a single instance of that component is created for that instance. Since + general use is to create a single Container instance for the lifetime of the application / + AppDomain, this would mean that only a single instance of that component would exist during the + lifetime of the application. In a multi-threaded applications, implementations registered using + this lifestyle must be thread-safe. + + + The following example registers the RealTimeProvider implementation for the + ITimeProvider service type using the Singleton lifestyle: + (Lifestyle.Singleton); + ]]> + Note that using the + RegisterSingle method has + the same effect: + (); + ]]> + + + + Initializes a new instance of the class. + The user friendly name of this lifestyle. + Thrown when is null (Nothing in VB) + or an empty string. + + + + The hybrid lifestyle allows mixing two lifestyles in a single registration. Based on the supplied + delegate the hybrid lifestyle will redirect the creation of + the instance to the correct lifestyle. The result of the + delegate will not be cached; it is invoked each time an instance is requested or injected. By + nesting hybrid lifestyles, any number of lifestyles can be mixed. + + The delegate that determines which + lifestyle should be used. The will be used if true is + returned; the otherwise. This delegate will be called every + time an instance needs to be resolved or injected. + The lifestyle to use when + returns true. + The lifestyle to use when + returns false. + A new hybrid lifestyle that wraps the supplied lifestyles. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + The following example shows the creation of a HybridLifestyle that mixes an + WebRequestLifestyle and LifetimeScopeLifestyle: + + HttpContext.Current != null, + new WebRequestLifestyle(), + new LifetimeScopeLifestyle()); + + // The created lifestyle can be reused for many registrations. + container.Register(mixedScopeLifestyle); + container.Register(mixedScopeLifestyle); + ]]> + + Hybrid lifestyles can be nested: + + container.GetCurrentLifetimeScope() != null, + new LifetimeScopeLifestyle(), + Lifestyle.Transient); + + var mixedScopeLifestyle = Lifestyle.CreateHybrid( + () => HttpContext.Current != null, + new WebRequestLifestyle(), + mixedLifetimeTransientLifestyle); + ]]> + + The mixedScopeLifestyle now mixed three lifestyles: Web Request, Lifetime Scope and + Transient. + + + + + + The hybrid lifestyle allows mixing two lifestyles in a single registration. Based on the supplied + delegate the hybrid lifestyle will redirect the creation of + the instance to the correct lifestyle. The result of the + delegate will not be cached; it is invoked each time an instance is requested or injected. By + nesting hybrid lifestyles, any number of lifestyles can be mixed. + + The delegate that determines which + lifestyle should be used. The will be used if true is + returned; the otherwise. This delegate will be called every + time an instance needs to be resolved or injected. + The scoped lifestyle to use when + returns true. + The scoped lifestyle to use when + returns false. + A new scoped hybrid lifestyle that wraps the supplied lifestyles. + Thrown when one of the supplied arguments is a null + reference (Nothing in VB). + + + The following example shows the creation of a HybridLifestyle that mixes an + WebRequestLifestyle and LifetimeScopeLifestyle: + + HttpContext.Current != null, + new WebRequestLifestyle(), + new LifetimeScopeLifestyle()); + + // The created lifestyle can be reused for many registrations. + container.Register(mixedScopeLifestyle); + container.Register(mixedScopeLifestyle); + ]]> + + + + + Creates a custom lifestyle using the supplied delegate. + + + The supplied will be called just once per registered + service. The supplied will be called by the framework + when the type is resolved for the first time, and the framework will supply the factory with a + Func<object> for creating new (transient) instances of that type (that might + have been intercepted and + initializers might have been applied). + It is the job of the to return a Func<object> + that applies the proper caching. The Func<object> that is returned by the + will be stored for that registration (every + registration will store its own Func<object> delegate) and this delegate will be + called every time the service is resolved (by calling + container.GetInstance<TService> or when that service is injected into another + type). + + The name of the lifestyle to create. The name is used to display the lifestyle + in the debugger. + A factory delegate that takes a Func<object> delegate + that will produce a transient instance and returns a delegate that returns cached instances. + A new . + Thrown when one of the arguments is a null reference + (Nothing in VB). + Thrown when is an empty string. + + The following example shows the creation of a lifestyle that caches registered instances for 10 + minutes: + + { + TimeSpan timeout = TimeSpan.FromMinutes(10); + var syncRoot = new object(); + var expirationTime = DateTime.MinValue; + object instance = null; + + // If the application has multiple registrations using this lifestyle, each registration + // will get its own Func delegate (created here) and therefore get its own set + // of variables as defined above. + return () => + { + lock (syncRoot) + { + if (expirationTime < DateTime.UtcNow) + { + instance = instanceCreator(); + expirationTime = DateTime.UtcNow.Add(timeout); + } + + return instance; + } + }; + }); + + var container = new Container(); + + // We can reuse the created lifestyle for multiple registrations. + container.Register(customLifestyle); + container.Register(customLifestyle); + ]]> + + + + + Creates a new instance for the given + that will create new instances of specified with the + caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be created. + The instance for which a + must be created. + A new instance. + Thrown when is a null + reference (Nothing in VB). + + + + Creates a new instance for the given + that will create new instances instance using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + A delegate that will create a new instance of + every time it is called. + The instance for which a + must be created. + A new instance. + Thrown when either or + are null references (Nothing in VB). + + + + Creates a new instance for the given + that will create new instances of specified with the + caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + Thrown when on of the supplied arguments is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + Thrown when is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be created. + The instance for which a + must be created. + A new instance. + Thrown when is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + A delegate that will create a new instance of + every time it is called. + The instance for which a + must be created. + A new instance. + Thrown when either or + are null references (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + This method might fail when run in a partial trust sandbox when + is an internal type. + + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + Thrown when on of the supplied arguments is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + This method might fail when run in a partial trust sandbox when + is an internal type. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + Thrown when on of the supplied arguments is a null + reference (Nothing in VB). + + + + Creates a new instance defining the creation of the + specified using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The delegate that will be responsible for creating new instances. + The instance for which a + must be created. + A new instance. + Thrown when on of the supplied arguments is a null + reference (Nothing in VB). + + + + When overridden in a derived class, + creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + + If you are implementing your own lifestyle, override this method to implement the code necessary + to create and return a new . Note that you should always create + a new instance. They should never be cached. + + + + + When overridden in a derived class, + creates a new instance defining the creation of the + specified using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + A delegate that will create a new instance of + every time it is called. + The instance for which a + must be created. + A new instance. + + If you are implementing your own lifestyle, override this method to implement the code necessary + to create and return a new . Note that you should always create + a new instance. They should never be cached. + + + + Gets the user friendly name of this lifestyle. + The user friendly name of this lifestyle. + + + + Gets the length of the lifestyle. Implementers must implement this property. The diagnostic + services use this value to compare lifestyles with each other to determine lifestyle + misconfigurations. + + The representing the length of this lifestyle. + + + + Forwards CreateRegistration calls to the lifestyle that is returned from the registered + container.Options.LifestyleSelectionBehavior. + + + + + Base class for scoped lifestyles. A scoped lifestyle caches instances for the duration of an implicitly + or explicitly defined scope. Such scope can be an (implicitly defined) web request or an explicitly + defined Lifetime Scope. The lifetime of instances registered with a scoped lifestyle is always equal + or bigger than one-instance-per-object-graph. In other words, a call to GetInstance() will never create + more than one instance of such registered type. + + + + Initializes a new instance of the class. + The user friendly name of this lifestyle. + Thrown when is null (Nothing in VB) + or an empty string. + + + Initializes a new instance of the class. + The user friendly name of this lifestyle. + Signals the lifestyle whether instances should be + disposed or not. + Thrown when is null (Nothing in VB) + or an empty string. + + + + Allows registering an delegate that will be called when the scope ends, + but before the scope disposes any instances. + + + During the call to all registered delegates are + processed in the order of registration. Do note that registered actions are not guaranteed + to run. In case an exception is thrown during the call to , the + will stop running any actions that might not have been invoked at that point. + Instances that are registered for disposal using on the other + hand, are guaranteed to be disposed. Note that registered actions won't be invoked during a call + to . + + The instance. + The delegate to run when the scope ends. + Thrown when one of the arguments is a null reference + (Nothing in VB). + Will be thrown when there is currently no active + scope for the supplied . + + + + Adds the to the list of items that will get disposed when the + scope ends. + + + Note to implementers: Instances registered for disposal will have to be disposed in the opposite + order of registration, since disposable components might still need to call disposable dependencies + in their Dispose() method. + + The instance. + The instance that should be disposed when the scope ends. + Thrown when one of the arguments is a null reference + (Nothing in VB). + Will be thrown when there is currently no active + scope for the supplied . + + + + Returns the current for this lifestyle and the given + , or null when this method is executed outside the context of a scope. + + The container instance that is related to the scope to return. + A instance or null when there is no scope active in this context. + + + + Creates a delegate that upon invocation return the current for this + lifestyle and the given , or null when the delegate is executed outside + the context of such scope. + + The container for which the delegate gets created. + A delegate. This method never returns null. + + + + Returns the current for this lifestyle and the given + , or null when this method is executed outside the context of a scope. + + The container instance that is related to the scope to return. + A instance or null when there is no scope active in this context. + + + + Creates a new instance defining the creation of the + specified using the supplied + with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + A delegate that will create a new instance of + every time it is called. + The instance for which a + must be created. + A new instance. + + + + Creates a new instance defining the creation of the + specified with the caching as specified by this lifestyle. + + The interface or base type that can be used to retrieve the instances. + The concrete type that will be registered. + The instance for which a + must be created. + A new instance. + + + + Disposes the list of supplied . The list is iterated in reverse + order (the first element in the list will be disposed last) and the method ensures that the + Dispose method of each element is called, regardless of any exceptions raised from any previously + called Dispose methods. If multiple exceptions are thrown, the last thrown exception will bubble + up the call stack. + + The list of objects to be disposed. + Thrown when the is a null + reference. + + + Internal helper for string resources. + + + + Provides data for and interaction with the + ResolveUnregisteredType event of + the . An observer can check the + to see whether the unregistered type can be handled. The + method can be called to register a delegate + that allows creation of instances of the unregistered for this and future requests. + + + + Initializes a new instance of the UnregisteredTypeEventArgs class. + The unregistered service type. + + + + Registers a delegate that allows creation of instances of the type + expressed by the for this and future requests. The delegate + will be caches and future requests will directly call that delegate. + + The delegate that allows creation of instances of the type + expressed by the . + Thrown when the is a + null reference. + Thrown when multiple observers that have registered to + the ResolveUnregisteredType event + called this method for the same type. + + + + Registers an that describes the creation of instances of the type + expressed by the for this and future requests. The delegate + will be cached and future requests will directly use that expression or the compiled delegate. + + + NOTE: If possible, use the Register(Registration) overload, + since this allows the analysis services to determine any configuration errors on the lifestyle of + the registration. + + The expression that describes the creation of instances of the type + expressed by the . + Thrown when the is a + null reference. + Thrown when multiple observers that have registered to + the ResolveUnregisteredType event + called this method for the same type. + + + + Registers a that describes the creation of instances of the type + expressed by the for this and future requests. The + registration will be cached and future requests will directly call unon that registration, the + expression that it generates or the delegate that gets compiled from that expression. + + The registration that describes the creation of instances according to + the registration's lifestyle of the type expressed by the . + Thrown when the is a + null reference. + Thrown when the is a + not exactly of type where T equals the . + + Thrown when multiple observers that have registered to + the ResolveUnregisteredType event + called this method for the same type. + + + Gets the unregistered service type that is currently requested. + The unregistered service type that is currently requested. + + + + Gets a value indicating whether the event represented by this instance has been handled. + This property will return true when has been called on + this instance. + + The indication whether the event has been handled. + + + + This class is for internal use only. + + + + Gets or sets the value. + The value. + + + diff --git a/packages/repositories.config b/packages/repositories.config index c80dc44..f2cd2cf 100644 --- a/packages/repositories.config +++ b/packages/repositories.config @@ -1,10 +1,11 @@ - - - - - - - - - + + + + + + + + + + \ No newline at end of file

    xiaA=SSbgO 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 literal 0 HcmV?d00001 diff --git a/packages/SimpleInjector.2.6.1/lib/net40-client/SimpleInjector.Diagnostics.xml b/packages/SimpleInjector.2.6.1/lib/net40-client/SimpleInjector.Diagnostics.xml new file mode 100644 index 0000000..254c1bd --- /dev/null +++ b/packages/SimpleInjector.2.6.1/lib/net40-client/SimpleInjector.Diagnostics.xml @@ -0,0 +1,193 @@ + + + + SimpleInjector.Diagnostics + + + +