/// <summary>
/// Creates a new <see cref="ExceptionCallHandler"/> that processses exceptions
/// using the given exception policy name, as defined in <paramref name="configurationSource"/>.
/// </summary>
/// <param name="exceptionPolicyName">Exception policy name.</param>
/// <param name="configurationSource">Configuration source defining the exception handling policy.</param>
public ExceptionCallHandler(string exceptionPolicyName, IConfigurationSource configurationSource)
{
this.exceptionPolicyName = exceptionPolicyName;
ExceptionPolicyFactory policyFactory = new ExceptionPolicyFactory(configurationSource);
exceptionPolicy = policyFactory.Create(exceptionPolicyName);
}
private static void RunInReleaseMode()
{
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
LogWriterFactory logWriterFactory = new LogWriterFactory(configurationSource);
Microsoft.Practices.EnterpriseLibrary.Logging.Logger.SetLogWriter(logWriterFactory.Create());
ExceptionPolicyFactory exceptionFactory = new ExceptionPolicyFactory(configurationSource);
ExceptionManager manager = exceptionFactory.CreateManager();
ExceptionPolicy.SetExceptionManager(manager);
TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
Current.DispatcherUnhandledException += CurrentOnDispatcherUnhandledException;
AppDomain.CurrentDomain.UnhandledException += CurrentDomainOnUnhandledException;
try
{
CloudDriveShellBootstrapper bootstrapper = new CloudDriveShellBootstrapper();
bootstrapper.Run();
}
catch (Exception ex)
{
HandleException(ex);
}
}
static void Main(string[] args)
{
var config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
var section = config.GetSection(ConfigurationSourceSection.SectionName) as ConfigurationSourceSection;
var dbConfigSourceElement = section.Sources.Get("DatabaseBlockSettings") as FileConfigurationSourceElement;
var dbConfigSource = new FileConfigurationSource(dbConfigSourceElement.FilePath);
var dbFactory = new DatabaseProviderFactory(dbConfigSource);
DatabaseFactory.SetDatabaseProviderFactory(dbFactory);
var logConfigSourceElement = section.Sources.Get("LoggingBlockSettings") as FileConfigurationSourceElement;
var logConfigSource = new FileConfigurationSource(logConfigSourceElement.FilePath);
var logFactory = new LogWriterFactory(logConfigSource);
var logWriter = logFactory.Create();
Logger.SetLogWriter(logWriter);
logWriter.Write("123333");
var exceptionConfigSourceElement = section.Sources.Get("ExceptionHandlingBlockSettings") as FileConfigurationSourceElement;
var exceptionConfigSource = new FileConfigurationSource(exceptionConfigSourceElement.FilePath);
var exceptionFactory = new ExceptionPolicyFactory(exceptionConfigSource);
var exceptionManager = exceptionFactory.CreateManager();
ExceptionPolicy.SetExceptionManager(exceptionManager);
ProcessException(exceptionManager, () => int.Parse("A"));
Console.WriteLine("主函数执行完成，按任意键退出……");
Console.ReadKey();
}
protected override void Arrange()
{
this.factory =
new ExceptionPolicyFactory(n =>
new ExceptionHandlingSettings
{
ExceptionPolicies =
{
new ExceptionPolicyData
{
Name = "existing",
ExceptionTypes =
{
new ExceptionTypeData
{
Type = typeof(Exception),
ExceptionHandlers =
{
new CustomHandlerData {
Type = typeof(MockExceptionHandler), Name = "mock"
}
}
}
}
}
}
});
}
/// <summary>
/// 演示如何使用企业库的异常组件
/// </summary>
/// <param name="args"></param>
/// <remarks>
/// 配置及注意点，参照LoggingBlock.Basic工程
/// </remarks>
static void Main(string[] args)
{
#region 初始化企业库组件
var source = ConfigurationSourceFactory.Create();
//设置log
var logFactory = new LogWriterFactory(source);
//如果有db的设置，必须在调用此方法前设置db
var logWriter = logFactory.Create();
Logger.SetLogWriter(logWriter);
//设置exception
var exceptionFactory = new ExceptionPolicyFactory(source);
var exceptionManager = exceptionFactory.CreateManager();
ExceptionPolicy.SetExceptionManager(exceptionManager);
#endregion
var exceptions = new List <bool>();
exceptions.Add(ProcessException(exceptionManager, () => int.Parse("A")));
exceptions.Add(ProcessException(exceptionManager, () => File.Open("tmp.txt", FileMode.Open)));
exceptions.Add(ProcessException(exceptionManager, () => new Hashtable()["tmp"].ToString()));
exceptions.Add(ProcessException(exceptionManager, () => { var str = new List <string>()[0]; }));
Console.WriteLine("主函数执行完成，{0}异常发生，按任意键退出……", exceptions.Count > 0 ? "有" : "无");
Console.ReadKey();
}
/// <summary>
/// Prepares the container.
/// </summary>
/// <returns></returns>
public static IUnityContainer PrepareContainer()
{
var container = Singleton.GetInstance <IUnityContainer>(() => new UnityContainer());
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "EntLib.config.xml");
var map = new ExeConfigurationFileMap {
ExeConfigFilename = path
};
Configuration config = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None);
try
{
var section = (UnityConfigurationSection)config.GetSection("unity");
//section.Configure(container, "DefContainer");
//For unity 3.0 version
container.LoadConfiguration(section, "DefContainer");
//For Entlib 6 :Exception Handling Application Block objects can no longer be created automatically from the Unity DI container.
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
LogWriterFactory logWriterFactory = new LogWriterFactory(configurationSource);
Microsoft.Practices.EnterpriseLibrary.Logging.Logger.SetLogWriter(logWriterFactory.Create());
// Singleton
ExceptionPolicyFactory exceptionPolicyFactory = new ExceptionPolicyFactory(configurationSource);
ExceptionPolicy.SetExceptionManager(exceptionPolicyFactory.CreateManager());
}
catch (InvalidOperationException ioe)
{
Debug.WriteLine(ioe);
// Microsoft.Practices.EnterpriseLibrary.Logging.Logger.Write(ioe, "ExceptionLogger");
throw;
}
return(container);
}
/// <summary>Integrates Unity when the application starts.</summary>
public static void Start()
{
var container = new ObjectBuilder(UnityConfig.RegisterTypes).GetContainer();
FilterProviders.Providers.Remove(FilterProviders.Providers.OfType <FilterAttributeFilterProvider>().First());
FilterProviders.Providers.Add(new UnityFilterAttributeFilterProvider(container));
DependencyResolver.SetResolver(new UnityDependencyResolver(container));
Logger.SetLogWriter(new LogWriterFactory().Create());
var config = ConfigurationSourceFactory.Create();
var factory = new ExceptionPolicyFactory(config);
var exceptionManager = factory.CreateManager();
container.RegisterInstance(exceptionManager);
ExceptionPolicy.SetExceptionManager(exceptionManager);
// Note: Uncomment if you want to use PerRequestLifetimeManager
// Microsoft.Web.Infrastructure.DynamicModuleHelper.DynamicModuleUtility.RegisterModule(typeof(UnityPerRequestHttpModule));
}
private static ExceptionManager CreateExceptionManager(IConfigurationSource config)
{
var factory = new ExceptionPolicyFactory(config);
var manger = factory.CreateManager();
ExceptionPolicy.SetExceptionManager(manger);
return(manger);
}
static ExceptionHandler()
{
logWriter = new LogWriterFactory().Create();
Logger.SetLogWriter(logWriter, false);
_exceptionPolicyFactory = new ExceptionPolicyFactory();
_exceptionManager = _exceptionPolicyFactory.CreateManager();
}
/// <summary>
/// Initializes this instance.
/// Call this method to set default exception manager.
/// </summary>
public static void Initilize()
{
var config = ConfigurationSourceFactory.Create();
var factory = new ExceptionPolicyFactory(config);
var exceptionManager = factory.CreateManager();
ExceptionPolicy.SetExceptionManager(exceptionManager);
}
private void InitializeExceptionManager()
{
//LogWriterFactory logWriterFactory = new LogWriterFactory();
//Logger.SetLogWriter(logWriterFactory.Create());
ExceptionPolicyFactory exceptionFactory = new ExceptionPolicyFactory();
exceptionManager = exceptionFactory.CreateManager();
}
private static void TestExceptionManager()
{
IConfigurationSource config = ConfigurationSourceFactory.Create();
ExceptionPolicyFactory factory = new ExceptionPolicyFactory(config);
Logger.SetLogWriter(new LogWriterFactory().Create());
ExceptionManager exceptionManager = factory.CreateManager();
exceptionManager.Process(MyExceptionCode, "Policy");
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
//Enterprise Library Configuration
IConfigurationSource config = ConfigurationSourceFactory.Create();
Microsoft.Practices.EnterpriseLibrary.Logging.Logger.SetLogWriter(new LogWriterFactory(config).Create());
ExceptionPolicyFactory factory = new ExceptionPolicyFactory(config);
ExceptionManager exManager = factory.CreateManager();
ExceptionPolicy.SetExceptionManager(exManager);
AppDomain.CurrentDomain.UnhandledException += AppDomainUnhandledException;
//Bootstrapper
Bootstrapper bootStrapper = new Bootstrapper();
bootStrapper.Run();
IUnityContainer container = bootStrapper.Container;
IRegionManager regionManager = container.Resolve <IRegionManager>();
//Start Services
container.Resolve <GotoHomeTimerService>(new ParameterOverride(
"timerInactividad", PubliPuntoEstacion.Properties.Settings.Default.TimerInactividad));
container.Resolve <MailService>(
new ParameterOverrides
{
{ "kioskoID", PubliPuntoEstacion.Properties.Settings.Default.KioskoID },
{ "pwdMail", PubliPuntoEstacion.Properties.Settings.Default.MailPwd }
});
if (Decktra.PubliPuntoEstacion.Properties.Settings.Default.WebSyncOn)
{
container.Resolve <SyncAgent>(
new ParameterOverrides
{
{ "webSyncServerAddress", PubliPuntoEstacion.Properties.Settings.Default.WebSyncServerAddress },
{ "videosPath", PubliPuntoEstacion.Properties.Settings.Default.VideosPath }
});
}
container.Resolve <SmsMessageService>(
new ParameterOverrides
{
{ "envioSMS_ON", PubliPuntoEstacion.Properties.Settings.Default.EnvioSMS_ON },
{ "SMS_UserName", PubliPuntoEstacion.Properties.Settings.Default.SMS_UserName },
{ "SMS_Pwd", PubliPuntoEstacion.Properties.Settings.Default.SMS_Pwd },
});
//Start MainView
regionManager.RequestNavigate(RegionNames.REGION_WORK_AREA, new Uri("HomeControlsView", UriKind.Relative));
regionManager.AddToRegion(RegionNames.REGION_NUESTROSCLIENTES_AREA, container.Resolve <NuestrosClientesView>());
regionManager.AddToRegion(RegionNames.REGION_OFERTAS_AREA, container.Resolve <OfertasView>());
}
/// <summary>
/// Initializes the ExceptionHandler
/// </summary>
static ExceptionHandler()
{
// Create LogWriter.
Logger.SetLogWriter(new LogWriterFactory().Create(), false);
// Initialize and set the ExceptionManager for the ExceptionPolicy.
IConfigurationSource config = ConfigurationSourceFactory.Create();
ExceptionPolicyFactory factory = new ExceptionPolicyFactory(config);
ExceptionManager = factory.CreateManager();
ExceptionPolicy.SetExceptionManager(ExceptionManager, false);
}
protected void Application_Start(object sender, EventArgs e)
{
IConfigurationSource source = ConfigurationSourceFactory.Create();
var logwriterFactory = new LogWriterFactory(source);
var logWriter = logwriterFactory.Create();
Logger.SetLogWriter(logWriter);
var exceptionPolicyFactory = new ExceptionPolicyFactory(source);
var exceptionManager = exceptionPolicyFactory.CreateManager();
ExceptionPolicy.SetExceptionManager(exceptionManager);
}
public static void Initialise(IUnityContainer container)
{
Logger.SetLogWriter(new LogWriterFactory().Create());
var config = ConfigurationSourceFactory.Create();
var factory = new ExceptionPolicyFactory(config);
var exceptionManager = factory.CreateManager();
container.RegisterInstance(exceptionManager);
ExceptionPolicy.SetExceptionManager(exceptionManager);
}
protected void Application_Start()
{
IConfigurationSource c = ConfigurationSourceFactory.Create();
ExceptionPolicyFactory factory = new ExceptionPolicyFactory(c);
Logger.SetLogWriter(new LogWriterFactory().Create());
ExceptionManager exManager = factory.CreateManager();
ExceptionPolicy.SetExceptionManager(factory.CreateManager());
UnityConfig.RegisterComponents();
GlobalConfiguration.Configure(WebApiConfig.Register);
}
public static void Start()
{
string configurationFilepath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "EntLib.config");
IConfigurationSource configurationSource = new FileConfigurationSource(configurationFilepath);
LogWriterFactory logWriterFactory = new LogWriterFactory(configurationSource);
Logger.SetLogWriter(logWriterFactory.Create());
ExceptionPolicyFactory exceptionPolicyFactory = new ExceptionPolicyFactory(configurationSource);
ExceptionPolicy.SetExceptionManager(exceptionPolicyFactory.CreateManager());
}
private void Initialise()
{
// Set the LogWriter for the static Logger class
Logger.SetLogWriter(new LogWriterFactory().Create());
// Initialise the Exception Manager
var config = ConfigurationSourceFactory.Create();
var factory = new ExceptionPolicyFactory(config);
// Set the Exception Policy
var exceptionManager = factory.CreateManager();
ExceptionPolicy.SetExceptionManager(exceptionManager);
_interval = GetPollingInterval();
}
private static void DoStuff()
{
// IoC
ExceptionPolicyFactory policyFactory = new ExceptionPolicyFactory();
var exceptionManager = policyFactory.CreateManager();
exceptionManager.Process(MyExceptionCode, "Policy");
//LogWriterFactory logWriterFactory = new LogWriterFactory();
//var log = logWriterFactory.Create();
//var configSource = ConfigurationSourceFactory.Create();
//Logger.SetLogWriter(new LogWriterFactory(configSource).Create());
//ExceptionPolicy.SetExceptionManager(new ExceptionPolicyFactory(configSource).CreateManager());
}
public static void Start()
{
EngineContext.Initialize(false);
var container = ServiceContainer.Current;
FilterProviders.Providers.Remove(FilterProviders.Providers.OfType <FilterAttributeFilterProvider>().First());
FilterProviders.Providers.Add(new UnityFilterAttributeFilterProvider(container));
DependencyResolver.SetResolver(new UnityDependencyResolver(container));
//验证流
DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false;
UnityValidatorActivatorFactory validatorFactory = new UnityValidatorActivatorFactory(ServiceContainer.Current);
ModelValidatorProviders.Providers.Insert(0, new FluentValidationModelValidatorProvider(validatorFactory));
//企业库【异常/日志】
var entLibConfigPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Configs", "EntLibConfig.config");
var configSouce = new FileConfigurationSource(entLibConfigPath);
ExceptionPolicyFactory exceptionPolicyFactory = new ExceptionPolicyFactory(configSouce);
ExceptionPolicy.SetExceptionManager(exceptionPolicyFactory.CreateManager());
LogWriterFactory logWriterFactory = new LogWriterFactory(configSouce);
Logger.SetLogWriter(logWriterFactory.Create());
//计划任务
string configurationFilepath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Configs", "quartz.config");
var configurationFileMap = new ExeConfigurationFileMap {
ExeConfigFilename = configurationFilepath
};
var configuration = ConfigurationManager.OpenMappedExeConfiguration(configurationFileMap, ConfigurationUserLevel.None);
System.Xml.XmlDocument sectionXmlDocument = new System.Xml.XmlDocument();
sectionXmlDocument.Load(new StringReader(configuration.GetSection("quartz").SectionInformation.GetRawXml()));
NameValueSectionHandler handler = new NameValueSectionHandler();
NameValueCollection props = handler.Create(null, null, sectionXmlDocument.DocumentElement) as NameValueCollection;
ServiceContainer.Current.AddExtension(new QuartzUnityExtension(props));
EngineContext.Current.Resolve <ISchedulerProvider>("Quartz").Start();
}
public static void Configure(IUnityContainer container)
{
// Get Entlib config source (Current is in Web.EnterpriseLibrary.config)
IConfigurationSource source = ConfigurationSourceFactory.Create();
// Config container from Policy injection config settings
var policyInjectionSettings = (PolicyInjectionSettings)source.GetSection(PolicyInjectionSettings.SectionName);
policyInjectionSettings.ConfigureContainer(container);
// Config retry policy
var retryPolicySettings = RetryPolicyConfigurationSettings.GetRetryPolicySettings(source);
// turn off throwIfSet for unit testing
RetryPolicyFactory.SetRetryManager(retryPolicySettings.BuildRetryManager(), throwIfSet: false);
// get factories from config
var policyFactory = new ExceptionPolicyFactory(source);
var dbFactory = new DatabaseProviderFactory(source);
var validationFactory = ConfigurationValidatorFactory.FromConfigurationSource(source);
// Set default locator
UnityServiceLocator locator = new UnityServiceLocator(container);
ServiceLocator.SetLocatorProvider(() => locator);
container
.AddNewExtension <Interception>()
// register Entlib types with appropiate factory
.RegisterType <ExceptionManager>(new InjectionFactory(c => policyFactory.CreateManager()))
.RegisterType <Database>(new InjectionFactory(c => dbFactory.CreateDefault()))
.RegisterInstance <ValidatorFactory>(validationFactory)
// use registration by convention extension for registering app types; IProfileStore, IUserRepository
.RegisterTypes(AllClasses.FromAssemblies(Assembly.GetExecutingAssembly()),
WithMappings.FromAllInterfacesInSameAssembly,
WithName.Default,
WithLifetime.ContainerControlled)
// register types with interception
.RegisterType <AExpense.Model.User>(new Interceptor <VirtualMethodInterceptor>(),
new InterceptionBehavior <TracingBehavior>())
.RegisterType <IExpenseRepository, ExpenseRepository>(new Interceptor <VirtualMethodInterceptor>(),
new InterceptionBehavior <PolicyInjectionBehavior>());
}
public void Config(IUnityContainer container)
{
string exceptionHandlingLogAndWrapPolicy = "LogAndWrap";
#region interception
container.AddNewExtension <Interception>();
container.Configure <Interception>().AddPolicy("Save")
.AddMatchingRule <MemberNameMatchingRule>(new InjectionConstructor(new InjectionParameter("Save*")))
.AddCallHandler <ExceptionCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor(exceptionHandlingLogAndWrapPolicy))
.AddCallHandler <TransactionCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor());
container.Configure <Interception>().AddPolicy("Update")
.AddMatchingRule <MemberNameMatchingRule>(new InjectionConstructor(new InjectionParameter("Update*")))
.AddCallHandler <ExceptionCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor(exceptionHandlingLogAndWrapPolicy))
.AddCallHandler <TransactionCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor());
container.Configure <Interception>().AddPolicy("Delete")
.AddMatchingRule <MemberNameMatchingRule>(new InjectionConstructor(new InjectionParameter("Delete*")))
.AddCallHandler <LogCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor(9001, true, false,
"Pending Deletion",
"Delete successfully", true, false, true, 10))
.AddCallHandler <ExceptionCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor(exceptionHandlingLogAndWrapPolicy))
.AddCallHandler <TransactionCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor());
container.Configure <Interception>().AddPolicy("List")
.AddMatchingRule <MemberNameMatchingRule>(new InjectionConstructor(new InjectionParameter("List*")))
.AddCallHandler <ExceptionCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor(exceptionHandlingLogAndWrapPolicy))
.AddCallHandler <ResourceAuthorizationCallHandler>(new ContainerControlledLifetimeManager(), new InjectionConstructor(container));
#endregion
#region logging
LogWriterFactory logWriterFactory = new LogWriterFactory();
LogWriter logWriter = logWriterFactory.Create();
Logger.SetLogWriter(logWriter, false);
#endregion
#region exception handling
ExceptionPolicyFactory policyFactory = new ExceptionPolicyFactory();
ExceptionManager exceptionManager = policyFactory.CreateManager();
ExceptionPolicy.SetExceptionManager(exceptionManager);
#endregion
}
// tpdo singleton
public static void SetExceptionManager()
{
IConfigurationSource source = ConfigurationSourceFactory.Create();
DatabaseFactory.ClearDatabaseProviderFactory();
DatabaseFactory.SetDatabaseProviderFactory(new DatabaseProviderFactory(source));
var logwriterFactory = new LogWriterFactory(source);
var logWriter = logwriterFactory.Create();
Logger.Reset();
Logger.SetLogWriter(logWriter);
var exceptionPolicyFactory = new ExceptionPolicyFactory(source);
var exceptionManager = exceptionPolicyFactory.CreateManager();
ExceptionPolicy.SetExceptionManager(exceptionManager);
}
/// <summary>
/// Log Exception according Exeption Application bLock EL
/// </summary>
/// <param name="exception"></param>
/// <param name="policyName"></param>
/// <returns></returns>
public static bool LogException(Exception exception, ExceptionPolicyEnum policyName)
{
try
{
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
LogWriterFactory logWriterFactory = new LogWriterFactory(configurationSource);
Logger.SetLogWriter(logWriterFactory.Create(), false);
ExceptionPolicyFactory factory = new ExceptionPolicyFactory(configurationSource);
ExceptionPolicy.SetExceptionManager(factory.CreateManager(), false);
ExceptionPolicy.HandleException(exception, policyName.ToString());
return(true);
}
catch
{
return(false);
}
}
static void Main(string[] args)
{
#region 编码方式定义异常策略
//----------------------------------------------------------------------------------------
//var policies = new List<ExceptionPolicyDefinition>();
////定义一个捕获FormatException异常的策略，什么也不做，只是过滤
//var myTestExceptionPolicy = new List<ExceptionPolicyEntry>
//{
// {
// new ExceptionPolicyEntry(typeof(FormatException), PostHandlingAction.None,
// new IExceptionHandler[]
// {
// })
// }
//};
//policies.Add(new ExceptionPolicyDefinition("MyTestExceptionPolicy", myTestExceptionPolicy));
//// 把异常策略加入异常管理
//var exManager = new ExceptionManager(policies);
//-------------------------------------------------------------------------------------------
#endregion
#region 通过配置文件来定义异常策略
// 通过配置文件来定义策略
var logWriter = new LogWriterFactory().Create();
Logger.SetLogWriter(logWriter);
var exManager = new ExceptionPolicyFactory().CreateManager();
#endregion
ExceptionPolicy.SetExceptionManager(exManager);
demo2();
demo1();
Console.ReadKey();
}
public static string Initialize(string providerName, string connectionString)
{
string sReturnValue = null;
try
{
IConfigurationSource config = ConfigurationSourceFactory.Create();
ExceptionPolicyFactory factory = new ExceptionPolicyFactory(config);
DatabaseProviderFactory dbfactory = new DatabaseProviderFactory(new SystemConfigurationSource(false).GetSection);
DatabaseFactory.SetDatabaseProviderFactory(dbfactory, false);
LogWriterFactory logWriterFactory = new LogWriterFactory(config);
Logger.SetLogWriter(logWriterFactory.Create());
ExceptionManager exManager = factory.CreateManager();
ExceptionPolicy.SetExceptionManager(factory.CreateManager());
sReturnValue = "Successfully Initialized";
}
catch (Exception ex)
{
sReturnValue = ex.Message;
}
return(sReturnValue);
}
public static void RegisterComponents()
{
var container = new UnityContainer();
container.AddNewExtension <Interception>();
IConfigurationSource source = ConfigurationSourceFactory.Create();
var policyInjectionSettings = (PolicyInjectionSettings)source.GetSection(PolicyInjectionSettings.SectionName);
policyInjectionSettings.ConfigureContainer(container);
var exceptionPolicyFactory = new ExceptionPolicyFactory(source);
var logWriterFactory = new LogWriterFactory(source);
container.RegisterType <ExceptionManager>(new ContainerControlledLifetimeManager(), new InjectionFactory(unityContainer => exceptionPolicyFactory.CreateManager()));
container.RegisterType <LogWriter>(new ContainerControlledLifetimeManager(), new InjectionFactory(unityContainer => logWriterFactory.Create()));
IList <Assembly> servicesAssemblies = new List <Assembly>();
servicesAssemblies.Add(Assembly.Load("Multiplica.Examen.Dev.Application.IServices"));
servicesAssemblies.Add(Assembly.Load("Multiplica.Examen.Dev.Application.Services"));
container.RegisterTypes(
AllClasses.FromAssemblies(servicesAssemblies),
WithMappings.FromMatchingInterface,
WithName.Default,
t => new PerRequestLifetimeManager(),
type => new InjectionMember[]
{
new InterceptionBehavior <PolicyInjectionBehavior>(),
new Interceptor <TransparentProxyInterceptor>()
}
);
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
}
protected override void Arrange()
{
this.factory = new ExceptionPolicyFactory(n => null);
}
protected override void Arrange()
{
this.factory = new ExceptionPolicyFactory(n => null);
}
protected override void Arrange()
{
this.factory = new ExceptionPolicyFactory(n => new ExceptionHandlingSettings());
}
public void CreateExceptionPolicyThrowsCorrectly()
{
ExceptionPolicyFactory factory = new ExceptionPolicyFactory(Context);
factory.CreateExceptionPolicy("Non Existent Policy", new Exception());
}
protected override void Arrange()
{
this.factory =
new ExceptionPolicyFactory(n =>
new ExceptionHandlingSettings
{
ExceptionPolicies =
{
new ExceptionPolicyData
{
Name = "existing",
ExceptionTypes =
{
new ExceptionTypeData
{
Type = typeof(Exception),
ExceptionHandlers =
{
new CustomHandlerData{ Type = typeof(MockExceptionHandler), Name = "mock" }
}
}
}
}
}
});
}
protected override void Arrange()
{
this.factory = new ExceptionPolicyFactory(n => new ExceptionHandlingSettings());
}
protected override void Arrange()
{
this.factory = new ExceptionPolicyFactory(n => { throw new ConfigurationErrorsException(); });
}
