public void BuildProxyType_ComplexGenericArguments_Virtual()
{
var knownBaseType = typeof(ProxiedChildGeneric <Proxied, Document>);
var typeFilter = new TypeLevelTypeFilter(new[] { knownBaseType });
var proxiedType = typeof(ProxiedChildChildGeneric <Proxied, Document>);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildProxyType_CheckInterfaceMembers"));
var proxyType = stableBindingProxyBuilder.BuildProxyType();
const string methodName = "ProxiedChildGeneric_ComplexGenericArguments_Virtual";
AssertHasSameGenericMethod(knownBaseType, proxyType, methodName, 2);
var proxied = new ProxiedChildChildGeneric <Proxied, Document> ();
var proxyMethodGeneric = GetGenericMethod(proxyType, methodName, 2);
Assert.That(proxyMethodGeneric.IsGenericMethod, Is.True);
var proxyMethod = proxyMethodGeneric.MakeGenericMethod(typeof(string), typeof(int));
var proxy = Activator.CreateInstance(proxyType, proxied);
var p0 = new Proxied("Hello");
var p1 = new Document("Doc");
const string p2 = "xyz";
const int p3 = 1234567;
var methodArguments = Create_ProxiedChildGeneric_ComplexGenericArguments_Parameters(p0, p1, p2, p3);
var proxyResult = (string)proxyMethod.Invoke(proxy, methodArguments);
StringAssert.StartsWith("ProxiedChildGeneric::ProxiedChildGeneric_ComplexGenericArguments_Virtual", proxyResult);
}
public void AddForwardingMethod_MethodWithVariableNumberOfParameters()
{
var proxyBuilder = new ForwardingProxyBuilder("AddForwardingProperty_MethodWithVariableNumberOfParameters", ModuleScope, typeof(Proxied), new Type[0]);
var methodInfo = typeof(Proxied).GetMethod("Sum");
var methodEmitter = proxyBuilder.AddForwardingMethod(methodInfo);
Type proxyType = proxyBuilder.BuildProxyType();
// Added by FS
AssertMethodInfoEqual(methodEmitter.MethodBuilder, methodInfo);
// Create proxy instance, initializing it with class to be proxied
var proxied = new Proxied("ProxiedProxySumTest");
object proxy = Activator.CreateInstance(proxyType, proxied);
// Check calling proxied method through reflection
const string resultExpected = "ProxiedProxySumTest: 12";
Assert.That(proxied.Sum(3, 4, 5), Is.EqualTo(resultExpected));
Assert.That(methodInfo.Invoke(proxied, new object[] { new int[] { 3, 4, 5 } }), Is.EqualTo(resultExpected));
var proxyMethodInfo = proxy.GetType().GetMethod("Sum");
AssertMethodInfoEqual(proxyMethodInfo, methodInfo);
Assert.That(proxyMethodInfo.Invoke(proxy, new object[] { new int[] { 3, 4, 5 } }), Is.EqualTo(resultExpected));
Assert.That(proxyMethodInfo.Invoke(proxy, new object[] { new int[] { } }), Is.EqualTo("ProxiedProxySumTest: 0"));
Assert.That(proxyMethodInfo.Invoke(proxy, new object[] { new int[] { 1 } }), Is.EqualTo("ProxiedProxySumTest: 1"));
Assert.That(proxyMethodInfo.Invoke(proxy, new object[] { new int[] { 1000, 100, 10, 1 } }), Is.EqualTo("ProxiedProxySumTest: 1111"));
}
/*
* Method uses the object passed in the constructor
*/
public T Calculate(dynamic x)
{
if (!Cache.Keys.Contains(x))
{
Cache[x] = Proxied.Calculate(x);;
}
return(Cache[x]);
}
public void BuildProxyType()
{
var proxyBuilder = new ForwardingProxyBuilder("ForwardingProxyBuilder_BuildProxyTypeTest", ModuleScope, typeof(Proxied), new Type[0]);
Type proxyType = proxyBuilder.BuildProxyType();
// Create proxy instance, initializing it with class to be proxied
var proxied = new Proxied();
object proxy = Activator.CreateInstance(proxyType, proxied);
FieldInfo proxiedFieldInfo = proxy.GetType().GetField("_proxied", _nonPublicInstanceFlags);
Assert.That(proxiedFieldInfo.GetValue(proxy), Is.EqualTo(proxied));
Assert.That(proxiedFieldInfo.IsInitOnly, Is.False);
Assert.That(proxiedFieldInfo.IsPrivate, Is.True);
}
public void IProxy()
{
var proxyBuilder = new ForwardingProxyBuilder("IProxy", ModuleScope, typeof(Proxied), new Type[0]);
Type proxyType = proxyBuilder.BuildProxyType();
var proxied = new Proxied("AAA");
object proxy = Activator.CreateInstance(proxyType, proxied);
Assert.That(ScriptingHelper.GetProxiedFieldValue(proxy), Is.SameAs(proxied));
var proxied2 = new Proxied("BBB");
((IProxy)proxy).SetProxied(proxied2);
Assert.That(ScriptingHelper.GetProxiedFieldValue(proxy), Is.SameAs(proxied2));
}
public void AddForwardingMethodFromMethodInfoCopy_ImplicitInterfaceMethod()
{
var proxyBuilder = new ForwardingProxyBuilder("AddForwardingMethodFromMethodInfoCopy_ImplicitInterfaceMethod",
ModuleScope, typeof(Proxied), new[] { typeof(IProxiedGetName) });
proxyBuilder.AddForwardingMethodFromClassOrInterfaceMethodInfoCopy(typeof(IProxiedGetName).GetMethod("GetName"));
Type proxyType = proxyBuilder.BuildProxyType();
// Create proxy instance, initializing it with class to be proxied
var proxied = new Proxied();
object proxy = Activator.CreateInstance(proxyType, proxied);
Assert.That(proxy.GetType().GetInterfaces(), Is.EquivalentTo((new[] { typeof(IProxiedGetName), typeof(IProxy) })));
Assert.That(((IProxiedGetName)proxy).GetName(), Is.EqualTo("Implementer.IProxiedGetName"));
Assert.That(proxy.GetType().GetMethod("GetName").Invoke(proxy, new object[0]), Is.EqualTo("Implementer.IProxiedGetName"));
}
public void AddForwardingMethodFromMethodInfoCopy_Method()
{
var proxyBuilder = new ForwardingProxyBuilder("AddForwardingMethodFromMethodInfoCopy_Method", ModuleScope, typeof(Proxied), new Type[0]);
var methodInfo = typeof(Proxied).GetMethod("PrependName");
proxyBuilder.AddForwardingMethodFromClassOrInterfaceMethodInfoCopy(methodInfo);
Type proxyType = proxyBuilder.BuildProxyType();
var proxied = new Proxied("The name");
object proxy = Activator.CreateInstance(proxyType, proxied);
// Check calling proxied method through reflection
Assert.That(methodInfo.Invoke(proxied, new object[] { "is Smith" }), Is.EqualTo("The name is Smith"));
var proxyMethodInfo = proxy.GetType().GetMethod("PrependName");
AssertMethodInfoEqual(proxyMethodInfo, methodInfo);
Assert.That(proxyMethodInfo.Invoke(proxy, new object[] { "is Smith" }), Is.EqualTo("The name is Smith"));
}
public override int GetHashCode()
{
return(Proxied.GetHashCode());
}
public override string ToString()
{
return(Proxied.ToString());
}
