private void ClearLogs()
{
//clear the log entries from the database
DatabaseProviderFactory factory = new DatabaseProviderFactory(ConfigurationSourceFactory.Create());
Data.Database db = factory.CreateDefault();
DbCommand command = db.GetStoredProcCommand("ClearLogs");
db.ExecuteNonQuery(command);
}
static void Main()
{
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
LogWriterFactory logWriterFactory = new LogWriterFactory(configurationSource);
Logger.SetLogWriter(logWriterFactory.Create());
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
private LogWriter GetWriter()
{
//per http://growingtech.blogspot.it/2013/05/enterprise-library-60-logwriter-has-not.html
// we have to explicitly set the writer for EntLib6 before we can return it
var configurationSource = ConfigurationSourceFactory.Create();
var logWriterFactory = new LogWriterFactory(configurationSource);
Logger.SetLogWriter(logWriterFactory.Create());
return(Logger.Writer);
}
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>());
}
public Log()
{
//Intialize the log configuration
if (!_isInitialized)
{
var config = ConfigurationSourceFactory.Create();
var logWriterFactory = new LogWriterFactory(config);
Logger.SetLogWriter(logWriterFactory.Create());
_isInitialized = true;
}
}
public mainForm()
{
try
{
IConfigurationSource configSource = ConfigurationSourceFactory.Create();
LogWriterFactory lwFactory = new LogWriterFactory(configSource);
Logger.SetLogWriter(lwFactory.Create(), false);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Format("Failed to set logger. {0}", ex.Message));
}
InitializeComponent();
//Initialize background worker
this.bw = new BackgroundWorker();
this.bw.WorkerSupportsCancellation = true;
this.bw.WorkerReportsProgress = true;
this.bw.DoWork += this.bw_DoWork;
this.bw.ProgressChanged += this.bw_ProgressChanged;
this.bw.RunWorkerCompleted += this.bw_Complete;
//Create menu strip gradient fill
this.menuStrip_Main.Renderer = new TStripRenderer(new ProColorsTable()
{
MStripGradientBegin = Color.LightSkyBlue, MStripGradientEnd = Color.DarkSlateBlue
})
{
RoundedEdges = false
};
//Set objectlistview header style and hot item style
var hfs = new BrightIdeasSoftware.HeaderFormatStyle();
hfs.SetFont(Font = new Font("Arial", 11F, FontStyle.Bold, GraphicsUnit.Point, ((byte)(0))));
hfs.Normal = new BrightIdeasSoftware.HeaderStateStyle()
{
BackColor = Color.FromArgb(76, 74, 132), ForeColor = Color.WhiteSmoke, FrameColor = Color.Black, FrameWidth = 1F
};
hfs.Hot = new BrightIdeasSoftware.HeaderStateStyle()
{
BackColor = Color.FromArgb(76, 74, 132), ForeColor = Color.WhiteSmoke, FrameColor = Color.Yellow, FrameWidth = 2F
};
this.objectListView_Results.HeaderFormatStyle = hfs;
var rbd = new BrightIdeasSoftware.RowBorderDecoration();
rbd.BorderPen = new Pen(Color.FromArgb(128, Color.LightSeaGreen), 2);
rbd.BoundsPadding = new Size(1, 1);
rbd.CornerRounding = 4.0f;
this.objectListView_Results.HotItemStyle.Decoration = rbd;
}
private LogService()
{
DatabaseFactory.SetDatabaseProviderFactory(new DatabaseProviderFactory());
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
LogWriterFactory logWriterFactory = new LogWriterFactory(configurationSource);
_writer = logWriterFactory.Create();
Logger.SetLogWriter(_writer);
}
public static IConfigurationSource Create(string name)
{
if (string.IsNullOrEmpty(name))
{
return(ConfigurationSourceFactory.Create());
}
else
{
return(ConfigurationSourceFactory.Create(name));
}
}
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");
}
public static void RegisterEnterpriseLibrary(this ContainerBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
using (var configSource = ConfigurationSourceFactory.Create())
{
builder.RegisterEnterpriseLibrary(configSource);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Tracer"/> class with the given logical operation name.
/// </summary>
/// <remarks>
/// If an existing activity id is already set, it will be kept. Otherwise, a new activity id will be created.
/// </remarks>
/// <param name="operation">The operation for the <see cref="Tracer"/></param>
public Tracer(string operation)
{
if (CheckTracingAvailable())
{
if (GetActivityId().Equals(Guid.Empty))
{
SetActivityId(Guid.NewGuid());
}
Initialize(operation, GetInstrumentationListener(ConfigurationSourceFactory.Create()));
}
}
static Logger()
{
try
{
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
ms.LogWriterFactory logWriterFactory = new ms.LogWriterFactory(configurationSource);
ms.Logger.SetLogWriter(new ms.LogWriterFactory().Create());
}
catch (Exception)
{
}
}
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 void Given()
{
var instrumentationProvider = new MockValidationInstrumentationProvider();
validationFactory = new CompositeValidatorFactory(
instrumentationProvider,
new ValidatorFactory[]
{
new AttributeValidatorFactory(instrumentationProvider),
new ConfigurationValidatorFactory(ConfigurationSourceFactory.Create(), instrumentationProvider)
});
}
/// <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);
}
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);
}
public static Operation GetInstance()
{
if (single == null)
{
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
PolicyInjector policyInjector = new PolicyInjector(configurationSource);
PolicyInjection.SetPolicyInjector(policyInjector);
single = PolicyInjection.Create <Operation>();
}
return(single);
}
public static Database CreateDatabase(string name)
{
try
{
DatabaseProviderFactory factory = new DatabaseProviderFactory(ConfigurationSourceFactory.Create());
return(factory.Create(name));
}
catch (ConfigurationErrorsException configurationException)
{
TryLogConfigurationError(configurationException, name);
throw;
}
}
public PolicyInjectionStrategy()
{
container = new UnityContainer();
container.AddNewExtension <Interception>();
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
PolicyInjectionSettings settings = (PolicyInjectionSettings)configurationSource
.GetSection(PolicyInjectionSettings.SectionName);
if (settings != null)
{
settings.ConfigureContainer(container, configurationSource);
}
}
protected void Application_Start(object sender, EventArgs e)
{
//IConfigurationSource config = ConfigurationSourceFactory.Create();
//ExceptionPolicyFactory factory = new ExceptionPolicyFactory(config);
//ExceptionManager exManager = factory.CreateManager();
//ExceptionPolicy.SetExceptionManager(factory.CreateManager());
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
DatabaseFactory.SetDatabaseProviderFactory(new DatabaseProviderFactory());
//ExceptionPolicy.SetExceptionManager(new ExceptionPolicyFactory(configurationSource).CreateManager());
}
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);
}
/// <summary>
/// Return the <see cref="TypeRegistration"/> objects needed to configure
/// the container for the Validation Application Block.
/// </summary>
/// <param name="configurationSource">The <see cref="IConfigurationSource"/> used when creating the <see cref="TypeRegistration{T}"/> entries.</param>
/// <returns>The sequence of <see cref="TypeRegistration"/> objects.</returns>
public IEnumerable <TypeRegistration> GetRegistrations(IConfigurationSource configurationSource)
{
IConfigurationSource availableConfigurationSource = configurationSource ??
ConfigurationSourceFactory.Create();
var instrumentationSection = InstrumentationConfigurationSection.GetSection(configurationSource);
yield return(new TypeRegistration <IValidationInstrumentationProvider>(
() => new ValidationInstrumentationProvider(
instrumentationSection.PerformanceCountersEnabled,
instrumentationSection.EventLoggingEnabled,
instrumentationSection.ApplicationInstanceName))
{
IsDefault = true
});
yield return(new TypeRegistration <AttributeValidatorFactory>(
() => new AttributeValidatorFactory(
Container.Resolved <IValidationInstrumentationProvider>()))
{
IsDefault = true, IsPublicName = true
});
yield return(new TypeRegistration <ConfigurationValidatorFactory>(
() =>
new ConfigurationValidatorFactory(
availableConfigurationSource,
Container.Resolved <IValidationInstrumentationProvider>()))
{
IsDefault = true, IsPublicName = true
});
yield return(new TypeRegistration <ValidationAttributeValidatorFactory>(
() => new ValidationAttributeValidatorFactory(
Container.Resolved <IValidationInstrumentationProvider>()))
{
IsDefault = true, IsPublicName = true
});
yield return(new TypeRegistration <ValidatorFactory>(
() =>
new CompositeValidatorFactory(
Container.Resolved <IValidationInstrumentationProvider>(),
Container.Resolved <AttributeValidatorFactory>(),
Container.Resolved <ConfigurationValidatorFactory>(),
Container.Resolved <ValidationAttributeValidatorFactory>())
)
{
IsDefault = true, IsPublicName = true
});
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var source = ConfigurationSourceFactory.Create();
DatabaseFactory.SetDatabaseProviderFactory(new DatabaseProviderFactory(source));
MapConfig.Register();
}
private static LogglyTraceListenerData GetLogglyTraceListenerSettings()
{
LogglyTraceListenerData traceListenerSettings = null;
using (var configurationSource = ConfigurationSourceFactory.Create())
{
var loggingSettings = LoggingSettings.GetLoggingSettings(configurationSource);
traceListenerSettings = loggingSettings.TraceListeners
.Where(l => l is LogglyTraceListenerData)
.Single() as LogglyTraceListenerData;
}
return(traceListenerSettings);
}
private LogService()
{
//http://www.cnblogs.com/theonewu/p/4045049.html
//http://entlib.codeplex.com/discussions/442089
//http://entlib.codeplex.com/discussions/442387
DatabaseFactory.SetDatabaseProviderFactory(new DatabaseProviderFactory());
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
LogWriterFactory logWriterFactory = new LogWriterFactory(configurationSource);
_writer = logWriterFactory.Create();
Logger.SetLogWriter(_writer);
}
public DynamicELLogger(string logRoot, IEnumerable <string> applications)
{
string[] categories = new string[] { "Info", "Error", "Debug", "Perf" };
LoggingSettings loggingSetting = LoggingSettings.GetLoggingSettings(ConfigurationSourceFactory.Create());
Dictionary <string, TextFormatter> formatters = new Dictionary <string, TextFormatter>(categories.Count(), StringComparer.OrdinalIgnoreCase);
foreach (string cate in categories)
{
var formatData = loggingSetting.Formatters.Where(f => f.Name.Equals(cate, StringComparison.OrdinalIgnoreCase)).SingleOrDefault() as TextFormatterData;
if (formatData == null)
{
throw new Exception(string.Format("Missing logging formatter \"{0}\"", cate));
}
TextFormatter formatter = new TextFormatter(formatData.Template);
formatters[cate] = formatter;
}
string baseLogPath = Path.Combine(logRoot, "{0}.log");
string logPath = Path.Combine(logRoot, "{0}\\{1}.log");
List <LogSource> logSources = new List <LogSource>();
foreach (var cate in categories)
{
logSources.Add(new LogSource(cate, new List <TraceListener>
{
new RollingFlatFileTraceListener(string.Format(baseLogPath, cate), "", "", formatters[cate], 0, "yyyyMMdd", RollFileExistsBehavior.Overwrite, RollInterval.Day)
}, SourceLevels.All));
}
foreach (var app in applications)
{
foreach (var cate in categories)
{
logSources.Add(new LogSource(app + "." + cate, new List <TraceListener>
{
new RollingFlatFileTraceListener(string.Format(logPath, app, cate), "", "", formatters[cate], 0, "yyyyMMdd", RollFileExistsBehavior.Overwrite, RollInterval.Day)
}, SourceLevels.All));
}
}
var nonExistantLog = new LogSource("Empty");
m_Writer = new LogWriter(new ILogFilter[0], logSources, nonExistantLog, categories[0]);
}
protected void Application_Start(object sender, EventArgs e)
{
DatabaseFactory.SetDatabaseProviderFactory(new DatabaseProviderFactory());
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
LogWriterFactory logWriterFactory = new LogWriterFactory(configurationSource);
Logger.SetLogWriter(logWriterFactory.Create());
//System.Data.SqlClient.SqlDependency.Start(ConfigurationManager.ConnectionStrings["BrokerageOnline"].ConnectionString);
SessionManager.IsSessionMonitorStopped = false;
Thread monitSession = new Thread(SessionManager.MoniterSession);
monitSession.Start();
}
private static void ConfigureLogging()
{
IConfigurationSource configurationSource = ConfigurationSourceFactory.Create();
var logWriterFactory = new LogWriterFactory(configurationSource);
try
{
Logger.SetLogWriter(logWriterFactory.Create());
}
catch (InvalidOperationException)
{
Logger.Reset();
Logger.SetLogWriter(logWriterFactory.Create());
}
}
public void SetUp()
{
DatabaseProviderFactory dbFactory = new DatabaseProviderFactory(ConfigurationSourceFactory.Create());
db = dbFactory.CreateDefault();
unencryptedBackingStore = new DataBackingStore(db, "encryptionTests", null);
unencryptedBackingStore.Flush();
ProtectedKey key = KeyManager.GenerateSymmetricKey(typeof(RijndaelManaged), DataProtectionScope.CurrentUser);
using (FileStream stream = new FileStream("ProtectedKey.file", FileMode.Create))
{
KeyManager.Write(stream, key);
}
}
private static IUnityContainer BuildUnityContainer()
{
var section = (UnityConfigurationSection)
ConfigurationManager.GetSection(UnityConfigurationSection.SectionName);
var returnContainer = new UnityContainer();
var container = section.Configure(returnContainer);
var config = ConfigurationSourceFactory.Create();
container.RegisterInstance(CreateLogWriter(config));
container.RegisterInstance(CreateExceptionManager(config));
container.RegisterInstance(container);
container.AddNewExtension <Interception>();
RegisterTypes(container);
return(container);
}
