/// <summary> /// Forwards an interface (and optionally ints inherited interfaces) to a target implementation, overriding some members with anonymous implementations. /// </summary> /// <typeparam name="TInterface">The interface type.</typeparam> /// <param name="defaultTarget">The target implementation, which receives any interface calls not overriden by the anonymous implementation.</param> /// <param name="anonymousDefinition">The anonymous implementation definition delegate, which receives and returns an anonymous implementation builder. Do not call <c>Create</c> on the anonymous implementation builder.</param> /// <param name="includeInheritedInterfaces"><c>true</c> to forward/implement inherited interfaces; <c>false</c> to only forward/implement the specified interface type.</param> public AmalgamBuilder Override<TInterface>(TInterface defaultTarget, Func<AnonymousInterface.Util.Builder<TInterface>, AnonymousInterface.Util.Builder<TInterface>> anonymousDefinition, bool includeInheritedInterfaces = true) where TInterface : class { var builder = Anonymous.Implement<TInterface>(defaultTarget); builder = anonymousDefinition(builder); Add(typeof(TInterface), builder.Create(), includeInheritedInterfaces); return this; }
object IAmalgamator.CreateAmalgam() { Anonymous.Implement <ITest>() .Method <Action>(x => x.A, () => { }) .Method <Action <int> >(x => x.A, _ => { }) .Method <TestDelegate1>(x => x.A, (out int x) => { x = 0; }) .Method <TestDelegate2>(x => x.A, (int x, ref int y) => { }) .Method <Func <int> >(x => x.B, () => 2) .PropertyGet(x => x.valg, () => 17) .PropertyGet(x => x.val, () => 13) .PropertySet(x => x.val, value => { }) .PropertySet <int>("vals", value => { }) .EventSubscribe <Action>("X", value => { }) .EventUnsubscribe <Action>("X", value => { }) .IndexGet <Func <int, string> >(index => null) .IndexSet <Action <int, string> >((index, value) => { }) .Create(); return(Amalgamation.Build() .Forward <ILongCountable>(a, false) .Forward <IContainsCountable>(this) .Override <ICountable>(a, anon => anon .PropertyGet(x => x.Count, OverrideCount) .Method <Func <int> >(x => x.GetCount, OverrideCount)) .Create()); }
public void GenericMethod_RequiresImplementation() { var core = new GenericMethodTest(); var instance = Anonymous.Implement <ITest>(core) .Create(); instance.E(13); Assert.AreEqual(13, core.observed); }
public void Method_WithNormalParameters() { int observed = 0; var instance = Anonymous.Implement <ITest>() .Method <Action <int> >(x => x.A, x => { observed = x; }) .Create(); instance.A(13); Assert.AreEqual(13, observed); }
public void PropertySet_WhichDoesNotHaveGet() { int observed = 0; var instance = Anonymous.Implement <ITest>() .PropertySet <int>("vals", x => { observed = x; }) .Create(); instance.vals = 13; Assert.AreEqual(13, observed); }
public void PropertySet_WhichAlsoHasGet() { int observed = 0; var instance = Anonymous.Implement <ITest>() .PropertySet(x => x.val, x => { observed = x; }) .Create(); instance.val = 13; Assert.AreEqual(13, observed); }
public void PropertyGet_WhichDoesNotHaveSet() { int retval = 13; var instance = Anonymous.Implement <ITest>() .PropertyGet(x => x.valg, () => retval) .Create(); int val = instance.valg; Assert.AreEqual(13, val); }
public void Method_HiddenFromBaseInterface() { int observed = 0; var instance = Anonymous.Implement <ITest>() .Method <Action>(x => ((ITestBase)x).A, () => { observed = 13; }) .Create() as ITestBase; instance.A(); Assert.AreEqual(13, observed); }
public void Method_WithParams() { int[] observed = null; var instance = Anonymous.Implement <ITest>() .Method <Action <int[]> >(x => x.C, x => { observed = x; }) .Create(); instance.C(3, 5, 7); Assert.IsTrue(observed.SequenceEqual(new[] { 3, 5, 7 })); }
public void Method_WithReturnValue() { int retval = 11; var instance = Anonymous.Implement <ITest>() .Method <Func <int> >(x => x.B, () => retval) .Create(); int val = instance.B(); Assert.AreEqual(11, val); }
public void Method_WithOutParameters() { int retval = 11; var instance = Anonymous.Implement <ITest>() .Method <TestDelegate1>(x => x.A, (out int x) => { x = retval; }) .Create(); int val = 0; instance.A(out val); Assert.AreEqual(11, val); }
public void EventUnsubscribe() { Action observed = null; var instance = Anonymous.Implement <ITest>() .EventUnsubscribe <Action>("X", x => { observed = x; }) .Create(); Action value = () => { }; instance.X -= value; Assert.AreEqual(value, observed); }
public void IndexSet() { int observedIndex = 0; string observedValue = null; var instance = Anonymous.Implement <ITest>() .IndexSet <Action <int, string> >((index, value) => { observedIndex = index; observedValue = value; }) .Create(); instance[13] = "test"; Assert.AreEqual(13, observedIndex); Assert.AreEqual("test", observedValue); }
public void IndexGet() { int observedIndex = 0; string retval = "test"; var instance = Anonymous.Implement <ITest>() .IndexGet <Func <int, string> >(index => { observedIndex = index; return(retval); }) .Create(); string val = instance[15]; Assert.AreEqual(15, observedIndex); Assert.AreEqual("test", val); }
public void Method_WithDefaultValues() { int observed = 0; var instance = Anonymous.Implement <ITest>() .Method <Action <int> >(x => x.D, x => { observed = x; }) .Create(); instance.D(); Assert.AreEqual(3, observed); instance.D(13); Assert.AreEqual(13, observed); }
public void Method_WithRefParameters() { int observedX = 0; int observedY = 0; int retval = 11; var instance = Anonymous.Implement <ITest>() .Method <TestDelegate2>(x => x.A, (int x, ref int y) => { observedX = x; observedY = y; y = retval; }) .Create(); int valX = 3; int valY = 5; instance.A(valX, ref valY); Assert.AreEqual(3, observedX); Assert.AreEqual(5, observedY); Assert.AreEqual(11, valY); }