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 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 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);
}
public void TestMakeGenericMethodFromParams()
{
Type type = typeof(TestClass);
MethodInfo method = type.GetMethod("TestMethod");
AssertExt.AreEqual(new Type[] { typeof(int) }, method.GenericArgumentsInferences(typeof(int)));
AssertExt.AreEqual(new Type[] { typeof(uint) }, method.GenericArgumentsInferences(typeof(uint)));
method = type.GetMethod("TestMethod2");
AssertExt.AreEqual(new Type[] { typeof(int) }, method.GenericArgumentsInferences(typeof(int)));
AssertExt.AreEqual(new Type[] { typeof(uint) }, method.GenericArgumentsInferences(typeof(uint)));
method = type.GetMethod("TestMethod3");
AssertExt.AreEqual(new Type[] { typeof(int) },
method.GenericArgumentsInferences(typeof(int), typeof(int)));
AssertExt.AreEqual(new Type[] { typeof(object) },
method.GenericArgumentsInferences(typeof(string), typeof(object)));
AssertExt.AreEqual(new Type[] { typeof(IList <int>) },
method.GenericArgumentsInferences(typeof(int[]), typeof(IList <int>)));
AssertExt.AreEqual(new Type[] { typeof(IList <int>) },
method.GenericArgumentsInferences(typeof(IList <int>), typeof(int[])));
AssertExt.AreEqual(null, method.GenericArgumentsInferences(typeof(uint), typeof(string)));
method = type.GetMethod("TestMethod4");
AssertExt.AreEqual(new Type[] { typeof(int) },
method.GenericArgumentsInferences(typeof(int), typeof(int)));
AssertExt.AreEqual(new Type[] { typeof(IList <int>) },
method.GenericArgumentsInferences(typeof(IList <int>), typeof(int[])));
AssertExt.AreEqual(null, method.GenericArgumentsInferences(typeof(int[]), typeof(IList <int>)));
AssertExt.AreEqual(null, method.GenericArgumentsInferences(typeof(string), typeof(object)));
AssertExt.AreEqual(null, method.GenericArgumentsInferences(typeof(uint), typeof(string)));
method = type.GetMethod("TestMethod5");
AssertExt.AreEqual(new Type[] { typeof(int) }, method.GenericArgumentsInferences(typeof(int[]), typeof(int)));
AssertExt.AreEqual(new Type[] { typeof(long) }, method.GenericArgumentsInferences(typeof(long[]), typeof(int)));
method = type.GetMethod("TestMethod6");
AssertExt.AreEqual(new Type[] { typeof(int), typeof(string) },
method.GenericArgumentsInferences(typeof(List <IDictionary <int, string> >), typeof(IList <int[]>)));
AssertExt.AreEqual(null,
method.GenericArgumentsInferences(typeof(List <Dictionary <int, string> >), typeof(IList <long[]>)));
method = type.GetMethod("TestMethod7");
AssertExt.AreEqual(new Type[] { typeof(int), typeof(string) },
method.GenericArgumentsInferences(typeof(List <IDictionary <int, string> >), typeof(IList <int[]>)));
AssertExt.AreEqual(new Type[] { typeof(int), typeof(string) },
method.GenericArgumentsInferences(typeof(List <Dictionary <int, string> >), typeof(IList <int[]>)));
AssertExt.AreEqual(null,
method.GenericArgumentsInferences(typeof(List <Dictionary <int, string> >), typeof(IList <long[]>)));
method = type.GetMethod("TestMethod8");
AssertExt.AreEqual(new Type[] { typeof(int) },
method.GenericArgumentsInferences(typeof(int), typeof(int), typeof(int), typeof(int)));
AssertExt.AreEqual(new Type[] { typeof(string) },
method.GenericArgumentsInferences(typeof(string), typeof(string), typeof(object), typeof(object)));
AssertExt.AreEqual(new Type[] { typeof(string) },
method.GenericArgumentsInferences(typeof(string), typeof(string[])));
AssertExt.AreEqual(new Type[] { typeof(string[]) },
method.GenericArgumentsInferences(typeof(string[]), typeof(string[])));
AssertExt.AreEqual(new Type[] { typeof(string[][]) },
method.GenericArgumentsInferences(typeof(string[][]), typeof(string[][])));
AssertExt.AreEqual(new Type[] { typeof(string[]) },
method.GenericArgumentsInferences(typeof(string[]), typeof(string[][])));
AssertExt.AreEqual(new Type[] { typeof(string) },
method.GenericArgumentsInferences(typeof(string), typeof(string)));
AssertExt.AreEqual(new Type[] { typeof(string) }, method.GenericArgumentsInferences(typeof(string)));
method = type.GetMethod("TestMethod9");
AssertExt.AreEqual(new Type[] { typeof(int), typeof(string) },
method.GenericArgumentsInferences(typeof(Func <int, string>), typeof(int), typeof(string)));
AssertExt.AreEqual(new Type[] { typeof(TestClass2), typeof(string) },
method.GenericArgumentsInferences(typeof(Func <TestClass2, string>), typeof(TestClass3), typeof(string)));
AssertExt.AreEqual(null,
method.GenericArgumentsInferences(typeof(Func <short, string>), typeof(int), typeof(string)));
AssertExt.AreEqual(new Type[] { typeof(object), typeof(string) },
method.GenericArgumentsInferences(typeof(Func <object, string>), typeof(string), typeof(string)));
AssertExt.AreEqual(new Type[] { typeof(int), typeof(string) },
method.GenericArgumentsInferences(typeof(Func <int, string>), typeof(short), typeof(string)));
AssertExt.AreEqual(new Type[] { typeof(int), typeof(object) },
method.GenericArgumentsInferences(typeof(Func <int, string>), typeof(short), typeof(object)));
AssertExt.AreEqual(new Type[] { typeof(IList <int>), typeof(object) },
method.GenericArgumentsInferences(typeof(Func <IList <int>, string>), typeof(int[]), typeof(object)));
AssertExt.AreEqual(new Type[] { typeof(IList <int>), typeof(object) },
method.GenericArgumentsInferences(typeof(Func <IList <int>, object>), typeof(int[]), typeof(string)));
AssertExt.AreEqual(new Type[] { typeof(IList <int>), typeof(IList <int>) },
method.GenericArgumentsInferences(typeof(Func <IList <int>, int[]>), typeof(int[]), typeof(IList <int>)));
}
