/// <summary>
/// 输出对象反射信息
/// </summary>
static public void reflex(object instance)
{
Logger.Log(instance.ToString());
Vitamin.logFileds(instance.GetType());
Vitamin.logPropertys(instance.GetType());
Vitamin.logMethods(instance.GetType());
}
/// <summary>
/// 输出类型反射信息
/// </summary>
static public void reflex(Type type)
{
Logger.to("[REFLEX]", ConsoleColor.Magenta, "-----------[" + type.ToString() + "]------------");
Vitamin.logFileds(type);
Vitamin.logPropertys(type);
Vitamin.logMethods(type);
Logger.to("[REFLEX]", ConsoleColor.Magenta, "------------------------------------------");
}
/// <summary>
/// 创建实例
/// 此方法适用于框架外的类有依赖注入的需求的情况，请使用该方法实例化该类
/// </summary>
static public T createObject <T>()
{
Type type = typeof(T);
object obj = Activator.CreateInstance(type);
Vitamin.injectModel(obj, type);
Vitamin.injectInstance(obj, type);
return((T)obj);
}
/// <summary>
/// 获取单例
/// 通过此接口获取的单例会有相关的依赖注入
/// </summary>
static public object getInstance(Type type)
{
if (Vitamin.__instances.GetValueOrDefault(type) == null)
{
object instance = Activator.CreateInstance(type);
Vitamin.injectModel(instance, instance.GetType());
Vitamin.__instances[type] = instance;
}
return(Vitamin.__instances[type]);
}
/// <summary>
/// 注入单例
/// 仅供内部调用，如果你希望框架外的类有依赖注入，请使用createObject实例化该类
/// </summary>
static private bool injectInstance(object target, Type type)
{
bool result = true;
var instanceType = typeof(Instance);
FieldInfo[] filedInfos = type.GetFields();
foreach (FieldInfo info in filedInfos)
{
if (Attribute.IsDefined(info, instanceType))
{
info.SetValue(target, Vitamin.getInstance(info.FieldType));
}
}
return(result);
}
/// <summary>
/// 获取组件
/// 通过框架接口获取的组件才会有相关的依赖注入
/// </summary>
static public T getView <T>() where T : ViewBase
{
Type viewType = typeof(T);
if (Vitamin.__views.ContainsKey(viewType))
{
if (Vitamin.__views.GetValueOrDefault(viewType) == null)
{
ViewBase view = (ViewBase)Activator.CreateInstance(viewType);
Vitamin.injectModel(view, viewType);
Vitamin.__views[viewType] = view;
}
}
return((T)Vitamin.__views[viewType]);
}
protected void execCommand(string cmdRoute, params object[] args)
{
Vitamin.execCommand(cmdRoute, args);
}
static public void initialize()
{
Vitamin.__views = new Dictionary <Type, ViewBase>();
Vitamin.__modles = new Dictionary <Type, ModelBase>();
Vitamin.__cmds = new Dictionary <string, CommandBase>();
Vitamin.__instances = new Dictionary <Type, object>();
var types = Assembly.GetCallingAssembly().GetTypes();
var modelBaseType = typeof(ModelBase);
var viewBaseType = typeof(ViewBase);
var cmdBaseType = typeof(CommandBase);
var net = new Net();
foreach (var type in types)
{
//获取基类
var baseType = type.BaseType;
if (baseType == modelBaseType)
{
ModelBase model = Activator.CreateInstance(type) as ModelBase;
Vitamin.__modles.Add(type, model);
}
else if (baseType == viewBaseType)
{
Vitamin.__views.Add(type, null);
}
else if (baseType == cmdBaseType)
{
CmdRoute des = (CmdRoute)type.GetCustomAttribute(typeof(CmdRoute));
if (des == null)
{
Logger.Error(baseType.ToString() + "没有添加描述信息!");
}
else
{
CommandBase cmd = Activator.CreateInstance(type) as CommandBase;
cmd.net = net;
Vitamin.__cmds.Add(des.routId, cmd);
}
}
}
while (true)
{
var allInject = true;
foreach (var model in Vitamin.__modles)
{
//MethodInfo method = typeof(Vitamin).GetMethod("injectModel");//先获取到DisplayType<T>的MethodInfo反射对象
//method.MakeGenericMethod(new Type[] { model.Value.GetType() }).Invoke(Vitamin, model.Value);//然后使用MethodInfo反射对象调用
bool result = Vitamin.injectModel(model.Value, model.Value.GetType());
if (!result)
{
allInject = false;
}
}
if (allInject)
{
foreach (var model in Vitamin.__modles)
{
Vitamin.injectInstance(model.Value, model.Value.GetType());
model.Value.initialize();
}
break;
}
}
foreach (var cmd in Vitamin.__cmds)
{
Vitamin.injectInstance(cmd.Value, cmd.Value.GetType());
bool result = Vitamin.injectModel(cmd.Value, cmd.Value.GetType());
}
Logger.Info("🎇✨🎉✨🛠💊 - Vitamin Start - 💊🛠✨🎉✨🎇");
}
