public static void Main(string[] args)
{
var c1 = new myClass2();
IMyClass c2 = c1.GetMyClass();
Console.Writeline(c2.MyData);
}
public void TestRebindSingletonToSingleton()
{
IDIContext context = ContextHelper.CreateContext();
context.s().Bind <IMyClass>(() => new MyClass());
IDIContext childContext = ContextHelper.CreateContext(context);
childContext.s().Rebind <IMyClass>();
IMyClass a1 = context.Resolve <IMyClass>();
IMyClass a2 = context.Resolve <IMyClass>();
Assert.AreSame(a1, a2);
IMyClass b1 = childContext.Resolve <IMyClass>();
IMyClass b2 = childContext.Resolve <IMyClass>();
Assert.AreSame(b1, b2);
Assert.AreNotSame(b1, a1);
Assert.AreNotSame(b2, a2);
IBinding d1 = context.Introspect <IMyClass>();
Assert.AreEqual(InstantiationType.Concrete, d1.instantiationType);
Assert.AreEqual(context, d1.context);
IBinding d2 = childContext.Introspect <IMyClass>();
Assert.AreEqual(InstantiationType.Concrete, d2.instantiationType);
Assert.AreEqual(childContext, d2.context);
}
public static void HelperMethod(this IMyClass instance)
{
//Do stuff...
//Can access internal implementation as necessary
var impl = (IMyClassImpl)instance;
impl.InternalHelperMethod();
}
public Action1DebugActionWebApiFilter(IMyClass myClass)
{
if (myClass == null)
{
throw new ArgumentNullException("myClass");
}
this.myClass = myClass;
}
public void Resolve_DependencyOnAnotherClass_Resolves()
{
IMyClass myClassInstance = Bootstrap.Container.Resolve <IMyClass>();
myClassInstance.Counter++;
IMyDependentClass myDependentClassInstance = Bootstrap.Container.Resolve <IMyDependentClass>();
myDependentClassInstance.MyDoubler.ShouldBeEquivalentTo(2);
}
private static void Main(string[] args)
{
// suppose it's from another assembly, and you don't have direct reference to type
var c = Activator.CreateInstance(typeof(MyClass));
IMyClass iface = c.ActLike <IMyClass>();
iface.method1();
Console.ReadKey();
}
public bool Method(IMyClass myObj)
{
if (myObj != null)
{
return(true);
}
return(_factory.CreateMyClass().SomeFunctionReturningBool());
}
public void TestwWithoutCustomFactoryWrapper()
{
IDIContext context = ContextHelper.CreateContext();
context.m().Bind <IMyClass>(() => new MyClass());
IMyClass obj = context.Resolve <IMyClass> ();
Assert.IsInstanceOf <MyClass>(obj);
}
public void Register_ValidRegistrationViaTypes_ResolvesNewInstance()
{
Container container = new Container();
container.Register <IMyClass, MyClass>();
IMyClass myClassInstance = container.Resolve <IMyClass>();
myClassInstance.IsCreated.Should().BeTrue();
}
public void Register_MultipleRegistrations_ResolvesLastRegistration()
{
Container container = new Container();
container.Register <IMyClass, MyClass>();
container.Register <IMyClass, MyOtherClass>();
IMyClass myClassInstance = container.Resolve <IMyClass>();
myClassInstance.GetType().ShouldBeEquivalentTo(typeof(MyOtherClass));
}
public void TestSoftResolutionWithDefault()
{
IDIContext context = ContextHelper.CreateContext();
context.s().Bind <IMyClass>(() => new MyClassWithDefault());
IMyClass obj = context.Resolve <IMyClass>();
Assert.That(obj.orange is DefaultOrange);
Assert.That(obj.apple is DefaultApple);
}
public void TestConstructorResolution()
{
IDIContext context = ContextHelper.CreateContext();
context.s().Bind <IMyClass>(() => new MyClass());
IMyClass obj = context.Resolve <IMyClass>(() => Construction
.ForType <IOrange>(new Orange()).AndType <IApple>(new Apple()));
Assert.That(obj.orange is Orange);
Assert.That(obj.apple is Apple);
}
public void Test()
{
var cl = new MyClass()
{
MyPropertyInt = 1, MyPropertyStr = "one"
};
IMyClass icl = cl as IMyClass;
string serializeObject = Newtonsoft.Json.JsonConvert.SerializeObject(icl, typeof(IMyClass), new Newtonsoft.Json.JsonSerializerSettings()
{
});
}
public void TestCustomFactoryWrapper()
{
IDIContext context = ContextHelper.CreateContext();
TestBinder testBinder = new TestBinder(context);
testBinder.Bind <IMyClass>(() => new MyClass());
IMyClass obj = context.Resolve <IMyClass>();
Assert.IsInstanceOf <AnotherClass>(obj);
Assert.IsInstanceOf <MyClass>((obj as AnotherClass).data);
}
public void TestSoftResolution()
{
IDIContext context = ContextHelper.CreateContext();
context.s().Bind <IMyClass>(() => new MyClass());
context.m().Bind <IOrange>(() => new Orange());
IMyClass obj = context.Resolve <IMyClass>();
Assert.That(obj.orange is Orange);
Assert.IsNull(obj.apple);
}
static void Main(string[] args)
{
IMyClass a = null;
Guid guid = new Guid("61D7B4BA-1597-4AAA-93D9-582412D2A04F");
Type transactionType = Type.GetTypeFromCLSID(guid);
object transaction = Activator.CreateInstance(transactionType);
a = transaction as IMyClass;
int b = a.Add(2, 3);
Console.WriteLine(b);
Console.ReadKey();
}
protected override bool IsOk(IMyOperation elementToCheck)
{
IMyClass owner = elementToCheck.Owner as IMyClass;
if (owner == null)
{
return(true);
}
IEnumerable <IMyOperation> otherOverloads = owner.OwnedOperations.Where(o => o.Name == elementToCheck.Name && o.Guid != elementToCheck.Guid);
return(!otherOverloads.Any(o => GetSignature(o).SequenceEqual(GetSignature(elementToCheck))));
}
public void TestMethod2()
{
try
{
IMyClass cls = AkProxy <IMyClass> .Create(new MyClass());
Console.WriteLine(cls.Quotient(2, 0));
Assert.Fail();
}
catch (Exception)
{
}
}
public void TestMixedInjection()
{
IDIContext context = ContextHelper.CreateContext();
context.s().Bind <IMyClass>(() => new MyClassMethodMixed());
context.m().Bind <IOrange>(() => new Orange());
context.m().Bind <IApple>(() => new Apple());
IMyClass obj = context.Resolve <IMyClass>();
Assert.That(obj.orange is Orange);
Assert.That(obj.apple is Apple);
}
public void TestSoftRequirement()
{
IDIContext context = ContextHelper.CreateContext();
context.s().Bind <IMyClass>(() => new MyClassSoftRequirement());
IMyClass obj = context.Resolve <IMyClass>(() => Construction
.ForType <IApple>(new Apple())
);
Assert.That(obj.apple is Apple);
Assert.IsNull(obj.orange);
}
public void Register_ValidRegistrationWithConcreteImplementation_ResolvesInstance()
{
int expectedCounter = 42;
Container container = new Container();
MyClass myConcreteClass = new MyClass {
Counter = expectedCounter
};
container.Register <IMyClass>(myConcreteClass);
IMyClass myResolvedClass = container.Resolve <IMyClass>();
myResolvedClass.Counter.Should().Be(expectedCounter);
}
public void Resolve_MultipleResolutions_SameObject()
{
Container container = new Container();
int expectedCounter = 10;
container.Register <IMyClass, MyClass>();
IMyClass myClassInstance = container.Resolve <IMyClass>();
IMyClass myOtherClassInstance = container.Resolve <IMyClass>();
myClassInstance.Counter = expectedCounter;
myOtherClassInstance.Counter.ShouldBeEquivalentTo(expectedCounter);
}
public void TestTypelessRequirement()
{
IDIContext context = ContextHelper.CreateContext();
context.s().Bind <IMyClass>(() => new MyClassRequirement());
IMyClass obj = context.Resolve <IMyClass>(() => Construction
.For("orange", new Orange())
.And("apple", new Apple())
);
Assert.That(obj.orange is Orange);
Assert.That(obj.apple is Apple);
}
public void TestRequirementPriorityOverContext()
{
IDIContext context = ContextHelper.CreateContext();
context.s().Bind <IMyClass>(() => new MyClass());
context.m().Bind <IOrange>(() => new Orange());
context.m().Bind <IApple>(() => new Apple());
IMyClass obj = context.Resolve <IMyClass>(() => Construction
.ForType <IApple>(new DefaultApple())
);
Assert.That(obj.orange is Orange);
Assert.That(obj.apple is DefaultApple);
}
public void TestInstanceBindingST()
{
MyClass obj = new MyClass();
IDIContext context = ContextHelper.CreateContext();
context.s().BindInstance <IMyClass>(obj);
IMyClass anotherObj = context.Resolve <IMyClass>();
Assert.AreSame(obj, anotherObj);
IMyClass oneMorerObj = context.Resolve <IMyClass>();
Assert.AreSame(obj, oneMorerObj);
}
public static IMyClass CreateMyClass()
{
IMyClass iMyClass = null;
try
{
Guid guid = new Guid("F0239BF9-0A6E-49A6-8853-BADE1B95E66F");
Type myClassType = Type.GetTypeFromCLSID(guid);
object myClass = Activator.CreateInstance(myClassType);
iMyClass = myClass as IMyClass;
}
catch (Exception e)
{
}
return(iMyClass);
}
public void TestCustomFactory()
{
IDIContext context = ContextHelper.CreateContext <IGlobalContextInitializer>();
context.m().Bind(() => new MyClassFactory());
context.m().Bind <IApple>(() => new Apple());
context.m().Bind <IOrange>(() => new Orange());
context.m().Bind <IMyClass>(() => new MyClass());
var factory = context.Resolve <MyClassFactory>();
IMyClass instance = factory.Create();
Assert.IsNotNull(instance);
instance = factory.Destroy(instance);
Assert.IsNull(instance);
}
// Use this for initialization
void Start()
{
//Setup compiler
CSharpCompiler.CodeCompiler compiler = new CSharpCompiler.CodeCompiler();
System.CodeDom.Compiler.CompilerParameters options = new System.CodeDom.Compiler.CompilerParameters();
options.GenerateExecutable = false;
options.GenerateInMemory = true;
options.OutputAssembly = "MyAssembly.dll";
//-- Add ALL assemblies to compiler. This is a security issue as user would have access to System.IO.File to delete data...
//var domain = System.AppDomain.CurrentDomain;
//string[] assemblyReferences = domain.GetAssemblies().Select(a => a.Location).ToArray();
//options.ReferencedAssemblies.AddRange(assemblyReferences);
//-- Add only some specific assemblies
options.ReferencedAssemblies.Add("UnityEngine"); //Add UnityEngine assembly
options.ReferencedAssemblies.Add("Assembly-CSharp"); //Add Assembly which holds all our scripts after build (THIS script is also located in this assembly)
//Compile
var result = compiler.CompileAssemblyFromFileBatch(options, new[] {
Application.streamingAssetsPath + "/BasicExampleScript.cs"
//Add other scripts here, separated by commas
});
//Create instances for all classes we just compiled
//foreach (var type in result.CompiledAssembly.GetTypes())
//{
// if (typeof(Component).IsAssignableFrom(type)) this.gameObject.AddComponent(type); //If type is a MonoBehaviour, add it to the gameobject
// else System.Activator.CreateInstance(type); //Otherwise create a new instance of the class, using the default class constructor
//}
//Add specific MonoBehaviour from our compiled scripts
Type _mb = result.CompiledAssembly.GetType("MyMonoBehaviour");
this.gameObject.AddComponent(_mb);
Debug.Log(result.CompiledAssembly.GetName());
//Create an instance of a specific class
Type _classType = result.CompiledAssembly.GetType("SomePublicClass");
var classInstance = Activator.CreateInstance(_classType);
//Since SomePublicClass uses IMyClass interface (see below), we can cast to it :)
IMyClass myClassInstance = (IMyClass)classInstance;
myClassInstance.DoSomething(); //...and call a function defined in IMyClass
Debug.Log("Sum:" + myClassInstance.Sum(40, 2)); //Another function in SomePublicClass which returns an int
}
public void TestConstructionFactory()
{
IDIContext context = ContextHelper.CreateContext <IGlobalContextInitializer>();
context.m().Bind(() => new MyClassConstructorFactory());
context.m().Bind <IMyClass>(() => new MyClass());
var factory = context.Resolve <MyClassConstructorFactory>();
IMyClass instance = factory.Create(new Apple(), new Orange());
Assert.IsNotNull(instance);
IDIClosedContext cto = instance as IDIClosedContext;
Assert.AreSame(cto.descriptor.context, context);
instance = factory.Destroy(instance);
Assert.IsNull(instance);
}
public void TestSeveralMethodsInjection()
{
IDIContext context = ContextHelper.CreateContext();
context.m().Bind <IMyClass>(() => new MyClassMethodSeveral());
context.m().Bind <IOrange>(() => new Orange());
IMyClass obj = context.Resolve <IMyClass>();
Assert.That(obj.orange is Orange);
Assert.That(obj.apple == null);
obj = context.Resolve <IMyClass>(() => Construction.ForType <IApple>(new Apple()));
Assert.That(obj.orange is Orange);
Assert.That(obj.apple is Apple);
context.m().Bind <IApple>(() => new Apple());
obj = context.Resolve <IMyClass>();
Assert.That(obj.orange is Orange);
Assert.That(obj.apple is Apple);
}
public Proxy(IMyClass myClass)
{
_myClass = myClass;
}
public ClassUser(IMyClass myClass)
{
_myClass = myClass;
}
