public void TestCtorDelegateFromConstructorInfo() { Type type = typeof(TestClass); ConstructorInfo method0 = type.GetConstructor(Type.EmptyTypes); ConstructorInfo method = type.GetConstructor(new Type[] { typeof(string) }); ConstructorInfo method2 = type.GetConstructor(new Type[] { typeof(string), typeof(int) }); // 普通的构造函数。 Assert.AreEqual("NoParam", method0.CreateDelegate <Func <TestClass> >()().Text); Assert.AreEqual("NoParam", ((TestClass)method0.CreateDelegate <Func <object> >()()).Text); Assert.AreEqual(null, method0.CreateDelegate <Func <string, object> >(false)); Assert.AreEqual(null, method0.CreateDelegate <Func <int> >(false)); Assert.AreEqual("Test1", method.CreateDelegate <Func <string, TestClass> >()("Test1").Text); Assert.AreEqual("Test2", method.CreateDelegate <Func <object, TestClass> >()("Test2").Text); Assert.AreEqual(null, method.CreateDelegate <Func <string, string> >(false)); Assert.AreEqual("Test3_10", method2.CreateDelegate <Func <string, int, TestClass> >()("Test3", 10).Text); Assert.AreEqual("Test4_10", method2.CreateDelegate <Func <string, ulong, TestClass> >()("Test4", 10UL).Text); Assert.AreEqual("Test5_10", method2.CreateDelegate <Func <string, short, TestClass> >()("Test5", (short)10).Text); Assert.AreEqual(null, method2.CreateDelegate <Func <string, string, TestClass> >(false)); // 通用构造函数。 Assert.AreEqual("NoParam", ((TestClass)method0.CreateDelegate()()).Text); Assert.AreEqual("Test6", ((TestClass)method.CreateDelegate()("Test6")).Text); Assert.AreEqual("Test7_20", ((TestClass)method2.CreateDelegate()("Test7", 20)).Text); AssertExt.ThrowsException(() => method0.CreateDelegate()("more args"), typeof(TargetParameterCountException)); AssertExt.ThrowsException(() => method.CreateDelegate()(), typeof(TargetParameterCountException)); }
public void TestToByte() { Assert.AreEqual(0, ConvertExt.ToByte("0", 13)); Assert.AreEqual(1, ConvertExt.ToByte("1", 3)); Assert.AreEqual(120, ConvertExt.ToByte("60", 20)); Assert.AreEqual(127, ConvertExt.ToByte("9a", 13)); Assert.AreEqual(128, ConvertExt.ToByte("4c", 29)); Assert.AreEqual(166, ConvertExt.ToByte("4m", 36)); Assert.AreEqual(254, ConvertExt.ToByte("9b", 27)); Assert.AreEqual(255, ConvertExt.ToByte("9c", 27)); AssertExt.ThrowsException(() => ConvertExt.ToByte("38o7", 27), typeof(OverflowException)); }
public void TestToInt64() { Assert.AreEqual(0L, ConvertExt.ToInt64("0", 13)); Assert.AreEqual(1L, ConvertExt.ToInt64("1", 3)); Assert.AreEqual(14720L, ConvertExt.ToInt64("1Gg0", 20)); Assert.AreEqual(9223372036854775807L, ConvertExt.ToInt64("10B269549075433C37", 13)); Assert.AreEqual(-1L, ConvertExt.ToInt64("4Eo8hfam6fllmo", 27)); Assert.AreEqual(-2L, ConvertExt.ToInt64("4Eo8hfam6fllmn", 27)); Assert.AreEqual(-8071017880399937603L, ConvertExt.ToInt64("26tvjyybszf7h", 36)); Assert.AreEqual(-9223372036854775808L, ConvertExt.ToInt64("q1se8f0m04isc", 29)); AssertExt.ThrowsException(() => ConvertExt.ToInt64("4Eo8hfam6fllmp", 27), typeof(OverflowException)); }
public void TestToInt32() { Assert.AreEqual(0, ConvertExt.ToInt32("0", 13)); Assert.AreEqual(1, ConvertExt.ToInt32("1", 3)); Assert.AreEqual(14720, ConvertExt.ToInt32("1Gg0", 20)); Assert.AreEqual(2147483647, ConvertExt.ToInt32("282ba4aaa", 13)); Assert.AreEqual(-1, ConvertExt.ToInt32("b28jpdl", 27)); Assert.AreEqual(-2, ConvertExt.ToInt32("b28jpdk", 27)); Assert.AreEqual(-1235678902, ConvertExt.ToInt32("1elf616", 36)); Assert.AreEqual(-2147483648, ConvertExt.ToInt32("3hk7988", 29)); AssertExt.ThrowsException(() => ConvertExt.ToInt32("b28jpdm", 27), typeof(OverflowException)); }
public void TestToInt16() { Assert.AreEqual(0, ConvertExt.ToInt16("0", 13)); Assert.AreEqual(1, ConvertExt.ToInt16("1", 3)); Assert.AreEqual(14720, ConvertExt.ToInt16("1Gg0", 20)); Assert.AreEqual(32767, ConvertExt.ToInt16("11bb7", 13)); Assert.AreEqual(-1, ConvertExt.ToInt16("38o6", 27)); Assert.AreEqual(-2, ConvertExt.ToInt16("38o5", 27)); Assert.AreEqual(-21458, ConvertExt.ToInt16("y0e", 36)); Assert.AreEqual(-32768, ConvertExt.ToInt16("19rr", 29)); AssertExt.ThrowsException(() => ConvertExt.ToInt16("38o7", 27), typeof(OverflowException)); }
public void TestToUInt64() { Assert.AreEqual(0UL, ConvertExt.ToUInt64("0", 13)); Assert.AreEqual(1UL, ConvertExt.ToUInt64("1", 3)); Assert.AreEqual(14720UL, ConvertExt.ToUInt64("1Gg0", 20)); Assert.AreEqual(9223372036854775807UL, ConvertExt.ToUInt64("10B269549075433C37", 13)); Assert.AreEqual(9223372036854775808UL, ConvertExt.ToUInt64("q1se8f0m04isc", 29)); Assert.AreEqual(10375726193309614013UL, ConvertExt.ToUInt64("26tvjyybszf7h", 36)); Assert.AreEqual(18446744073709551614UL, ConvertExt.ToUInt64("4Eo8hfam6fllmn", 27)); Assert.AreEqual(18446744073709551615UL, ConvertExt.ToUInt64("4Eo8hfam6fllmo", 27)); AssertExt.ThrowsException(() => ConvertExt.ToUInt64("4Eo8hfam6fllmp", 27), typeof(OverflowException)); }
public void TestToUInt32() { Assert.AreEqual(0U, ConvertExt.ToUInt32("0", 13)); Assert.AreEqual(1U, ConvertExt.ToUInt32("1", 3)); Assert.AreEqual(14720U, ConvertExt.ToUInt32("1Gg0", 20)); Assert.AreEqual(2147483647U, ConvertExt.ToUInt32("282ba4aaa", 13)); Assert.AreEqual(2147483648U, ConvertExt.ToUInt32("3hk7988", 29)); Assert.AreEqual(3059288394U, ConvertExt.ToUInt32("1elf616", 36)); Assert.AreEqual(4294967294U, ConvertExt.ToUInt32("b28jpdk", 27)); Assert.AreEqual(4294967295U, ConvertExt.ToUInt32("b28jpdl", 27)); AssertExt.ThrowsException(() => ConvertExt.ToUInt32("b28jpdm", 27), typeof(OverflowException)); }
public void TestInvokeMethod() { Type type = typeof(TestSubClass); BindingFlags bindingFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.InvokeMethod; BindingFlags bindingOptFlags = bindingFlags | BindingFlags.OptionalParamBinding; // 测试完整的调用。 Assert.AreEqual(TestSubClass.TestMethod(), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[0])); Assert.AreEqual(TestSubClass.TestMethod(10), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { 10 })); Assert.AreEqual(TestSubClass.TestMethod(10), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.CastBinder, null, new object[] { 10 })); Assert.AreEqual(TestSubClass.TestMethod(10, 20), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { 10, 20 })); Assert.AreEqual(TestSubClass.TestMethod(10, 20), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.CastBinder, null, new object[] { 10, 20 })); Assert.AreEqual(TestSubClass.TestMethod(30, null, true), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { 30, null, true })); // 测试完整的调用与类型转换。 Type[] invalidCastExceptions = new Type[] { typeof(ArgumentException), typeof(InvalidCastException), typeof(MissingMethodException) }; Assert.AreEqual(TestSubClass.TestMethod((short)10), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { (short)10 })); Assert.AreEqual(TestSubClass.TestMethod((short)10), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.CastBinder, null, new object[] { (short)10 })); AssertExt.ThrowsException(() => type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { 10L }), invalidCastExceptions); Assert.AreEqual(TestSubClass.TestMethod(10), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.CastBinder, null, new object[] { 10L })); Assert.AreEqual(TestSubClass.TestMethod((short)10, (byte)20), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { (short)10, (byte)20 })); AssertExt.ThrowsException(() => type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { 10UL, 20L }), invalidCastExceptions); AssertExt.ThrowsException(() => type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { 10, 20L }), invalidCastExceptions); Assert.AreEqual(TestSubClass.TestMethod(10, 20), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.CastBinder, null, new object[] { 10UL, 20L })); // 测试命名参数。 Assert.AreEqual(TestSubClass.TestMethod(30, "str", true), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { 30, "str", true })); Assert.AreEqual(TestSubClass.TestMethod(value2: "str", value1: 30, value3: true), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { "str", 30, true }, null, null, new string[] { "value2", "value1", "value3" })); Assert.AreEqual(TestSubClass.TestMethod(30, "str", true), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { "str", 30, true }, null, null, new string[] { "value2" })); Assert.AreEqual(TestSubClass.TestMethod(value3: true, value2: "str", value1: 30), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { true, "str", 30 }, null, null, new string[] { "value3", "value2", "value1" })); Assert.AreEqual(TestSubClass.TestMethod(30, "str", true), type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { true, "str", 30 }, null, null, new string[] { "value3", "value2" })); AssertExt.ThrowsException(() => type.InvokeMember("TestMethod", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { 10 }, null, null, new string[] { "values" }), typeof(MissingMethodException)); // 测试默认参数和 params 参数。 Assert.AreEqual(TestSubClass.TestMethod2(30, "str", true, 1, 2, 3), type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 30, "str", true, 1, 2, 3 })); Assert.AreEqual(TestSubClass.TestMethod2(30, "str", true), type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 30, "str", true })); Assert.AreEqual(TestSubClass.TestMethod2(30, "str"), type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 30, "str" })); Assert.AreEqual(TestSubClass.TestMethod2(30), type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 30 })); AssertExt.ThrowsException(() => type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[0]), typeof(MissingMethodException)); // 测试命名参数、默认参数和 params 参数。 Assert.AreEqual(TestSubClass.TestMethod2(value1: 30, value2: "str", value3: true, value4: new int[] { 1, 2, 3 }), type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 30, "str", true, 1, 2, 3 }, null, null, new string[] { "value1", "value2", "value3", "value4" })); Assert.AreEqual(TestSubClass.TestMethod2(30, "str", true, 1, 2, 3), type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 30, "str", true, 1, 2, 3 }, null, null, new string[] { "value1", "value2", "value3" })); Assert.AreEqual(TestSubClass.TestMethod2(value1: 30, value2: "str", value3: true), type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 30, "str", true }, null, null, new string[] { "value1", "value2", "value3" })); Assert.AreEqual(TestSubClass.TestMethod2(30, "str", true, 1, 2, 3), type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 30, "str", 1, true, 2, 3 }, null, null, new string[] { "value1", "value2", "value4" })); Assert.AreEqual(TestSubClass.TestMethod2(value1: 30, value2: "str", value4: new int[] { 1 }), type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 30, "str", new int[] { 1 } }, null, null, new string[] { "value1", "value2", "value4" })); Assert.AreEqual(TestSubClass.TestMethod2(value4: new int[] { 1 }, value3: true, value1: 30), type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { new int[] { 1 }, true, 30 }, null, null, new string[] { "value4", "value3", "value1" })); Assert.AreEqual(TestSubClass.TestMethod2(value4: new int[] { 1 }, value1: 30), type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { new int[] { 1 }, 30 }, null, null, new string[] { "value4", "value1" })); Assert.AreEqual(TestSubClass.TestMethod2(value3: true, value1: 30), type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { true, 30 }, null, null, new string[] { "value3", "value1" })); Assert.AreEqual(TestSubClass.TestMethod2(value1: 30), type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 30 }, null, null, new string[] { "value1" })); // 测试泛型方法。 Assert.AreEqual(TestSubClass.TestMethod3(10, 20), type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { 10, 20 })); Assert.AreEqual(TestSubClass.TestMethod3((short)10, 20), type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { (short)10, 20 })); Assert.AreEqual(TestSubClass.TestMethod3((short)10, (short)20), type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { (short)10, (short)20 })); Assert.AreEqual(TestSubClass.TestMethod3((short)10, (long)20), type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { (short)10, (long)20 })); Assert.AreEqual(TestSubClass.TestMethod3(10, "str"), type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { 10, "str" })); Assert.AreEqual(TestSubClass.TestMethod3((short)10, "str"), type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { (short)10, "str" })); AssertExt.ThrowsException(() => type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { (long)10, "str" }), typeof(MissingMethodException)); Assert.AreEqual(TestSubClass.TestMethod3("text", "str"), type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { "text", "str" })); AssertExt.ThrowsException(() => type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { "str", 10 }), typeof(MissingMethodException)); Assert.AreEqual(TestSubClass.TestMethod3("text", "str", 10), type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { "text", "str", 10 })); Assert.AreEqual(TestSubClass.TestMethod3(10, 20, 30), type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { 10, 20, 30 })); Assert.AreEqual(TestSubClass.TestMethod3(10, 20, "str"), type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.DefaultBinder, null, new object[] { 10, 20, "str" })); Assert.AreEqual("<System.Int32, System.String, System.Int32>(10, str, 20,30)", type.InvokeMember("TestMethod5", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 10, "str", 20, 30 })); Assert.AreEqual("<System.Int32, System.String, System.Int64>(10, str, 20,30)", type.InvokeMember("TestMethod5", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 10, "str", 20L, 30 })); Assert.AreEqual("<System.Int32, System.String, System.Int32>(10, test, 20,30)", type.InvokeMember("TestMethod5", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 10, new int[] { 20, 30 }, "test" }, null, null, new string[] { "value1", "value3", "value2" })); // 测试选择方法。 BindingFlags bindingInsFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod; BindingFlags bindingInsOptFlags = bindingInsFlags | BindingFlags.OptionalParamBinding; TestSubClass subClass = new TestSubClass(); Assert.AreEqual(subClass.TestMethod4(10, 20), type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.CastBinder, subClass, new object[] { 10, 20 })); Assert.AreEqual(subClass.TestMethod4(true, "str"), type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.CastBinder, subClass, new object[] { true, "str" })); Assert.AreEqual(subClass.TestMethod4(10, "str"), type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.CastBinder, subClass, new object[] { 10, "str" })); Assert.AreEqual(subClass.TestMethod4(10, "str"), type.InvokeMember("TestMethod4", bindingInsOptFlags, PowerBinder.CastBinder, subClass, new object[] { 10, "str" })); Assert.AreEqual(subClass.TestMethod4(10, "str", false), type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.CastBinder, subClass, new object[] { 10, "str", false })); Assert.AreEqual(subClass.TestMethod4(10, "str", 1), type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.CastBinder, subClass, new object[] { 10, "str", 1 })); Assert.AreEqual(subClass.TestMethod4(10, "str", new int[] { 1 }), type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.CastBinder, subClass, new object[] { 10, "str", new int[] { 1 } })); Assert.AreEqual(subClass.TestMethod4(10, "str", 1, 2), type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.CastBinder, subClass, new object[] { 10, "str", 1, 2 })); Assert.AreEqual(subClass.TestMethod4(true, true), type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.DefaultBinder, subClass, new object[] { true, true })); Assert.AreEqual(TestSubClass.TestMethod6(value2: 30, value1: "str"), type.InvokeMember("TestMethod6", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 30, "str" }, null, null, new string[] { "value2", "value1" })); Assert.AreEqual(TestSubClass.TestMethod6(value2: (short)30, value1: "str"), type.InvokeMember("TestMethod6", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { (short)30, "str" }, null, null, new string[] { "value2", "value1" })); Assert.AreEqual(TestSubClass.TestMethod6(value2: 30, value1: "str", value3: "str2"), type.InvokeMember("TestMethod6", bindingOptFlags, PowerBinder.DefaultBinder, null, new object[] { 30, "str", "str2" }, null, null, new string[] { "value2", "value1" })); }
public void TestInvokeField() { Type type = typeof(TestClass); Type subType = typeof(TestSubClass); TestSubClass targetSub = new TestSubClass(); TestClass target = targetSub; // 测试父类。 // DefaultBinder Assert.AreEqual(target.TestField, type.InvokeMember("TestField", BindingFlags.GetField, PowerBinder.DefaultBinder, target, new object[0])); Assert.AreEqual(target.TestField2, type.InvokeMember("TestField2", BindingFlags.GetField, PowerBinder.DefaultBinder, target, new object[0])); Assert.AreEqual(target.TestField3, type.InvokeMember("TestField3", BindingFlags.GetField, PowerBinder.DefaultBinder, target, new object[0])); Assert.AreEqual(target.TestField4, type.InvokeMember("TestField4", BindingFlags.GetField, PowerBinder.DefaultBinder, target, new object[0])); // CastBinder Assert.AreEqual(target.TestField, type.InvokeMember("TestField", BindingFlags.GetField, PowerBinder.CastBinder, target, new object[0])); Assert.AreEqual(target.TestField2, type.InvokeMember("TestField2", BindingFlags.GetField, PowerBinder.CastBinder, target, new object[0])); Assert.AreEqual(target.TestField3, type.InvokeMember("TestField3", BindingFlags.GetField, PowerBinder.CastBinder, target, new object[0])); Assert.AreEqual(target.TestField4, type.InvokeMember("TestField4", BindingFlags.GetField, PowerBinder.CastBinder, target, new object[0])); // 测试子类。 // DefaultBinder Assert.AreEqual(targetSub.TestField, subType.InvokeMember("TestField", BindingFlags.GetField, PowerBinder.DefaultBinder, target, new object[0])); Assert.AreEqual(targetSub.TestField2, subType.InvokeMember("TestField2", BindingFlags.GetField, PowerBinder.DefaultBinder, target, new object[0])); Assert.AreEqual(targetSub.TestField3, subType.InvokeMember("TestField3", BindingFlags.GetField, PowerBinder.DefaultBinder, target, new object[0])); Assert.AreEqual(targetSub.TestField4, subType.InvokeMember("TestField4", BindingFlags.GetField, PowerBinder.DefaultBinder, target, new object[0])); // CastBinder Assert.AreEqual(targetSub.TestField, subType.InvokeMember("TestField", BindingFlags.GetField, PowerBinder.CastBinder, target, new object[0])); Assert.AreEqual(targetSub.TestField2, subType.InvokeMember("TestField2", BindingFlags.GetField, PowerBinder.CastBinder, target, new object[0])); Assert.AreEqual(targetSub.TestField3, subType.InvokeMember("TestField3", BindingFlags.GetField, PowerBinder.CastBinder, target, new object[0])); Assert.AreEqual(targetSub.TestField4, subType.InvokeMember("TestField4", BindingFlags.GetField, PowerBinder.CastBinder, target, new object[0])); // 测试设置父类字段。 // DefaultBinder type.InvokeMember("TestField", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { "TestClass0" }); Assert.AreEqual("TestClass0", target.TestField); type.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { (short)20 }); Assert.AreEqual((short)20, target.TestField2); AssertExt.ThrowsException(() => type.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { 20 }), typeof(ArgumentException), typeof(InvalidCastException)); type.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { 200 }); Assert.AreEqual(200L, target.TestField3); type.InvokeMember("TestField4", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { "TestClass44" }); Assert.AreEqual("TestClass44", target.TestField4); // CastBinder type.InvokeMember("TestField", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { "TestClass0" }); Assert.AreEqual("TestClass0", target.TestField); type.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { 20 }); Assert.AreEqual((short)20, target.TestField2); type.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { 200 }); Assert.AreEqual(200L, target.TestField3); type.InvokeMember("TestField4", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { "TestClass44" }); Assert.AreEqual("TestClass44", target.TestField4); // 测试设置子类字段。 // DefaultBinder subType.InvokeMember("TestField", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { "TestSubClass0" }); Assert.AreEqual("TestSubClass0", targetSub.TestField); subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { 21 }); Assert.AreEqual((short)21, targetSub.TestField2); subType.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { 201 }); Assert.AreEqual(201, targetSub.TestField3); subType.InvokeMember("TestField4", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { 202 }); Assert.AreEqual(202, targetSub.TestField4); // CastBinder subType.InvokeMember("TestField", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { "TestSubClass0" }); Assert.AreEqual("TestSubClass0", targetSub.TestField); subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { 21 }); Assert.AreEqual((short)21, targetSub.TestField2); subType.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { 201 }); Assert.AreEqual(201, targetSub.TestField3); subType.InvokeMember("TestField4", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { 202 }); Assert.AreEqual(202, targetSub.TestField4); // 测试设置子类和父类字段。 // DefaultBinder subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { (short)22 }); Assert.AreEqual((short)22, target.TestField2); AssertExt.ThrowsException(() => subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { 23L }), typeof(MissingFieldException), typeof(ArgumentException), typeof(InvalidCastException)); subType.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { 202L }); Assert.AreEqual(202L, target.TestField3); subType.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { (short)203 }); Assert.AreEqual(203, targetSub.TestField3); subType.InvokeMember("TestField4", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { "TestClass00" }); Assert.AreEqual("TestClass00", target.TestField4); // CastBinder subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { (short)22 }); Assert.AreEqual((short)22, target.TestField2); subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { 23L }); Assert.AreEqual(23, targetSub.TestField2); subType.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { 202L }); Assert.AreEqual(202L, target.TestField3); subType.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { (short)203 }); Assert.AreEqual(203, targetSub.TestField3); subType.InvokeMember("TestField4", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { "TestClass00" }); Assert.AreEqual("TestClass00", target.TestField4); // 测试强制类型转换。 // DefaultBinder AssertExt.ThrowsException(() => subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.DefaultBinder, target, new object[1] { Tristate.True }), typeof(MissingFieldException), typeof(ArgumentException), typeof(InvalidCastException)); // CastBinder subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { Tristate.True }); Assert.AreEqual((int)Tristate.True, targetSub.TestField2); AssertExt.ThrowsException(() => subType.InvokeMember("TestField", BindingFlags.SetField, PowerBinder.CastBinder, target, new object[1] { 22 }), typeof(MissingFieldException)); }
public void TestMethodDelegateFromMethodInfo() { Type type = typeof(TestClass); MethodInfo method0 = type.GetMethod("TestStaticMethod", Type.EmptyTypes); MethodInfo method = type.GetMethod("TestStaticMethod", new Type[] { typeof(string) }); MethodInfo method2 = type.GetMethod("TestStaticMethod", new Type[] { typeof(string), typeof(int) }); MethodInfo method3 = type.GetMethod("TestStaticMethod2"); MethodInfo method4 = type.GetMethod("TestStaticMethod3"); // 开放的静态方法。 Assert.AreEqual("StaticMethod", method0.CreateDelegate <Func <string> >()()); Assert.AreEqual("StaticMethod", method0.CreateDelegate <Func <object> >()()); Assert.AreEqual(null, method0.CreateDelegate <Func <string, string> >(false)); Assert.AreEqual(null, method0.CreateDelegate <Func <int> >(false)); Assert.AreEqual("Test1_StaticMethod", method.CreateDelegate <Func <string, string> >()("Test1")); Assert.AreEqual("Test2_StaticMethod", method.CreateDelegate <Func <string, string> >(null)("Test2")); Assert.AreEqual("Test2_StaticMethod", method.CreateDelegate <Func <string, string> >("NoUse")("Test2")); Assert.AreEqual(null, method.CreateDelegate <Func <int, string> >(false)); Assert.AreEqual(null, method.CreateDelegate <Func <string, int> >(false)); Assert.AreEqual("Test3_StaticMethod", method.CreateDelegate <Func <object, string> >()("Test3")); Assert.AreEqual("Test4_StaticMethod", method.CreateDelegate <Func <object, object> >()("Test4")); Assert.AreEqual("Test5_10_StaticMethod", method2.CreateDelegate <Func <string, int, string> >()("Test5", 10)); Assert.AreEqual("Test6_10_StaticMethod", method2.CreateDelegate <Func <string, short, string> >()("Test6", 10)); Assert.AreEqual("Test7_10_StaticMethod", method2.CreateDelegate <Func <string, ulong, string> >()("Test7", 10UL)); Assert.AreEqual("Test8_10_StaticMethod", method2.CreateDelegate <Func <object, ulong, string> >()("Test8", 10UL)); Assert.AreEqual("Test9_10_StaticMethod", method2.CreateDelegate <Func <object, ulong, object> >()("Test9", 10UL)); Assert.AreEqual(null, method2.CreateDelegate <Func <string, string, string> >(false)); // 第一个参数封闭的静态方法。 Assert.AreEqual("StaticMethod", method0.CreateDelegate <Func <string> >(null)()); Assert.AreEqual("_StaticMethod", method.CreateDelegate <Func <string> >(null)()); Assert.AreEqual("Test10_StaticMethod", method.CreateDelegate <Func <string> >("Test10")()); Assert.AreEqual("Test11_StaticMethod", method.CreateDelegate <Func <object> >("Test11")()); Assert.AreEqual(null, method.CreateDelegate <Func <int> >("Test11", false)); // 通用静态方法。 Assert.AreEqual("StaticMethod", method0.CreateDelegate()("NoUse")); Assert.AreEqual("Test12_StaticMethod", method.CreateDelegate()("NoUse", "Test12")); AssertExt.ThrowsException(() => method0.CreateDelegate()("Instance", "more args"), typeof(TargetParameterCountException)); AssertExt.ThrowsException(() => method.CreateDelegate()("Instance"), typeof(TargetParameterCountException)); // 开放的泛型静态方法。 Assert.AreEqual("<System.String>Test13_StaticMethod", method3.CreateDelegate <Func <string, string> >()("Test13")); Assert.AreEqual("<System.Int32>14_StaticMethod", method3.CreateDelegate <Func <int, string> >()(14)); Assert.AreEqual("<System.String>Test15_StaticMethod", method3.CreateDelegate <Func <string, string> >(null)("Test15")); Assert.AreEqual("<System.String>Test16_StaticMethod", method3.CreateDelegate <Func <string, string> >("NoUse")("Test16")); Assert.AreEqual(null, method3.CreateDelegate <Func <string, int> >(false)); // 第一个参数封闭的泛型静态方法。 Assert.AreEqual("<System.Object>_StaticMethod", method3.CreateDelegate <Func <string> >(null)()); Assert.AreEqual("<System.String>Test17_StaticMethod", method3.CreateDelegate <Func <string> >("Test17")()); Assert.AreEqual("<System.String>Test18_StaticMethod", method3.CreateDelegate <Func <object> >("Test18")()); Assert.AreEqual("<System.Int32>19_StaticMethod", method3.CreateDelegate <Func <string> >(19)()); Assert.AreEqual(null, method3.CreateDelegate <Func <int> >("Test11", false)); // 特殊静态方法。 Assert.AreEqual("A_B_StaticMethod", method4.CreateDelegate <Func <string, string, int, string> >()("A", "B", 0)); Assert.AreEqual("A_B_StaticMethod", method4.CreateDelegate <Func <string, int, string> >("A")("B", 0)); string value = "B"; int value2; Assert.AreEqual("A_B_StaticMethod", method4.CreateDelegate <TestDelegate>()("A", ref value, out value2)); Assert.AreEqual("StaticMethodRef", value); Assert.AreEqual(101, value2); // 实例方法。 method0 = type.GetMethod("TestInstanceMethod", Type.EmptyTypes); method = type.GetMethod("TestInstanceMethod", new Type[] { typeof(string) }); method2 = type.GetMethod("TestInstanceMethod", new Type[] { typeof(string), typeof(int) }); method3 = type.GetMethod("TestInstanceMethod2"); method4 = type.GetMethod("TestInstanceMethod3"); TestClass tc = new TestClass(); tc.Text = "TC"; // 开放的实例方法。 Assert.AreEqual("TC_InstanceMethod", method0.CreateDelegate <Func <TestClass, string> >()(tc)); Assert.AreEqual("TC_InstanceMethod", method0.CreateDelegate <Func <TestClass, string> >(null)(tc)); Assert.AreEqual("TC_InstanceMethod", method0.CreateDelegate <Func <TestClass, string> >("NoUse")(tc)); Assert.AreEqual("TC_InstanceMethod", method0.CreateDelegate <Func <object, object> >()(tc)); Assert.AreEqual(null, method0.CreateDelegate <Func <TestClass, string, string> >(false)); Assert.AreEqual(null, method0.CreateDelegate <Func <TestClass, int> >(false)); Assert.AreEqual("Test1_TC_InstanceMethod", method.CreateDelegate <Func <TestClass, string, string> >()(tc, "Test1")); Assert.AreEqual("Test2_TC_InstanceMethod", method.CreateDelegate <Func <TestClass, string, string> >(null)(tc, "Test2")); Assert.AreEqual("Test2_TC_InstanceMethod", method.CreateDelegate <Func <TestClass, string, string> >("NoUse")(tc, "Test2")); Assert.AreEqual(null, method.CreateDelegate <Func <TestClass, int, string> >(false)); Assert.AreEqual(null, method.CreateDelegate <Func <TestClass, string, int> >(false)); Assert.AreEqual("Test3_TC_InstanceMethod", method.CreateDelegate <Func <TestClass, object, string> >()(tc, "Test3")); Assert.AreEqual("Test4_TC_InstanceMethod", method.CreateDelegate <Func <TestClass, object, object> >()(tc, "Test4")); Assert.AreEqual("Test4_TC_InstanceMethod", method.CreateDelegate <Func <object, object, object> >()(tc, "Test4")); Assert.AreEqual("Test5_10_TC_InstanceMethod", method2.CreateDelegate <Func <TestClass, string, int, string> >()(tc, "Test5", 10)); Assert.AreEqual("Test6_10_TC_InstanceMethod", method2.CreateDelegate <Func <TestClass, string, short, string> >()(tc, "Test6", 10)); Assert.AreEqual("Test7_10_TC_InstanceMethod", method2.CreateDelegate <Func <TestClass, string, ulong, string> >()(tc, "Test7", 10UL)); Assert.AreEqual("Test8_10_TC_InstanceMethod", method2.CreateDelegate <Func <TestClass, object, ulong, string> >()(tc, "Test8", 10UL)); Assert.AreEqual("Test9_10_TC_InstanceMethod", method2.CreateDelegate <Func <TestClass, object, ulong, object> >()(tc, "Test9", 10UL)); Assert.AreEqual(null, method2.CreateDelegate <Func <TestClass, string, string, string> >(false)); // 第一个参数封闭的实例方法。 Assert.AreEqual("TC_InstanceMethod", method0.CreateDelegate <Func <string> >(tc)()); Assert.AreEqual("NullThis_InstanceMethod", method0.CreateDelegate <Func <string> >(null)()); Assert.AreEqual("Test10_NullThis_InstanceMethod", method.CreateDelegate <Func <string, string> >(null)("Test10")); Assert.AreEqual("Test10_NullThis_InstanceMethod", method.CreateDelegate <Func <object, string> >(null)("Test10")); Assert.AreEqual("Test10_NullThis_InstanceMethod", method.CreateDelegate <Func <string, object> >(null)("Test10")); Assert.AreEqual("Test10_NullThis_InstanceMethod", method.CreateDelegate <Func <object, object> >(null)("Test10")); Assert.AreEqual(null, method.CreateDelegate <Func <int, object> >(null)); Assert.AreEqual("Test10_TC_InstanceMethod", method.CreateDelegate <Func <string, string> >(tc)("Test10")); Assert.AreEqual("Test11_TC_InstanceMethod", method.CreateDelegate <Func <string, object> >(tc)("Test11")); Assert.AreEqual("Test11_TC_InstanceMethod", method.CreateDelegate <Func <object, object> >(tc)("Test11")); Assert.AreEqual(null, method.CreateDelegate <Func <int> >(tc, false)); // 通用实例方法。 Assert.AreEqual("Test12_TC_InstanceMethod", method.CreateDelegate()(tc, "Test12")); Assert.AreEqual("TC_InstanceMethod", method0.CreateDelegate()(tc)); // 开放的泛型实例方法。 Assert.AreEqual("<System.String>Test13_TC_InstanceMethod", method3.CreateDelegate <Func <TestClass, string, string> >()(tc, "Test13")); Assert.AreEqual("<System.Int32>14_TC_InstanceMethod", method3.CreateDelegate <Func <TestClass, int, string> >()(tc, 14)); Assert.AreEqual("<System.String>Test15_TC_InstanceMethod", method3.CreateDelegate <Func <TestClass, string, string> >(null)(tc, "Test15")); Assert.AreEqual("<System.String>Test16_TC_InstanceMethod", method3.CreateDelegate <Func <TestClass, string, string> >("NoUse")(tc, "Test16")); Assert.AreEqual("<System.Object>Test16_TC_InstanceMethod", method3.CreateDelegate <Func <object, object, string> >("NoUse")(tc, "Test16")); Assert.AreEqual(null, method3.CreateDelegate <Func <TestClass, string, int> >(false)); // 第一个参数封闭的泛型实例方法。 Assert.AreEqual("<System.String>Test17_NullThis_InstanceMethod", method3.CreateDelegate <Func <string, string> >(null)("Test17")); Assert.AreEqual("<System.Object>Test17_NullThis_InstanceMethod", method3.CreateDelegate <Func <object, string> >(null)("Test17")); Assert.AreEqual("<System.String>Test17_NullThis_InstanceMethod", method3.CreateDelegate <Func <string, object> >(null)("Test17")); Assert.AreEqual("<System.Object>Test17_NullThis_InstanceMethod", method3.CreateDelegate <Func <object, object> >(null)("Test17")); Assert.AreEqual("<System.Int32>17_NullThis_InstanceMethod", method3.CreateDelegate <Func <int, object> >(null)(17)); Assert.AreEqual(null, method3.CreateDelegate <Func <int, int> >(null)); Assert.AreEqual("<System.String>Test18_TC_InstanceMethod", method3.CreateDelegate <Func <string, string> >(tc)("Test18")); Assert.AreEqual("<System.String>Test19_TC_InstanceMethod", method3.CreateDelegate <Func <string, object> >(tc)("Test19")); Assert.AreEqual("<System.Object>Test20_TC_InstanceMethod", method3.CreateDelegate <Func <object, object> >(tc)("Test20")); Assert.AreEqual("<System.Int32>21_TC_InstanceMethod", method3.CreateDelegate <Func <int, object> >(tc)(21)); // 特殊实例方法。 Assert.AreEqual("A_B_InstanceMethod", method4.CreateDelegate <Func <TestClass, string, string, int, string> >()(tc, "A", "B", 0)); Assert.AreEqual("B", tc.Text); tc.Text = "XXX"; Assert.AreEqual("A_B_InstanceMethod", method4.CreateDelegate <Func <string, string, int, string> >(tc)("A", "B", 0)); Assert.AreEqual("B", tc.Text); value = "B"; value2 = 0; tc.Text = "XXX"; Assert.AreEqual("A_B_InstanceMethod", method4.CreateDelegate <TestDelegate>(tc)("A", ref value, out value2)); Assert.AreEqual("InstanceMethodRef", value); Assert.AreEqual("B", tc.Text); Assert.AreEqual(101, value2); }