public void AddAssembly(Assembly assembly)
{
foreach (var type in assembly.GetTypes())
{
foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance))
{
var attribute = method.GetCustomAttribute <InitializationAttribute>();
if (attribute == null)
{
continue;
}
if (type.IsGenericType)
{
throw new Exception("Initialization method is within a generic type.");
}
if (method.IsGenericMethod)
{
throw new Exception("Initialization method must not be generic.");
}
if (method.ReturnType != typeof(void))
{
throw new Exception("Invalid initialization method return type.");
}
if (method.GetParameters().Length != 0)
{
throw new Exception("Invalid initialization cannot have parameters");
}
if (!m_initializer.ContainsKey(attribute.Pass))
{
m_initializer.Add(attribute.Pass, new List <InitializationMethod>());
}
var initializationMethod = new InitializationMethod(attribute, method);
if (method.IsStatic)
{
initializationMethod.Caller = null; // null because it's static
}
// a bit ugly to get the instance in case of a singleton class
else if (type.IsDerivedFromGenericType(typeof(Singleton <>)))
{
var instanceProp = type.GetProperty("Instance", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.FlattenHierarchy);
initializationMethod.Caller = instanceProp.GetValue(null, new object[0]);
}
else
{
throw new Exception("Method have to be static or class must inherit Singleton<>");
}
m_initializer[attribute.Pass].Add(initializationMethod);
}
}
}
public void AddAssembly(Assembly assembly)
{
Type[] types = assembly.GetTypes();
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
for (int j = 0; j < methods.Length; j++)
{
MethodInfo methodInfo = methods[j];
InitializationAttribute customAttribute = methodInfo.GetCustomAttribute <InitializationAttribute>();
if (customAttribute != null)
{
if (type.IsGenericType)
{
throw new Exception("Initialization method is within a generic type.");
}
if (methodInfo.IsGenericMethod)
{
throw new Exception("Initialization method must not be generic.");
}
if (methodInfo.ReturnType != typeof(void))
{
throw new Exception("Invalid initialization method return type.");
}
if (methodInfo.GetParameters().Length != 0)
{
throw new Exception("Invalid initialization cannot have parameters");
}
if (!this.m_initializer.ContainsKey(customAttribute.Pass))
{
this.m_initializer.Add(customAttribute.Pass, new List <InitializationMethod>());
}
InitializationMethod initializationMethod = new InitializationMethod(customAttribute, methodInfo);
if (methodInfo.IsStatic)
{
initializationMethod.Caller = null;
}
else
{
if (!type.IsDerivedFromGenericType(typeof(Singleton <>)))
{
throw new Exception("Method have to be static or class must inherit Singleton<>");
}
PropertyInfo property = type.GetProperty("Instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
initializationMethod.Caller = property.GetValue(null, new object[0]);
}
this.m_initializer[customAttribute.Pass].Add(initializationMethod);
}
}
}
}
private void ExecuteInitializationMethod(InitializationMethod method)
{
if (!method.Initialized)
{
if (method.Attribute.Dependance != null && !this.m_initializedTypes.Contains(method.Attribute.Dependance))
{
if (!this.m_dependances.ContainsKey(method.Attribute.Dependance))
{
this.m_dependances.Add(method.Attribute.Dependance, new List <InitializationMethod>());
}
this.m_dependances[method.Attribute.Dependance].Add(method);
}
else
{
if (!method.Attribute.Silent && !string.IsNullOrEmpty(method.Attribute.Description))
{
InitializationManager.logger.Info(method.Attribute.Description);
this.OnProcessInitialization(method.Attribute.Description);
}
else
{
if (!method.Attribute.Silent)
{
string text = string.Format("Initialize '{0}'", method.Method.DeclaringType.Name);
InitializationManager.logger.Info(text);
this.OnProcessInitialization(text);
}
}
method.Method.Invoke(method.Caller, new object[0]);
method.Initialized = true;
if (!this.m_initializedTypes.Contains(method.Method.DeclaringType))
{
this.m_initializedTypes.Add(method.Method.DeclaringType);
}
if (this.m_dependances.ContainsKey(method.Method.DeclaringType))
{
foreach (InitializationMethod current in this.m_dependances[method.Method.DeclaringType])
{
this.ExecuteInitializationMethod(current);
}
this.m_dependances.Remove(method.Method.DeclaringType);
}
}
}
}
private void ExecuteInitializationMethod(InitializationMethod method)
{
if (method.Initialized)
{
return;
}
if (method.Attribute.Dependance != null &&
!m_initializedTypes.Contains(method.Attribute.Dependance))
{
if (!m_dependances.ContainsKey(method.Attribute.Dependance))
{
m_dependances.Add(method.Attribute.Dependance, new List <InitializationMethod>());
}
m_dependances[method.Attribute.Dependance].Add(method);
}
else
{
if (!method.Attribute.Silent && !string.IsNullOrEmpty(method.Attribute.Description))
{
logger.Info(method.Attribute.Description);
OnProcessInitialization(method.Attribute.Description);
}
else if (!method.Attribute.Silent)
{
var text = string.Format("Initialize '{0}'", method.Method.DeclaringType.Name);
logger.Info(text);
OnProcessInitialization(text);
}
try
{
method.Method.Invoke(method.Caller, new object[0]);
}
catch (Exception ex)
{
logger.ErrorException(ex.InnerException.Message, ex);
throw;
}
method.Initialized = true;
if (!m_initializedTypes.Contains(method.Method.DeclaringType))
{
m_initializedTypes.Add(method.Method.DeclaringType);
}
if (!m_dependances.ContainsKey(method.Method.DeclaringType))
{
return;
}
foreach (var dependance in m_dependances[method.Method.DeclaringType])
{
ExecuteInitializationMethod(dependance);
}
m_dependances.Remove(method.Method.DeclaringType);
}
}
