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; }