public static void Configuration()
{
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
PolicyInjector policyInjector = new PolicyInjector(configurationSource);
PolicyInjection.SetPolicyInjector(policyInjector);
}
public static ErrorType GetErrorType(string exceptionType, string opCoCode, string policyName)
{
ErrorType errorType = null;
//read the config details from file or other source (db) to find the error handling section
//find all the exception policies
NamedElementCollection <ExceptionPolicyData> policies =
((ExceptionHandlingSettings)ConfigurationSourceFactory.Create().GetSection("exceptionHandling")).ExceptionPolicies;
//find just the one specified
if (policies != null)
{
ExceptionPolicyData specifiedPolicy = policies.Get(policyName);
if (specifiedPolicy != null)
{
specifiedPolicy.ExceptionTypes.ForEach(delegate(ExceptionTypeData currentExceptionType)
{
if (currentExceptionType.Type.ToString() == exceptionType)
{
errorType = PopulateErrorType(specifiedPolicy.Name, opCoCode, currentExceptionType);
}
}
);
}
}
return(errorType);
}
static void Main(string[] args)
{
if (AlreadyRunning())
{
Console.WriteLine("running already");
return;
}
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
LogWriterFactory logWriterFactory = new LogWriterFactory(configurationSource);
Logger.SetLogWriter(logWriterFactory.Create());
Log("begin running 1.0.0.0");
var config = new AppConfigConfiguration();
IOrganizationService service = null;
try
{
service = HelperCrm.CreateOrganizationService(config);
IDwService dw = new DWService(Log);
IJobTime job = new JobService(Log);
IRemoveDuplicatesService removeDup = new RemoveDuplicateAuditLog(Log);
Imapping mapping = new MappingCrmToDw(Log);
ICrmAuditLogService crmToDw = new CrmAuditLogService(service, Log);
crmToDw.RetreiveAndSet(config, job, mapping, dw);
}
catch (Exception e)
{
Log(e.ToString());
}
Log("end running");
}
/// <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>
/// Ensure that this container has been configured to resolve Enterprise Library
/// objects.
/// </summary>
protected override void Initialize()
{
if (Container.Configure <EnterpriseLibraryCoreExtension>() == null)
{
Container.AddExtension(new EnterpriseLibraryCoreExtension(ConfigurationSourceFactory.Create()));
}
}
public void TestDirectAOPWithPIAB()
{
var container = new UnityContainer();
container.RegisterType <IEmployeeBusinessObject, EmployeeBusinessObject>(new InjectionConstructor());
container.AddNewExtension <Interception>();
container.AddNewExtension <EnterpriseLibraryCoreExtension>();
container.Configure <Interception>().SetInterceptorFor <IEmployeeBusinessObject>(
new TransparentProxyInterceptor());
// Get Policy Injection Settings from the Configuration
IConfigurationSource configSource = ConfigurationSourceFactory.Create();
var policyInjectionsettings =
(PolicyInjectionSettings)configSource.GetSection(PolicyInjectionSettings.SectionName);
if (policyInjectionsettings != null)
{
policyInjectionsettings.ConfigureContainer(container, configSource);
}
var ebo = container.Resolve <IEmployeeBusinessObject>();
Assert.NotNull(ebo);
}
/// <summary>
/// Returns a validator representing the validation criteria specified for type <paramref name="targetType"/>
/// through attributes on type <paramref name="targetType"/> and its ancestors for the supplied ruleset.
/// </summary>
/// <param name="targetType">The type to get the validator for.</param>
/// <param name="ruleset">The name of the required ruleset.</param>
/// <returns>The validator.</returns>
/// <exception cref="ArgumentNullException">when the <paramref name="ruleset"/> is <see langword="null"/>.</exception>
public static Validator CreateValidatorFromAttributes(Type targetType, string ruleset)
{
if (null == ruleset)
{
throw new ArgumentNullException("ruleset");
}
Validator wrapperValidator = null;
lock (attributeOnlyValidatorsCacheLock)
{
ValidatorCacheKey key = new ValidatorCacheKey(targetType, ruleset, false);
Validator cachedValidator;
if (attributeOnlyValidatorsCache.TryGetValue(key, out cachedValidator))
{
return(cachedValidator);
}
Validator validator = InnerCreateValidatorFromAttributes(targetType, ruleset);
wrapperValidator = WrapAndInstrumentValidator(validator, ConfigurationSourceFactory.Create());
attributeOnlyValidatorsCache[key] = wrapperValidator;
}
return(wrapperValidator);
}
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);
}
}
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);
}
public void LogWithMultipleCategories()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
// need to go through the source to get a TraceEventCache
TraceSource source = new TraceSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
LogEntry logEntry = new LogEntry();
logEntry.Message = "message";
logEntry.Categories.Add("FormattedCategory");
logEntry.Categories.Add("DictionaryCategory");
logEntry.EventId = 123;
logEntry.Priority = 11;
logEntry.Severity = TraceEventType.Error;
logEntry.Title = "title";
source.TraceData(TraceEventType.Error, 0, logEntry);
DatabaseProviderFactory factory = new DatabaseProviderFactory(ConfigurationSourceFactory.Create());
Data.Database db = factory.CreateDefault();
DbCommand command = db.GetSqlStringCommand("SELECT Count(*) FROM Category");
int categoryCount = Convert.ToInt32(db.ExecuteScalar(command));
Assert.AreEqual(2, categoryCount);
}
public static void EnterpriseLibraryExample()
{
Console.Clear();
using (var container = new UnityContainer())
{
var configurationSource = ConfigurationSourceFactory.Create();
var logWriterFactory = new LogWriterFactory(configurationSource);
Logger.SetLogWriter(logWriterFactory.Create());
container.AddNewExtension <Microsoft.Practices.Unity.InterceptionExtension.Interception>();
container.RegisterType <IKundeBi, KundeBi>(
new InterceptionBehavior <PolicyInjectionBehavior>(),
new Interceptor <InterfaceInterceptor>());
container.Configure <Microsoft.Practices.Unity.InterceptionExtension.Interception>()
.AddPolicy("log")
.AddMatchingRule <AssemblyMatchingRule>(
new InjectionConstructor(
new InjectionParameter("PolicyInjection")))
.AddCallHandler <LogCallHandler>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor(9001, true, true, "start", "finish", true, false, true, 10, 1));
var kundeBi = container.Resolve <IKundeBi>();
kundeBi.LoadKunde(1);
kundeBi.SaveKunde(1);
Console.ReadLine();
}
}
// http://www.nikosbaxevanis.com/bonus-bits/2011/08/following-the-composition-root-pattern-with-enterprise-library.html
public static void ForEnterpriseLibrary(UnityContainer container)
{
var configurator = new UnityContainerConfigurator(container);
var configSource = ConfigurationSourceFactory.Create();
EnterpriseLibraryContainer.ConfigureContainer(configurator, configSource);
}
private static ValidatorFactory GetValidatorFactory(SpecificationSource specificationSource)
{
if (specificationSource == SpecificationSource.ParameterAttributesOnly)
{
return(null);
}
var configurationSource = ConfigurationSourceFactory.Create();
var instrumentationProvider = ValidationInstrumentationProvider.FromConfigurationSource(configurationSource);
switch (specificationSource)
{
case SpecificationSource.Both:
return(new CompositeValidatorFactory(
instrumentationProvider,
new AttributeValidatorFactory(instrumentationProvider),
new ConfigurationValidatorFactory(configurationSource, instrumentationProvider)));
case SpecificationSource.Attributes:
return(new AttributeValidatorFactory(instrumentationProvider));
case SpecificationSource.Configuration:
return(new ConfigurationValidatorFactory(configurationSource, instrumentationProvider));
default:
return(null);
}
}
public void DefaultConfigurationSourceIsSystemSource()
{
using (var defaultSource = ConfigurationSourceFactory.Create())
{
Assert.AreEqual(typeof(SystemConfigurationSource), defaultSource.GetType());
}
}
public void PassingNullWriterToTracerThrows()
{
using (new Tracer(operation, null, ConfigurationSourceFactory.Create()))
{
int i = new Random().Next();
}
}
static void InitializeLogger()
{
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
LogWriterFactory logWriterFactory = new LogWriterFactory(configurationSource);
Logger.SetLogWriter(logWriterFactory.Create(), false);
}
public void CanCreateAConfigurationSourceThatExistsInConfig()
{
using (var source = ConfigurationSourceFactory.Create("fileSource"))
{
Assert.AreEqual(typeof(FileConfigurationSource), source.GetType());
}
}
protected override void Initialize()
{
base.Initialize();
var configSource = ConfigurationSourceFactory.Create();
var section = configSource.GetSection(PolicyInjectionSettings.SectionName) as PolicyInjectionSettings;
if (section != null)
{
PolicyInjectionSettings.ConfigureContainer(Container, configSource);
}
foreach (var registration in Container.Registrations)
{
if (registration.RegisteredType.Assembly != typeof(IUnityContainer).Assembly)
{
SetInterceptorFor(registration.RegisteredType, registration.MappedToType, registration.Name);
}
}
Context.Registering += delegate(object sender, RegisterEventArgs e)
{
SetInterceptorFor(e.TypeFrom ?? e.TypeTo, e.TypeTo, e.Name);
};
Context.RegisteringInstance += delegate(object sender, RegisterInstanceEventArgs e)
{
SetInterceptorFor(e.RegisteredType, e.Instance.GetType(), e.Name);
};
}
public UserManagerImplementation()
{
// Get configuration source
this._source = ConfigurationSourceFactory.Create(UserSettings.SectionName);
// Load & Clone configuration (so not read-only)
this.Load();
// Determine configuration file path
if (this.Source is SystemConfigurationSource)
{
this._filePath = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
}
else if (this.Source is FileConfigurationSource)
{
ConfigurationSourceSection configurationSourceSection =
ConfigurationSourceSection.GetConfigurationSourceSection();
FileConfigurationSourceElement objectConfiguration
= (FileConfigurationSourceElement)configurationSourceSection.Sources.Get(UserSettings.SectionName);
FileConfigurationSourceElement e = (FileConfigurationSourceElement)objectConfiguration;
this._filePath = objectConfiguration.FilePath;
}
}
private static void ConfigureUnity(UnityContainerExtension initialization)
{
Logger.InfoFormat("Starting the server [{0}]", typeof(Shell).Assembly.EffectiveVersion());
try
{
var configurationSource = ConfigurationSourceFactory.Create();
var container = new UnityContainer()
.AddExtension(new EnterpriseLibraryCoreExtension(configurationSource))
.RegisterInstance(configurationSource);
var serviceLocator = new UnityServiceLocator(container);
Microsoft.Practices.ServiceLocation.ServiceLocator.SetLocatorProvider(() => serviceLocator);
EnterpriseLibraryContainer.Current = serviceLocator;
if (initialization != null)
{
container.AddExtension(initialization);
}
var section = (UnityConfigurationSection)configurationSource.GetSection("unity");
if (section != null)
{
section.Configure(container);
}
}
catch (Exception ex)
{
Logger.Fatal("Unexpected error while container initialization", ex);
throw;
}
}
public EntlibLog()
{
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
LogWriterFactory logWriterFactory = new LogWriterFactory(configurationSource);
defaultWriter = logWriterFactory.Create();
}
private static ConfigurationValidatorBuilder GetConfigurationValidatorBuilder(MemberAccessValidatorBuilderFactory memberAccessValidatorBuilderFactory)
{
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
ConfigurationValidatorBuilder builder = new ConfigurationValidatorBuilder(configurationSource, memberAccessValidatorBuilderFactory);
return(builder);
}
public void AddGetAndRemoveASection()
{
IConfigurationSource source = ConfigurationSourceFactory.Create("sqlSource");
Assert.AreEqual(typeof(SqlConfigurationSource), source.GetType());
DummySection dummySection1 = new DummySection();
dummySection1.Value = 10;
source.Add(CreateParameter(), localSection, dummySection1);
ConfigurationSection newSection = source.GetSection(localSection);
Assert.AreEqual(typeof(DummySection), newSection.GetType());
DummySection dummySection2 = newSection as DummySection;
Assert.AreEqual(dummySection1, dummySection2);
source.Remove(CreateParameter(), localSection);
newSection = source.GetSection(localSection);
Assert.AreEqual(null, newSection);
}
public void SetUp()
{
hashProviders = new Dictionary <string, IHashProvider>();
symmetricCrytoProviders = new Dictionary <string, ISymmetricCryptoProvider>();
CreateKeyFile(symmetricKeyFile);
CreateKeyFile(keyedHashKeyFile);
configSource = ConfigurationSourceFactory.Create();
HashProviderFactory factory = new HashProviderFactory(configSource);
defaultHashProvider = factory.Create(hashInstance);
hashProviders.Add(hashInstance, defaultHashProvider);
SymmetricCryptoProviderFactory symmfactory = new SymmetricCryptoProviderFactory(configSource);
defaultSymmetricCryptoProvider = symmfactory.Create(symmInstance);
algorithSymmetricCryptoProvider = symmfactory.Create(symmetricAlgorithm1);
symmetricCrytoProviders.Add(symmInstance, defaultSymmetricCryptoProvider);
symmetricCrytoProviders.Add(symmetricAlgorithm1, algorithSymmetricCryptoProvider);
var container = EnterpriseLibraryContainer.CreateDefaultContainer(configSource);
cryptographyManager = container.GetInstance <CryptographyManager>();
}
static ApiClient()
{
//设置策略注入
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
var injector = new PolicyInjector(configurationSource);
PolicyInjection.SetPolicyInjector(injector);
}
/// <summary>
/// Configure Logger
/// </summary>
private void ConfigureLogger()
{
DatabaseFactory.SetDatabaseProviderFactory(new DatabaseProviderFactory());
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
LogWriterFactory logWriterFactory = new LogWriterFactory(configurationSource);
Logger.SetLogWriter(logWriterFactory.Create());
}
public static void Initialize()
{
//抓取Config檔案中的設定，作為configurationSource
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
//以Config檔案中的設定，建立ExceptionManager
ExceptionPolicy.SetExceptionManager(new ExceptionPolicyFactory(configurationSource).CreateManager(), true);
}
/// <summary>
/// Initializes a new instance of the <see cref="Tracer"/> class with the given logical operation name and activity id.
/// </summary>
/// <remarks>
/// The activity id will override a previous activity id
/// </remarks>
/// <param name="operation">The operation for the <see cref="Tracer"/></param>
/// <param name="activityId">The activity id</param>
public Tracer(string operation, Guid activityId)
{
if (CheckTracingAvailable())
{
SetActivityId(activityId);
Initialize(operation, GetInstrumentationListener(ConfigurationSourceFactory.Create()));
}
}
public void Given()
{
validationFactory = new CompositeValidatorFactory(
new ValidatorFactory[]
{
new AttributeValidatorFactory(),
new ConfigurationValidatorFactory(ConfigurationSourceFactory.Create())
});
}
public LibDataAccess()
{
if (dataBase == null)
{
DatabaseProviderFactory factory = new DatabaseProviderFactory(ConfigurationSourceFactory.Create());
dataBase = factory.Create("DefaultConnection");
_DatabaseType = dataBase.GetType().Name == "OracleDatabase" ? LibDatabaseType.Oracle : LibDatabaseType.SqlServer;
}
}
