public void ShouldErrorIfMissingRootType()
{
Diagnostics diags = null;
InjectionState injectionState = null;
int ii;
try
{
(ii, injectionState) = new DependencyInjector().CreateAndInjectDependencies <int>();
Assert.Fail();
}
catch (DIException iex)
{
diags = iex.Diagnostics;
Assert.IsTrue(diags.HasWarnings);
dynamic diagnostic = diags.Groups["MissingRoot"]?.Occurrences[0];
Assert.AreEqual("System.Int32", diagnostic.BeanType);
Assert.AreEqual("", diagnostic.BeanName);
}
catch (Exception ex)
{
var dx = ex;
Assert.Fail();
}
}
private static void OnGameInjectionStateChange(GameType gameType, InjectionState injectionState)
{
if (injectionState != InjectionState.Injected)
{
return;
}
if (!config.TryGetValue(gameType.ToString(), out var subConfig))
{
subConfig = new Dictionary <string, object>();
}
if (Logger.DebugMode)
{
subConfig["debug"] = true;
}
else
{
subConfig.Remove("debug");
}
string jsonConfig = JsonConvert.SerializeObject(subConfig);
if (ProcessMonitor.SendCommand(gameType, CommandType.Config, jsonConfig, 10000) != "Done")
{
if (ProcessMonitor.SendCommand(gameType, CommandType.Config, jsonConfig, 5000) != "Done")
{
Logger.LogError("Unable to send config to in-game UI");
}
}
}
public (object bean, InjectionState injectionState) Execute(InjectionState injectionState
, BeanFactoryArgs args)
{
int x = ((string)null).Length;
return("", injectionState);
}
Execute(InjectionState injectionState, BeanFactoryArgs args)
{
object[] @params = (object[])args.FactoryParmeter;
//Assert(@params.Length == 2);
//Assert(@params[0] is Type);
//Assert(@params[1] is String);
return(GetResourceAsString(@params[0] as Type, @params[1] as String), injectionState);
}
public (object bean, InjectionState injectionState) Execute(InjectionState injectionState, BeanFactoryArgs args)
{
object[] @params = (object[])args.FactoryParmeter;
Assert(@params.Length == 2);
Assert(@params[0] is Type);
Assert(@params[1] is String);
return(ConvertResourceToXPathNavigator(@params[0] as Type, @params[1] as String), injectionState);
}
public (object bean, InjectionState injectionState) Execute(InjectionState injectionState, BeanFactoryArgs args)
{
if (System.Environment.GetCommandLineArgs().Length > 1)
{
return(iocContainer.CreateAndInjectDependencies <FileListProvider>(injectionState));
}
else
{
return(iocContainer.CreateAndInjectDependencies <UsageListProvider>(injectionState, rootBeanSpec: new RootBeanSpec(rootBeanName: "usage")));
}
}
public (object bean, InjectionState injectionState) Execute(InjectionState injectionState, BeanFactoryArgs args)
{
if (System.Diagnostics.Debugger.IsAttached)
{
return(iocContainer.CreateAndInjectDependencies <VSOutputWindow>(injectionState
, rootBeanSpec: new RootBeanSpec(rootBeanName: "outputWindow")));
}
else
{
return(iocContainer.CreateAndInjectDependencies <ConsoleDisplay>(injectionState));
}
}
public void Reset()
{
SocketStreamClient.Stop();
InjectionState = InjectionState.Idle;
InjectionAttempt = 0;
Process = null;
// Window = IntPtr.Zero;
// WindowState = WindowState.Normal;
// IsForeground = false;
// ScreenCoordinates = Rectangle.Empty;
// OverlayWindow?.Close();
// OverlayWindow = null;
}
public (object bean, InjectionState injectionState) Execute(InjectionState injectionState, BeanFactoryArgs args)
{
switch ((int)args.FactoryParmeter)
{
case 1:
return(pDependencyInjector.CreateAndInjectDependencies <ChildOne>(injectionState));
case 2:
return(pDependencyInjector.CreateAndInjectDependencies <ChildTwo>(injectionState));
default:
throw new Exception("Execute failed");
}
}
private static void OnGameInjectionStateChange(GameType gameType, InjectionState injectionState)
{
if (injectionState != InjectionState.Injected)
{
return;
}
if (!config.TryGetValue(gameType.ToString(), out var subConfig))
{
subConfig = new Dictionary <string, object>();
}
string jsonConfig = JsonConvert.SerializeObject(subConfig);
if (ProcessMonitor.SendCommand(gameType, CommandType.Config, jsonConfig, 10000) != "Done")
{
ProcessMonitor.SendCommand(gameType, CommandType.Config, jsonConfig, 10000);
}
}
private InjectionState CreateAndInjectDocumentParser(InjectionState injectionState
, string beanName, string documentPath, string xmlRoot, Type resourceAssemblyFinder)
{
IIOCCXPathNavigatorCache nc;
(nc, injectionState) = pdi.CreateAndInjectDependencies <IIOCCXPathNavigatorCache>(injectionState);
nc.Factory = navigatorFactory;
nc.ResourcePath = (string)propertyMap.Map(documentPath);
nc.ResourceAssemblyFinder = resourceAssemblyFinder;
IOCCDocumentParser ddp;
(ddp, injectionState) = pdi.CreateAndInjectDependencies <IOCCDocumentParser>(injectionState);
ddp.XmlRoot = xmlRoot;
ddp.NavigatorCache = nc;
return(pdi.CreateAndInjectDependencies(ddp, injectionState: injectionState, rootBeanSpec:
new RootBeanSpec(rootBeanName: beanName), deferDepedencyInjection: false).injectionState);
}
public InjectionState CreateAndInjectDependencies(object rootObject,
InjectionState injectionState, RootBeanSpec rootBeanSpec = null, bool deferDependencyInjection = false)
{
try
{
Type constructableType = rootObject.GetType();
rootBeanSpec = rootBeanSpec ?? new RootBeanSpec();
rootBeanSpec = rootBeanSpec.Scope == BeanScope.Prototype
? new RootBeanSpec("prototype-" + Guid.NewGuid().ToString()
, rootBeanSpec.RootConstrutorName, rootBeanSpec.Scope)
: rootBeanSpec;
// in the call to CreateObjectTree we trick the method to create the dependencies
// by adding the prototype uniquely to both the type map and the deferred assignment list
var rodt = new RootObjectDecisionTable(deferDependencyInjection, rootBeanSpec.Scope);
string beanName = rootBeanSpec.RootBeanName;
rodt.MaybeAddBeanToTypeMap(
() => injectionState = UpdateTypeMap(injectionState, rootBeanSpec, constructableType, beanName));
rodt.MaybeAddObjectToCreatedSoFarMap(
() => injectionState.MapObjectsCreatedSoFar[new InstantiatedBeanId(constructableType
, beanName, rootBeanSpec.RootConstrutorName)] = rootObject);
rodt.MaybeAddDeferredIn(
() => injectionState.CreationContext.BeansWithDeferredAssignments
.Add(new ConstructableBean(rootObject.GetType(), beanName)));
ConstructableBean cb = new ConstructableBean(constructableType, beanName);
bool deferredIn = injectionState.CreationContext.BeansWithDeferredAssignments.Contains(cb);
BeanMaker rootBeanMaker = (scope, spec, ct, mocf, diags, cp, cc) =>
{
if (!deferredIn && cc.BeansWithDeferredAssignments.Contains(cb))
{
// a cyclical dependency has been encountered which has triggered a genuine
// deferred assignment. This needs to be squashed
cc.BeansWithDeferredAssignments.Remove(cb);
}
return(true, rootObject);
};
(_, injectionState) = CreateObjectTree(new BeanSpec(constructableType, beanName, rootBeanSpec.RootConstrutorName)
, injectionState.CreationContext, injectionState, new BeanReferenceDetails(), rootBeanSpec.Scope, rootBeanMaker);
rodt.MaybeAddDeferredOut(
() => injectionState.CreationContext.BeansWithDeferredAssignments
.Add(new ConstructableBean(rootObject.GetType(), beanName)));
return(injectionState);
}
public (object bean, InjectionState injectionState) Execute(InjectionState injectionState, BeanFactoryArgs args)
{
var pdi = new DependencyInjector();
if (args.FactoryParmeter as Type == typeof(DiverseA))
{
return(pdi.CreateAndInjectDependencies <DiverseA>(injectionState));
}
else if (args.FactoryParmeter as Type == typeof(DiverseB))
{
return(pdi.CreateAndInjectDependencies(args.FactoryParmeter as Type, injectionState));
}
else if (args.FactoryParmeter as Type == typeof(DiverseC))
{
return(pdi.CreateAndInjectDependencies((args.FactoryParmeter as Type).FullName, injectionState));
}
else
{
var diverseD = new DiverseD();
return(pdi.CreateAndInjectDependencies(diverseD, injectionState));
}
}
Configure(InjectionState injectionState = null)
{
injectionState = pdi.CreateAndInjectDependencies(this, injectionState: injectionState
, deferDepedencyInjection: false).injectionState;
injectionState = CreateAndInjectDocumentParser(injectionState
, "site-userguide", "PureDIDocumentor.Docs.UserGuide.xml", Constants.UserGuideRoot
, typeof(DependencyConfiguration));
injectionState = CreateAndInjectDocumentParser(injectionState
, "site-diagnostics", "PureDI.Docs.DiagnosticSchema.xml", Constants.DiagnosticSchemaRoot
, typeof(DependencyInjector));
injectionState = CreateAndInjectDocumentParser(injectionState
, "doc-userguide", "PureDIDocumentor.Docs.UserGuide.xml", Constants.UserGuideRoot
, typeof(DependencyConfiguration));
InjectionState @is;
(_, @is) =
pdi.CreateAndInjectDependencies(
new GenericConfig(("relativePath", "../../../../Simple")), injectionState: injectionState)
;
(IDocumentProcessor dp, InjectionState is2) = pdi.CreateAndInjectDependencies <
IDocumentProcessor>(@is);
(var dsg, var is3) = pdi.CreateAndInjectDependencies <IDocumentationSiteGenerator>(is2);
return(dsg, dp, is3);
}
internal InjectionState CheckInjectionOf(string target)
{
using (var dll = ModuleDefinition.ReadModule(target)) {
foreach (var typeName in new string[] { Injector.HOOK_TYPE, Injector.PPML_HOOK_TYPE })
{
var type = dll.GetType(typeName);
if (type == null)
{
continue;
}
var result = CheckInjection(type);
if (result != InjectionState.NONE)
{
if (Target.Equals(target))
{
lock (this)
Status = result;
}
return(result);
}
}
}
return(InjectionState.NONE);
}
CreateAndInjectDependencies(Type rootType, InjectionState injectionState, string rootBeanName
, string rootConstructorName, BeanScope scope)
{
try
{
Assert(rootType != null);
Assert(rootBeanName != null);
object rootObject;
(rootObject, injectionState) = CreateObjectTree(
new BeanSpec(rootType, rootBeanName, rootConstructorName)
, injectionState.CreationContext, injectionState, new BeanReferenceDetails(), scope, MakeBean);
if (rootObject != null && !rootType.IsInstanceOfType(rootObject))
{
throw new DIException(
$"object created by IOC container is not {rootType.Name} as expected",
injectionState.Diagnostics);
}
Assert(rootObject == null ||
rootType.IsInstanceOfType(rootObject));
return(rootObject, injectionState);
}
catch (NoArgConstructorException inace) // I suspect this is never executed
{
dynamic diagnostic = injectionState.Diagnostics.Groups["MissingNoArgConstructor"].CreateDiagnostic();
diagnostic.Class = rootType.GetSafeFullName();
injectionState.Diagnostics.Groups["MissingNoArgConstructor"].Add(diagnostic);
throw new DIException("Failed to create object tree - see diagnostics for details", inace,
injectionState.Diagnostics);
}
finally
{
RecordIncompleteAssignments(injectionState);
}
}
public static void Main()
{
InjectionState injectionState;
PermanentService ps;
var pdi = new DependencyInjector();
(ps, injectionState) = pdi.CreateAndInjectDependencies<PermanentService>();
InjectionState transitoryState = injectionState;
for (int ii = 0; ii < 10; ii++)
{
BigData bigData;
(bigData, transitoryState)
= pdi.CreateAndInjectDependencies<BigData>(injectionState);
Console.WriteLine(bigData.AddUp()); // 500_000_500_000
// 500_000_500_000
// 500_000_500_000
// 500_000_500_000
// 500_000_500_000
// 500_000_500_000
// 500_000_500_000
// 500_000_500_000
// 500_000_500_000
// 500_000_500_000
}
}
public (object bean, InjectionState injectionState) Execute(InjectionState injectionState, BeanFactoryArgs args)
{
return(injector.CreateAndInjectDependencies <SimpleChild>(injectionState));
}
private static int SayInjectedStatus(InjectionState injected)
{
WriteLine(injected.ToString().ToLower());
return(RC_NORMAL);
}
public (object bean, InjectionState injectionState) Execute(InjectionState injectionState, BeanFactoryArgs args)
{
return(new ValueObject((string)args.FactoryParmeter), injectionState);
}
Execute(InjectionState injectionState, BeanFactoryArgs args)
{
return(new Repository(Environment.GetEnvironmentVariable("CONNECTION_STRING"))
, injectionState);
}
Execute(InjectionState injectionState, BeanFactoryArgs args)
{
return (numberProvider.number, injectionState);
}
Execute(InjectionState injectionState, BeanFactoryArgs args)
{
accumulator++;
return(accumulator, injectionState);
}
Execute(InjectionState injectionState, BeanFactoryArgs args)
{
return(42, injectionState);
}
Execute(InjectionState injectionState, BeanFactoryArgs args)
{
return(args.FactoryParmeter, injectionState);
}
public override (object bean, InjectionState injectionState) Execute(InjectionState injectionState, BeanFactoryArgs args) => (24, injectionState);
public abstract (object bean, InjectionState injectionState) Execute(InjectionState injectionState, BeanFactoryArgs args);
Execute(InjectionState injectionState, BeanFactoryArgs args)
{
throw new Exception("test exception");
}
public (object bean, InjectionState injectionState) Execute(InjectionState injectionState, BeanFactoryArgs args)
{
return(43, injectionState);
}
Execute(InjectionState injectionState, BeanFactoryArgs args)
{
throw new System.NotImplementedException();
}
