public bool Initialize(bool beforeFieldInit, object state)
{
_logSources = ChoDictionary <string, ChoLogListener[]> .Unique(new ChoDictionary <string, ChoLogListener[]>(DefaultLogSources));
if (!beforeFieldInit)
{
if (LoggerTypes == null)
{
return(false);
}
foreach (ChoLogSource loggerType in LoggerTypes)
{
try
{
ChoValidation.Validate(loggerType);
_logSources.Add(loggerType.Category, loggerType.LogListeners);
}
catch (Exception)
{
//ChoStreamProfile.WriteLine(ChoReservedDirectoryName.Settings, ChoPath.AddExtension(typeof(ChoLoggerSettings).FullName, ChoReservedFileExt.Err),
// String.Format("Failed to initialize '{0}' object. {1}", loggerType.Category, ex.Message));
}
}
}
return(false);
}
public void Initialize(bool beforeInit)
{
_logSources = ChoDictionary <string, ChoLogListener[]> .Unique(new ChoDictionary <string, ChoLogListener[]>(DefaultLogSources));
if (!beforeInit)
{
if (LoggerTypes == null)
{
return;
}
foreach (ChoLogSource loggerType in LoggerTypes)
{
try
{
ChoValidation.Validate(loggerType);
_logSources.Add(loggerType.Category, loggerType.LogListeners);
}
catch (Exception ex)
{
ChoStreamProfile.WriteLine(ChoLogDirectories.Settings, Path.ChangeExtension(typeof(ChoLoggerSettings).Name, ChoExt.Err),
String.Format("Failed to initialize '{0}' object. {1}", loggerType.Category, ex.Message));
}
}
}
}
private static void Add <T>(string logFileName, ChoDictionary <string, T> objDictionary, ChoTypeNameSpecifier defaultObjectKey, string typeName) where T : class
{
try
{
T obj = ChoObjectManagementFactory.CreateInstance(typeName) as T;
if (obj != null)
{
string key;
if (obj is IChoObjectNameable)
{
key = ((IChoObjectNameable)obj).Name;
}
else
{
key = ChoObjectNameableAttribute.GetName(obj.GetType(), defaultObjectKey);
}
ChoGuard.NotNullOrEmpty(key, String.Format("{0}: Name can't be empty.", typeName));
if (!objDictionary.ContainsKey(key))
{
objDictionary.Add(key, obj);
}
}
//else
// ChoStreamProfile.WriteLine(ChoReservedDirectoryName.Settings, Path.ChangeExtension(logFileName, ChoReservedFileExt.Err),
// String.Format("Failed to create {0} object.", typeName));
}
catch (Exception)
{
//ChoStreamProfile.WriteLine(ChoReservedDirectoryName.Settings, Path.ChangeExtension(logFileName, ChoReservedFileExt.Err),
// String.Format("Failed to create {0} object. {1}", typeName, ex.Message));
}
}
public ChoDictionary <string, ChoObjConfigurable> ConvertToDistinctDictionary(ChoObjConfigurable[] objConfigurables)
{
ChoDictionary <string, ChoObjConfigurable> _distinctObjectConfigurables = new ChoDictionary <string, ChoObjConfigurable>();
if (ChoGuard.IsArgumentNotNullOrEmpty(objConfigurables))
{
return(_distinctObjectConfigurables);
}
foreach (ChoObjConfigurable objConfigurable in objConfigurables)
{
if (objConfigurable == null)
{
continue;
}
if (String.IsNullOrEmpty(objConfigurable.Name))
{
continue;
}
if (_distinctObjectConfigurables.ContainsKey(objConfigurable.Name))
{
ChoTrace.Debug(String.Format("Item with {0} key already exists.", objConfigurable.Name));
continue;
}
_distinctObjectConfigurables.Add(objConfigurable.Name, objConfigurable);
}
return(_distinctObjectConfigurables);
}
public void Initialize(bool beforeInit)
{
//Create the default/built-in objects
_logFormatters = new ChoDictionary <string, IChoLogFormatter>(DefaultLogFormatters);
ChoObjConfigurable.Load <IChoLogFormatter>(typeof(ChoLogFormatterSettings).Name, ChoType.GetTypes(typeof(ChoLogFormatterAttribute)),
_logFormatters, LogFormatterTypes);
}
public static void Load <T>(string logFileName, Type type, ChoDictionary <string, T> objDictionary,
ChoObjConfigurable[] objTypeConfigurables, ChoTypeNameSpecifier defaultObjectKey) where T : class
{
if (type == null)
{
return;
}
Load <T>(logFileName, new Type[] { type }, objDictionary, objTypeConfigurables, defaultObjectKey);
}
public void Initialize(bool beforeInit)
{
_logManagers = new ChoDictionary <string, IChoLogManager>(DefaultLogManagers);
if (!beforeInit)
{
ChoObjConfigurable.Load <IChoLogManager>(typeof(ChoLogManagerSettings).Name, ChoType.GetTypes(typeof(ChoLogManagerAttribute)),
_logManagers, LogManagerTypes);
}
}
public static void Load <T>(string logFileName, string typeName, ChoDictionary <string, T> objDictionary,
ChoObjConfigurable[] objTypeConfigurables, ChoTypeNameSpecifier defaultObjectKey) where T : class
{
if (String.IsNullOrEmpty(typeName))
{
return;
}
Load <T>(logFileName, new string[] { typeName }, objDictionary, objTypeConfigurables, defaultObjectKey);
}
public bool Initialize(bool beforeFieldInit, object state)
{
//Create the default/built-in objects
_validationManagers = new ChoDictionary <string, IChoValidationManager>(DefaultValidationManagers);
//ChoObjConfigurable.Load<IChoValidationManager>(ChoType.GetLogFileName(typeof(ChoValidationManagerSettings)), ChoType.GetTypes(typeof(ChoValidationManagerAttribute)),
// _validationManagers, ValidationManagerTypes);
return(false);
}
public bool Initialize(bool beforeFieldInit, object state)
{
_logManagers = new ChoDictionary <string, IChoLogManager>(DefaultLogManagers);
if (!beforeFieldInit)
{
ChoObjConfigurable.Load <IChoLogManager>(ChoType.GetLogFileName(typeof(ChoLogManagerSettings)), ChoType.GetTypes(typeof(ChoLogManagerAttribute)),
_logManagers, LogManagerTypes);
}
return(false);
}
public bool Initialize(bool beforeFieldInit, object state)
{
lock (_padLock)
{
_configStorages = new ChoDictionary <string, IChoConfigStorage>(DefaultConfigStorages);
//if (!beforeFieldInit)
// ChoObjConfigurable.Load<IChoConfigStorage>(ChoType.GetLogFileName(typeof(ChoConfigStorageManagerSettings)), ChoType.GetTypes(typeof(ChoConfigStorageAttribute)),
// _configStorages, ConfigStorageTypes);
return(false);
}
}
private static void Adjust <T>(string logFileName, ChoDictionary <string, T> objDictionary,
ChoObjTypeConfigurable[] objTypeConfigurables, ChoDefaultObjectKey typeName) where T : class
{
if (objTypeConfigurables != null && objTypeConfigurables.Length > 0)
{
foreach (ChoObjTypeConfigurable objTypeConfigurable in objTypeConfigurables)
{
if (objTypeConfigurable == null)
{
continue;
}
try
{
string key = objTypeConfigurable.Name;
T obj = default(T);
if (!String.IsNullOrEmpty(objTypeConfigurable.Type))
{
obj = ChoObjectManagementFactory.CreateInstance(objTypeConfigurable.Type) as T;
if (obj == null)
{
ChoStreamProfile.WriteLine(ChoLogDirectories.Settings, Path.ChangeExtension(logFileName, ChoExt.Err),
String.Format("Failed to create {0} object.", objTypeConfigurable.Type));
}
}
if (obj != null)
{
key = ChoObjectNameableAttribute.GetName(obj.GetType(), typeName);
}
if (objTypeConfigurable.Action == Action.Remove &&
objDictionary.ContainsKey(key))
{
objDictionary.Remove(key);
}
else if (!objDictionary.ContainsKey(key) && obj != null)
{
objDictionary.Add(key, obj);
}
}
catch (Exception ex)
{
ChoStreamProfile.WriteLine(ChoLogDirectories.Settings, Path.ChangeExtension(logFileName, ChoExt.Err),
String.Format("Failed to create {0} object. {1}", objTypeConfigurable.Type, ex.Message));
}
}
}
}
public void Log(ChoLogEntry message)
{
ChoDictionary <string, ChoLogListener[]> logListeners = ChoLoggerSettings.Me.Find(message.Categories);
foreach (string key in logListeners.Keys)
{
if (logListeners[key] != null)
{
foreach (ChoLogListener logListener in logListeners[key])
{
logListener.TraceData(new TraceEventCache(), key, message.Severity, 100, message.Message);
}
}
}
}
public bool Initialize(bool beforeFieldInit, object state)
{
if (beforeFieldInit)
{
//Create the default/built-in objects
_logListeners = new ChoDictionary <string, ChoLogListener>(DefaultLogListeners);
}
else
{
ChoObjConfigurable.Load <ChoLogListener>(ChoType.GetLogFileName(typeof(ChoLogListenerSettings)), ChoType.GetTypes(typeof(ChoLogListenerAttribute)),
_logListeners, LogListenerTypes);
}
return(false);
}
public static void Load <T>(string logFileName, Type[] types, ChoDictionary <string, T> objDictionary,
ChoObjConfigurable[] objTypeConfigurables, ChoTypeNameSpecifier defaultObjectKey) where T : class
{
ChoGuard.ArgumentNotNull(logFileName, "LogFileName");
ChoGuard.ArgumentNotNull(objDictionary, "ObjectDictionary");
if (types == null || types.Length == 0)
{
return;
}
foreach (Type type in types)
{
Add <T>(logFileName, objDictionary, defaultObjectKey, type.SimpleQualifiedName());
}
Adjust <T>(logFileName, objDictionary, objTypeConfigurables, defaultObjectKey);
}
public ChoDictionary <string, ChoLogListener[]> Find(ICollection <string> categories)
{
ChoGuard.ArgumentNotNull(categories, "Categories");
ChoDictionary <string, ChoLogListener[]> logListeners = new ChoDictionary <string, ChoLogListener[]>();
foreach (string category in categories)
{
foreach (string key in _logSources.Keys)
{
if (key == category && _logSources.ContainsKey(key))
{
logListeners.Add(key, _logSources[key]);
}
}
}
return(logListeners);
}
private void AddToMap(ChoDictionary <string, string> typeShortNameMap, ChoBufferProfileEx errProfile, Type type, string typeShortName, bool overrideType)
{
if (typeShortNameMap.ContainsKey(typeShortName))
{
if (!overrideType)
{
errProfile.AppendLine(String.Format("Type: {0}, ShortName: {1}", type.SimpleQualifiedName(), typeShortName));
return;
}
else
{
ChoTrace.Debug(String.Format("DELETED: Type: {0}, ShortName: {1}", typeShortNameMap[typeShortName], typeShortName));
typeShortNameMap.Remove(typeShortName);
}
}
typeShortNameMap.Add(typeShortName, type.SimpleQualifiedName());
ChoTrace.Debug(String.Format("ADDED: Type: {0}, ShortName: {1}", type.SimpleQualifiedName(), typeShortName));
}
public static void Load <T>(string logFileName, string[] typeNames, ChoDictionary <string, T> objDictionary,
ChoObjConfigurable[] objTypeConfigurables, ChoTypeNameSpecifier defaultObjectKey) where T : class
{
ChoGuard.ArgumentNotNull(logFileName, "LogFileName");
ChoGuard.ArgumentNotNull(objDictionary, "ObjectDictionary");
if (typeNames == null || typeNames.Length == 0)
{
return;
}
foreach (string typeName in typeNames)
{
if (String.IsNullOrEmpty(typeName))
{
continue;
}
Add <T>(logFileName, objDictionary, defaultObjectKey, typeName);
}
Adjust <T>(logFileName, objDictionary, objTypeConfigurables, defaultObjectKey);
}
public bool Initialize(bool beforeFieldInit, object state)
{
if (beforeFieldInit)
{
return(false);
}
//REVISIT
//ChoProfile.InitializeProfile(GetType());
ChoDictionary <string, string> typeShortNameMap = ChoDictionary <string, string> .Synchronized(new ChoDictionary <string, string>());
using (ChoBufferProfileEx errProfile = ChoBufferProfileEx.DelayedAutoStart(new ChoBufferProfileEx(true, ChoPath.AddExtension(typeof(ChoTypeFactory).FullName, ChoReservedFileExt.Err), "Below are the duplicate type short names founds...")))
{
foreach (Type type in ChoType.GetTypes(typeof(ChoTypeShortNameAttribute)))
{
ChoTypeShortNameAttribute typeShortNameAttribute = ChoType.GetAttribute <ChoTypeShortNameAttribute>(type);
AddToMap(typeShortNameMap, errProfile, type, typeShortNameAttribute.Name, false);
}
if (ChoShortTypeNameSettings.Me.ValidTypsShortNames != null)
{
foreach (ChoTypsShortName typsShortName in ChoShortTypeNameSettings.Me.ValidTypsShortNames)
{
if (typsShortName.Type == null)
{
continue;
}
AddToMap(typeShortNameMap, errProfile, typsShortName.Type, typsShortName.TypeShortName, typsShortName.Override);
}
}
}
lock (_padLock)
{
_typeShortNameMap = typeShortNameMap;
}
return(false);
}
public void Initialize()
{
if (_propertyReplacers == null)
{
_propertyReplacers = new ChoDictionary <string, IChoPropertyReplacer>(DefaultPropertyReplacers);
}
if (_propertyReplacers.Count == DefaultPropertyReplacers.Count)
{
if (PropertyDictionaryReplacers != null)
{
foreach (ChoObjConfigurable objConfigurable in PropertyDictionaryReplacers)
{
if (objConfigurable == null)
{
continue;
}
if (String.IsNullOrEmpty(objConfigurable.Name))
{
continue;
}
if (!(objConfigurable is IChoKeyValuePropertyReplacer))
{
continue;
}
if (_propertyReplacers.ContainsKey(objConfigurable.Name))
{
ChoProfile.WriteLine(String.Format("Item with {0} key already exists.", objConfigurable.Name));
continue;
}
_propertyReplacers.Add(objConfigurable.Name, objConfigurable as IChoPropertyReplacer);
}
}
if (CustomPropertyReplacers != null)
{
foreach (ChoObjConfigurable objConfigurable in CustomPropertyReplacers)
{
if (objConfigurable == null)
{
continue;
}
if (String.IsNullOrEmpty(objConfigurable.Name))
{
continue;
}
if (!(objConfigurable is IChoCustomPropertyReplacer))
{
continue;
}
if (_propertyReplacers.ContainsKey(objConfigurable.Name))
{
ChoProfile.WriteLine(String.Format("Item with {0} key already exists.", objConfigurable.Name));
continue;
}
_propertyReplacers.Add(objConfigurable.Name, objConfigurable as IChoPropertyReplacer);
}
}
}
}
public bool Initialize(bool beforeFieldInit, object state)
{
if (_propertyReplacers == null)
{
//ChoStreamProfile.Clean(ChoReservedDirectoryName.Settings, ChoType.GetLogFileName(typeof(ChoPropertyManagerSettings), ChoReservedFileExt.Err));
_propertyReplacers = new ChoDictionary <string, IChoPropertyReplacer>(DefaultPropertyReplacers);
}
if (!beforeFieldInit)
{
if (_propertyReplacers.Count == DefaultPropertyReplacers.Count)
{
if (PropertyDictionaryReplacers != null)
{
foreach (ChoObjConfigurable objConfigurable in PropertyDictionaryReplacers)
{
if (objConfigurable == null)
{
continue;
}
if (String.IsNullOrEmpty(objConfigurable.Name))
{
continue;
}
if (!(objConfigurable is IChoKeyValuePropertyReplacer))
{
continue;
}
if (_propertyReplacers.ContainsKey(objConfigurable.Name))
{
ChoProfile.WriteLine(String.Format("Item with {0} key already exists.", objConfigurable.Name));
continue;
}
_propertyReplacers.Add(objConfigurable.Name, objConfigurable as IChoPropertyReplacer);
}
}
if (CustomPropertyReplacers != null)
{
foreach (ChoObjConfigurable objConfigurable in CustomPropertyReplacers)
{
if (objConfigurable == null)
{
continue;
}
if (String.IsNullOrEmpty(objConfigurable.Name))
{
continue;
}
if (!(objConfigurable is IChoCustomPropertyReplacer))
{
continue;
}
if (_propertyReplacers.ContainsKey(objConfigurable.Name))
{
ChoProfile.WriteLine(String.Format("Item with {0} key already exists.", objConfigurable.Name));
continue;
}
_propertyReplacers.Add(objConfigurable.Name, objConfigurable as IChoPropertyReplacer);
}
}
}
}
return(false);
}
public static void Load <T>(string logFileName, Type[] types, ChoDictionary <string, T> objDictionary,
ChoObjConfigurable[] objTypeConfigurables) where T : class
{
Load <T>(logFileName, types, objDictionary, objTypeConfigurables, ChoTypeNameSpecifier.FullName);
}
public static void Load <T>(string logFileName, string[] typeNames, ChoDictionary <string, T> objDictionary,
ChoObjTypeConfigurable[] objTypeConfigurables) where T : class
{
Load <T>(logFileName, typeNames, objDictionary, objTypeConfigurables, ChoDefaultObjectKey.FullName);
}
