public static void TrapInject <TIn, TOut>(this IInjectable <TIn, TOut> injectable, Func <TIn, bool> filter,
Func <TIn, TOut> func, InjectionPriority priority = InjectionPriority.Middle)
{
injectable.Inject(v => filter(v)
? InjectionResult.Trap <TIn, TOut>(func(v))
: InjectionResult.PassThru <TIn, TOut>(), priority);
}
public static void LoadInjections(Assembly assembly, string fileName)
{
Type initType = typeof(IInjectable);
List <Type> injectables = assembly.GetTypes().Where(x => initType.IsAssignableFrom(x)).ToList();
List <IInjectable> injects = new List <IInjectable>();
foreach (Type iType in injectables)
{
IInjectable inject = (IInjectable)Activator.CreateInstance(iType);
string pluginPath = runningPath + "\\" + inject.initHandle + "\\";
if (!Directory.Exists(pluginPath))
{
Directory.CreateDirectory(pluginPath);
}
inject.basePath = pluginPath;
injects.Add(inject);
}
injects.Sort((i1, i2) => i1.priority.CompareTo(i2.priority));
}
public static void TrapInject <TIn>(this IInjectable <TIn> injectable, Func <TIn, bool> filter,
Action <TIn> func, InjectionPriority priority = InjectionPriority.Middle)
{
injectable.Inject(filter, v =>
{
func(v);
return(InjectionResult.Trap <TIn>());
}, priority);
}
/// <summary>
/// 执行注入操作
/// </summary>
/// <remarks>此方法将会注入并初始化类中所有标记了InjectAttribute的Property</remarks>
public static void Inject(this IInjectable injectable)
{
injectable.InjectionContext = injectable.InjectionContext ?? InjectionContext.Default;
injectable.GetType()
.GetProperties()
.Where(m => m.GetCustomAttributes(typeof(InjectAttribute), true).Any())
.ToList()
.ForEach(m => m.SetValue(injectable, injectable.InjectionContext.GetObject(m.PropertyType), null));
}
//constructor requires the loosely coupled injectable
public EverythingsInjected(IInjectable constructorInjected)
{
//have to set the default with property injected
_propertyInjected = GetIInjectable();
//retain the constructor injected injectable
_constructorInjected = constructorInjected;
//using basic interface injection
_interfaceInjected = GetIInjectable();
}
public void CompileParallel(IEnumerable <ActionSource> input, IInjectable <UnityComponentSource> output)
{
int count = -1;
Parallel.ForEach(input, src =>
{
var builder = new StringBuilder(Config.MAX_KEY_LENGTH);
for (int i = src.startOffset; i != src.count; i++)
{
if (src.context[i] == ' ')
{
output.Push()
}
else
{
builder.Append(src.context[i]);
}
}
});
}
public Dictionary <InjectableId, IInjectable[]> InjectAllRequiredFields(MonoBehaviour behaviour, Entity entity)
{
var behaviourType = behaviour.GetType();
EnsureLoaded(behaviourType);
var createdInjectables = new Dictionary <InjectableId, IInjectable[]>();
foreach (var idToFields in fieldInfoCache[behaviourType])
{
var id = idToFields.Key;
var fields = idToFields.Value;
var injectables = new IInjectable[fields.Length];
for (var i = 0; i < fields.Length; i++)
{
injectables[i] = Inject(behaviour, id, entity, fields[i]);
}
createdInjectables[id] = injectables;
}
return(createdInjectables);
}
public void InjectToInjectable(IInjectable injectable)
{
var injectMethod = ReflectionUtils.GetMethodByAttribute(injectable.GetType(), typeof(InjectAttribute));
var parameterInfos = injectMethod.GetParameters();
var parameters = new object[parameterInfos.Length];
for (var i = 0; i < parameterInfos.Length; i++)
{
var paramType = parameterInfos[i].ParameterType;
if (_dependenciesProvider.TryGet <object>(paramType, out var param))
{
parameters[i] = param;
}
else
{
throw new InvalidOperationException($"{paramType.FullName} is not included in the dependencies");
}
}
injectMethod.Invoke(injectable, parameters);
}
public void OnUpdate(IEnumerable <ActionSource> input, IInjectable <UnityComponentSource> output)
{
Parallel.ForEach(input, src =>
{
var builder = _builderPool.GetObject();
string cmd;
string arg;
for (int i = src.startOffset; i != src.count; i++)
{
if (src.context[i] == ' ')
{
}
else
{
builder.Append(src.context[i]);
}
}
output.Push();
_builderPool.PutObject(builder);
});
}
public Consumer(IInjectable <Item> item)
{
Item = item;
}
public void OnInject(IInjectable <UnityComponentSource> output)
{
}
private void Form1_Load(object sender, EventArgs e)
{
instance = this;
runningPath = Directory.GetCurrentDirectory();
PluginManager.runningPath = runningPath + "\\Plugins";
string settingFilePath = runningPath + "\\Settings.txt";
if (!File.Exists(settingFilePath))
{
SaveSettings(new Settings(), settingFilePath);
}
string json = File.ReadAllText(settingFilePath);
settings = JsonConvert.DeserializeObject <Settings>(json);
xResTB.Text = settings.xRes.ToString();
yResTB.Text = settings.yRes.ToString();
channelTB.Text = settings.lastChannel;
emailTB.Text = settings.lastEmail;
AutoSave.Interval = settings.tickDelay;
string pluginPath = runningPath + "\\Plugins\\DLLs";
if (!Directory.Exists(pluginPath))
{
Directory.CreateDirectory(pluginPath);
}
CommandHandler.Initialize(channelTB.Text, runningPath);
foreach (string file in Directory.GetFiles(pluginPath))
{
if (Path.GetExtension(file) == ".dll")
{
Assembly dll = Assembly.LoadFile(file);
string name = Path.GetFileName(file);
PluginManager.LoadPlugins(dll);
PluginManager.LoadCommands(dll, name);
PluginManager.LoadInjections(dll, name);
}
}
for (int i = 0; i < PluginManager.injects.Count; i++)
{
IInjectable inject = PluginManager.injects[i];
if (inject.Initialize())
{
Debug.Log("Injected " + inject.initHandle + " successfully");
}
else
{
Debug.LogError("Injected " + inject.initHandle + " unsuccessfully");
}
}
}
public DemoHttpFunction(IInjectable injectable)
{
_injectable = injectable;
}
public Activity(IInjectable injectable) => _injectable = injectable;
public static void Inject <TIn>(this IInjectable <TIn> injectable, Func <TIn, bool> filter,
Func <TIn, IInjectionResult <TIn> > func, InjectionPriority priority = InjectionPriority.Middle)
{
injectable.Inject(v => filter(v) ? func(v) : InjectionResult.PassThru <TIn>(), priority);
}
public TestFuncCreationComplex(IInjectable injectionTest, IStartupConfiguration configuration, IShutdownHandler shutdownHandler)
{
InjectionTest = injectionTest;
}
public DemoEntity(IInjectable injectable) => _injectable = injectable;
