static void Extend(IUnityContainer container)
{
container.AddExtension(new TypeTracker());
container.AddExtension(new CycleDetector());
container.AddExtension(new InjectionPolicies());
container.AddExtension(new TypeRegistrationRequired());
}
public void CanCreatePoliciesForHandler()
{
ExceptionPolicyData exceptionPolicyData = new ExceptionPolicyData("policy");
settings.ExceptionPolicies.Add(exceptionPolicyData);
ExceptionTypeData exceptionTypeData = new ExceptionTypeData("type1", typeof(Exception), PostHandlingAction.ThrowNewException);
exceptionPolicyData.ExceptionTypes.Add(exceptionTypeData);
ExceptionHandlerData exceptionHandlerData = new ReplaceHandlerData("handler1", "replaced", typeof(ArgumentException).AssemblyQualifiedName);
exceptionTypeData.ExceptionHandlers.Add(exceptionHandlerData);
container.AddExtension(new ExceptionHandlingBlockExtension());
ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("policy");
Exception originalException = new Exception("to be replaced");
try
{
policy.HandleException(originalException);
Assert.Fail("a new exception should have been thrown");
}
catch (ArgumentException e)
{
Assert.AreEqual("replaced", e.Message);
Assert.IsNull(e.InnerException);
}
}
public void Baseline()
{
// Act
Container.AddExtension(extension1);
// Validate
Assert.AreSame(Container, extension1.ExtensionContext.Container);
Assert.IsNotNull(extension1.ExtensionContext.Policies);
}
public void SafeBehaviorPreventsExceptionOnRegisterInstance()
{
Container.RemoveAllExtensions();
Container.AddExtension(new UnitySafeBehaviorExtension());
Container.AddExtension(new InjectedMembers());
Container.AddExtension(new UnityDefaultStrategiesExtension());
Container.RegisterInstance <ITest>(this);
Assert.AreEqual(0, FirstChanceExceptions.Count);
}
public void CanCreatePoliciesForTextFormatter()
{
FormatterData data = new TextFormatterData("name", "template");
loggingSettings.Formatters.Add(data);
container.AddExtension(new LoggingBlockExtension());
TextFormatter createdObject = (TextFormatter)container.Resolve <ILogFormatter>("name");
Assert.IsNotNull(createdObject);
Assert.AreEqual("template", createdObject.Template);
}
internal override void Execute(IUnityContainer container)
{
if (decoratorFunc != null)
{
container.AddExtension(new DecoratorExtension <T>(decoratorFunc));
}
if (action != null)
{
container.AddExtension(new PostBuildUpActionExtension <T>(action));
}
}
public void ExtensionPopulatesTheConfigurationSourcePolicy()
{
IConfigurationSource theAvailableConfigurationSource = null;
container.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource));
container.AddExtension(new TestHelperExtension(
c =>
{
theAvailableConfigurationSource
= c.Policies.Get <IConfigurationObjectPolicy>(typeof(IConfigurationSource)).ConfigurationSource;
}));
Assert.AreSame(configurationSource, theAvailableConfigurationSource);
}
public static void RegisterTypes(IUnityContainer container)
{
container.AddNewExtension <Interception>();
Container.RegisterType <ToDoListEntities>(new Unity.Lifetime.SingletonLifetimeManager());
container.AddExtension(new RegisterModule());
container.AddExtension(new RepositoryRegisterModule());
container.AddExtension(new ServiceRegisterModule());
container.AddNewExtension <Interception>();
}
public void ExceptionHandledThroughLoggingBlock()
{
MockTraceListener.Reset();
container.AddExtension(new ExceptionHandlingBlockExtension());
container.AddExtension(new LoggingBlockExtension());
ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("Logging Policy");
Assert.IsFalse(policy.HandleException(new Exception("TEST EXCEPTION")));
Assert.AreEqual(1, MockTraceListener.LastEntry.Categories.Count);
Assert.IsTrue(MockTraceListener.LastEntry.Categories.Contains("TestCat"));
Assert.AreEqual(5, MockTraceListener.LastEntry.EventId);
Assert.AreEqual(TraceEventType.Error, MockTraceListener.LastEntry.Severity);
Assert.AreEqual("TestTitle", MockTraceListener.LastEntry.Title);
}
public void CanCreatePoliciesForHandler()
{
ExceptionPolicyData exceptionPolicyData = new ExceptionPolicyData("policy");
settings.ExceptionPolicies.Add(exceptionPolicyData);
ExceptionTypeData exceptionTypeData = new ExceptionTypeData("type1", typeof(Exception), PostHandlingAction.ThrowNewException);
exceptionPolicyData.ExceptionTypes.Add(exceptionTypeData);
FaultContractExceptionHandlerData exceptionHandlerData = new FaultContractExceptionHandlerData("handler1",
typeof(MockFaultContract).AssemblyQualifiedName);
exceptionHandlerData.ExceptionMessage = "fault message";
exceptionHandlerData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("Message", "{Message}"));
exceptionHandlerData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("Data", "{Data}"));
exceptionHandlerData.PropertyMappings.Add(new FaultContractExceptionHandlerMappingData("SomeNumber", "{OffendingNumber}"));
exceptionTypeData.ExceptionHandlers.Add(exceptionHandlerData);
container.AddExtension(new ExceptionHandlingBlockExtension());
ExceptionPolicyImpl policy = container.Resolve <ExceptionPolicyImpl>("policy");
NotFiniteNumberException originalException = new NotFiniteNumberException("MyException", 12341234123412);
originalException.Data.Add("someKey", "someValue");
try
{
policy.HandleException(originalException);
Assert.Fail("a new exception should have been thrown");
}
catch (FaultContractWrapperException e)
{
MockFaultContract fault = (MockFaultContract)e.FaultContract;
Assert.AreEqual(originalException.Message, fault.Message);
Assert.AreEqual(originalException.Data.Count, fault.Data.Count);
Assert.AreEqual(originalException.Data["someKey"], fault.Data["someKey"]);
Assert.AreEqual(originalException.OffendingNumber, fault.SomeNumber);
}
}
protected void Application_Start(object sender, EventArgs e)
{
// initialize entity framework 6 profiling
EFProfilingBootstrapper.Initialize();
#region Optional bootstrap code for unity based deep profiling and policy injection based profiling
// Register types to unity container to demo unity based deep profiling & policy injection based profiling.
Container.RegisterType <IDemoDBDataService, DemoDBDataService>(
new ContainerControlledLifetimeManager()
, new InterceptionBehavior <PolicyInjectionBehavior>()); //enable policy injection
Container.RegisterType <IDemoDBService, DemoDBService>(new ContainerControlledLifetimeManager());
// Enable policy injection for interface types registered with PolicyInjectionBehavior
Container.AddNewExtension <Interception>()
.Configure <Interception>()
.SetDefaultInterceptorFor <IDemoDBDataService>(new InterfaceInterceptor());
// Enable deep profiling extension for profiling any interface methods on
// interface types containing "DemoDBService".
// When deep profiling is enabled on specified types, policy injection will be ignored.
Container.AddExtension(new DeepProfilingExtension(new RegexDeepProfilingFilter(new Regex("DemoDBService"))));
#endregion
}
/// <summary>
/// Installs extensions to the container.
/// </summary>
/// <param name="container">Container to modify</param>
/// <param name="extensions">Extensions to install</param>
public static void InstallExtensions(this IUnityContainer container, IEnumerable <UnityContainerExtension> extensions)
{
foreach (var extension in extensions)
{
container.AddExtension(extension);
}
}
protected ViewModelLocator()
{
_unityContainer = new UnityContainer();
_unityContainer.AddExtension(new Diagnostic());
// Providers
// Services
_unityContainer.RegisterType <IDialogService, DialogService>();
RegisterSingleton <INavigationService, NavigationService>();
_unityContainer.RegisterType <IDeserializer, JsonSerializer>();
_unityContainer.RegisterType <IErrorLogger, ErrorLogger>();
//DataServices
_unityContainer.RegisterType <BaseClient>();
_unityContainer.RegisterType <UserDataService>();
_unityContainer.RegisterType <MagazineDataService>();
_unityContainer.RegisterType <AbonnementDataService>();
_unityContainer.RegisterType <PaiementDataService>();
// View models
_unityContainer.RegisterType <LoginViewModel>();
_unityContainer.RegisterType <AccountViewModel>();
_unityContainer.RegisterType <NonAbonnementsViewModel>();
_unityContainer.RegisterType <AbonnementsViewModel>();
_unityContainer.RegisterType <MagazineViewModel>();
_unityContainer.RegisterType <PayementViewModel>();
_unityContainer.RegisterType <ButtonSubscribedMagazineViewModel>();
_unityContainer.RegisterType <ButtonSubscribeMagazineViewModel>();
_unityContainer.RegisterType <MainViewModel>();
}
/// <summary>
/// Add the extension specified in this element to the container.
/// </summary>
/// <param name="container">Container to configure.</param>
protected override void ConfigureContainer(IUnityContainer container)
{
var extensionType = GetExtensionType();
var extension = (UnityContainerExtension)container.Resolve(extensionType);
container.AddExtension(extension);
}
public UnityDependencyEngine()
{
_container = new UnityContainer();
var unityDecoratorExtension = new UnityDecoratorExtension();
_container.AddExtension(unityDecoratorExtension);
}
private void RegisterExtension(string assemblyName, string className)
{
Assembly asm = Load(assemblyName);
ContainerExtension extensions = (ContainerExtension)asm.CreateInstance(className);
_Container.AddExtension(extensions);
}
static void Main(string[] args)
{
var ext = new NLogExtension()
{
GetName = (t, n) => t.FullName
};
_container = new UnityContainer();
_container.AddExtension(ext).
RegisterType <ITestComponent, Baranina>("baranina").
RegisterType <ITestComponent, Cielecina>("cielecina").
RegisterType <ITestConstructorInjection, TestConstructorInjection>();
var _instance = _container.Resolve <Class1>();
_instance.GetName += GetName;
_instance.GetName += GetName2;
_instance.GetName += GetName3;
_instance.GetName += GetName4;
_instance.TestLogging();
ITestComponent baranina = _container.Resolve <Baranina>();
baranina.GetName();
var bar2 = _container.Resolve <ITestComponent>("baranina");
ITestComponent cielecina = _container.Resolve <Cielecina>();
cielecina.GetName();
Console.ReadLine();
}
public void AddExtension(UnityContainerExtension extensionModule)
{
if (extensionModule != null)
{
_container.AddExtension(extensionModule);
}
}
/// <summary>
/// Registers the type mappings with the Unity container.
/// </summary>
/// <param name="container">The unity container to configure.</param>
/// <remarks>
/// There is no need to register concrete types such as controllers or
/// API controllers (unless you want to change the defaults), as Unity
/// allows resolving a concrete type even if it was not previously
/// registered.
/// </remarks>
public static void RegisterTypes(IUnityContainer container)
{
container.RegisterType <Services.ISessionService, Services.SessionService>(new PerRequestLifetimeManager());
var connectionString = ConfigurationManager.ConnectionStrings["DataBaseConnection"].ConnectionString;
container.AddExtension(new ApplicationExtension(connectionString));
}
/// <summary>
/// Add the extensions needed to make everything works. Including EnumerableExtensions.
/// </summary>
/// <param name="container"></param>
/// <returns></returns>
public static IUnityContainer WithAspNetCoreServiceProvider(this IUnityContainer container)
{
container.RegisterType <IServiceProvider, UnityServiceProvider>();
container.RegisterType <IServiceScopeFactory, UnityServiceScopeFactory>();
return(container.AddExtension(new EnumerableExtension()).AddExtension(new CustomBuildExtension()));
}
/// <summary>
/// Creates a new extension object and adds it to the container.
/// </summary>
/// <typeparam name="TExtension">Type of <see cref="UnityContainerExtension"/> to add. The extension type
/// will be resolved from within the supplied <paramref name="container"/>.</typeparam>
/// <param name="container">Container to add the extension to.</param>
/// <returns>The <see cref="Unity.IUnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns>
public static IUnityContainer AddNewExtension <TExtension>(this IUnityContainer container)
where TExtension : UnityContainerExtension
{
TExtension newExtension = (container ?? throw new ArgumentNullException(nameof(container))).Resolve <TExtension>();
return(container.AddExtension(newExtension));
}
public static ITypeFactory Boot(string loggerName,Assembly asm)
{
XmlConfigurator.Configure();
container = new UnityContainer();
RegisterKnownTypes(asm);
RegisterKnownTypes(typeof(ITypeFactory).Assembly);
container.RegisterInstance<ITypeFactory>(new TypeFactory(container));
container.RegisterInstance<ILog>(LogManager.GetLogger(loggerName));
container.RegisterInstance<ICommandRouter>(new CommandRouterImpl());
factory = container.Resolve<ITypeFactory>();
factory.Get<ILog>().Info(".=.=.=. " + Assembly.GetExecutingAssembly().GetName().Name + " =.=.=.=");
factory.Get<ILog>().Info("Version:" + Assembly.GetExecutingAssembly().GetName().Version.ToString());
string dataPath = ApplicationEnvironment.Instance.DataPath;
if (!Directory.Exists(dataPath))
{
factory.Get<ILog>().Error("L'applicazione non riesce a creare il percorso dati:" + dataPath);
}
factory.Get<ILog>().Debug("Data path applicazione:"+dataPath);
container.AddExtension(new WireImportExports());
return factory;
}
public static IUnityContainer AddNewExtension<TExtension>(this IUnityContainer container)
where TExtension : UnityContainerExtension
{
Guard.ArgumentNotNull(container, "container");
TExtension newExtension = container.Resolve<TExtension>();
return container.AddExtension(newExtension);
}
public void SetUp()
{
container = new UnityContainer();
settings = new ExceptionHandlingSettings();
configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(ExceptionHandlingSettings.SectionName, settings);
container.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource));
}
public void Configure(IUnityContainer container)
{
Guard.ArgumentNotNull(container, "container");
ConstructorInfo ctor = Type.GetConstructor(Type.EmptyTypes);
UnityContainerExtension instance = (UnityContainerExtension)ctor.Invoke(null);
container.AddExtension(instance);
}
protected override void ConfigureContainer(IUnityContainer container)
{
Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(container, "container");
var extensionType = this.GetExtensionType();
var extension = (UnityContainerExtension)container.Resolve(extensionType);
container.AddExtension(extension);
}
public void Setup()
{
Tests.Init.ServiceCollection.AddTransient <ICalculator, Multiplication>();
_serviceProvider = Init.ServiceCollection.BuildServiceProvider();
_container = new UnityContainer();
_container.AddExtension(new UnityFallbackProviderExtension(_serviceProvider));
}
public void TestInitialize()
{
container = new UnityContainer();
mr = new MockRepository();
mocknity = new MocknityContainerExtension(mr);
container.AddExtension(mocknity);
}
public void SetUp()
{
loggingSettings = new LoggingSettings();
configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(LoggingSettings.SectionName, loggingSettings);
container = new UnityContainer();
container.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource));
}
public void Run()
{
_container.AddExtension(new SchedulerUnityExtension());
ConfigureContainer();
ConfigureMvc();
GlobalConfiguration.Configure(ConfigureWebApi);
}
public void SetUp()
{
container = new UnityContainer();
settings = new TestSettings();
configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(settingsKey, settings);
container.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource));
}
protected override void ConfigureContainer(IUnityContainer container)
{
Microsoft.Practices.Unity.Utility.Guard.ArgumentNotNull(container, "container");
var extensionType = this.GetExtensionType();
var extension = (UnityContainerExtension)container.Resolve(extensionType);
container.AddExtension(extension);
}
public void SetUp()
{
container = new UnityContainer();
settings = new ExceptionHandlingSettings();
configurationSource = new DictionaryConfigurationSource();
configurationSource.Add(ExceptionHandlingSettings.SectionName, settings);
container.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource));
}
/// <summary>
/// Creates the instance of the Unity container.
/// </summary>
protected override void PreCompose()
{
unityContainer = new UnityContainer();
var locator = new UnityServiceLocator(unityContainer);
exportProvider = new CSLExportProvider(locator);
unityContainer.AddExtension(new CSLExportProviderExtension(exportProvider));
RegisterTypes();
}
public void Init(HttpApplication context)
{
if (_container == null)
{
var appAsUnityAccessor = (context as IUnityContainerAccessor);
if (appAsUnityAccessor == null)
throw new Exception("The http application must implement \"Thingie.Tracking.Unity.ASPNET.IUnityContainerAccessor\" for the TrackingModule to work! Please implement the interface in global.asax.");
_container = appAsUnityAccessor.Container;
RegisterTrackers(_container);
_container.AddExtension(new TrackingExtension());
}
context.PreRequestHandlerExecute += new EventHandler(context_PreRequestHandlerExecute);
context.PostRequestHandlerExecute += new EventHandler(context_PostRequestHandlerExecute);
}
protected override void ConfigureContainer(IUnityContainer container)
{
var interception = new ExtendedInterception();
if (!string.IsNullOrEmpty(Interceptor))
{
var type = Type.GetType(Interceptor);
if (null == type)
{
throw new ConfigurationErrorsException(string.Format("The {0} is not a valid Interceptor.",
Interceptor));
}
if (!typeof (IInterceptor).IsAssignableFrom(type))
{
throw new ConfigurationErrorsException(string.Format("The {0} is not a valid Interceptor.",
Interceptor));
}
interception.Interceptor = (IInterceptor) Activator.CreateInstance(type);
}
container.AddExtension(interception);
}
private void RegisterTypes(IUnityContainer container)
{
//Register Common unity container
var commonContainer = new CommonUnityExtension();
container.AddExtension(commonContainer);
}
public void SetUp()
{
container = new UnityContainer();
container.AddExtension(new EnterpriseLibraryCoreExtension());
}
public virtual void Setup()
{
Container = new UnityContainer();
MockUnit.Setup();
Container.AddExtension(MockUnit.Extension);
}
public void SetUp()
{
container = new UnityContainer();
container.AddExtension(new EnterpriseLibraryCoreExtension());
CryptographerFixture.CreateKeyFile(keyedHashKeyFile);
}
/// <summary>
/// Add the extension specified in this element to the container.
/// </summary>
/// <param name="container">Container to configure.</param>
protected override void ConfigureContainer(IUnityContainer container)
{
var extensionType = GetExtensionType();
var extension = (UnityContainerExtension)container.Resolve(extensionType);
container.AddExtension(extension);
}
