public void SomeFunction()
{
SomeClass2 someClass2 = new SomeClass2();
SomeClass3 someClass3 = new SomeClass3();
// Note: SomeClass41 is not accessable!
//SomeClass4.SomeClass41 someClass41 = new SomeClass4.SomeClass41();
SomeClass4.SomeClass42 someClass42 = new SomeClass4.SomeClass42();
SomeClass4.SomeClass43 someClass43 = new SomeClass4.SomeClass43();
// Note: SomeClass51 is not accessable!
//SomeClass5.SomeClass51 someClass51 = new SomeClass5.SomeClass51();
SomeClass5.SomeClass52 someClass52 = new SomeClass5.SomeClass52();
SomeClass5.SomeClass53 someClass53 = new SomeClass5.SomeClass53();
SomeClass6 someClass6 = new SomeClass6();
someClass6.A = 10;
// Note: B Property is not Accessable!
//someClass6.B = 20;
// Note: C Property is not Accessable!
//someClass6.C = 30;
someClass6.D = 40;
someClass6.E = 50;
}
public void SetterWorksForPrivate()
{
var c = new SomeClass3();
typeof(SomeClass3).Property("Priv").SetterAs <Action <SomeClass3, int> >()(c, 5);
Assert.Equal(5, typeof(SomeClass3).Property("Priv").GetterAs <Func <SomeClass3, object> >()(c));
}
public void InvokesVirtualMethodAs()
{
var t2 = new SomeClass2();
var t3 = new SomeClass3();
var method = typeof(SomeClass2).Method("SetP2P3", typeof(string), typeof(string));
Assert.Null(method.InvokerAs <Func <SomeClass2, string, string, object> >()(t2, "t1", "t2"));
Assert.Equal("t1", t2.P2);
Assert.Equal("t2", t2.P3);
Assert.Null(method.InvokerAs <Func <object, string, object, object> >()(t2, "t1!", "t2!"));
Assert.Equal("t1!", t2.P2);
Assert.Null(method.InvokerAs <Func <SomeClass2, string, string, object> >()(t3, "t1", "t2"));
Assert.Equal("t1_", t3.P2);
Assert.Equal("t2_", t3.P3);
Assert.Null(method.InvokerAs <Func <SomeClass2, string, string, object> >()(t3, "t1!", "t2!"));
Assert.Equal("t1!_", t3.P2);
Assert.Equal("t2!_", t3.P3);
var method2 = typeof(SomeClass3).Method("SetP2P3", typeof(string), typeof(string));
Assert.Null(method2.InvokerAs <Func <SomeClass2, string, string, object> >()(t3, "t11", "t22"));
Assert.Equal("t11_", t3.P2);
Assert.Equal("t22_", t3.P3);
Assert.Null(method2.InvokerAs <Func <SomeClass2, string, string, object> >()(t3, "t11!", "t22!"));
Assert.Equal("t11!_", t3.P2);
Assert.Equal("t22!_", t3.P3);
}
public void InvokesNewMethodAs()
{
var t3 = new SomeClass3();
var method = typeof(SomeClass3).Method("GetF1");
Assert.Equal(12, method.InvokerAs <Func <SomeClass3, object> >()(t3));
Assert.Equal(12, method.InvokerAs <Func <SomeClass3, int> >()(t3));
}
public void GetterWorksForPublic()
{
var c = new SomeClass3 {
CanSet = 2, P2 = "test"
};
Assert.Equal("test", typeof(SomeClass3).Property("P2").GetterAs <Func <object, string> >()(c));
Assert.Equal(2, typeof(SomeClass3).Property("CanGet").GetterAs <Func <object, object> >()(c));
}
public void InvokesIntMethodInvoker()
{
var t2 = new SomeClass2();
var t3 = new SomeClass3();
var method = typeof(SomeClass2).Method("GetF1");
var invoker = method.Invoker();
Assert.Equal(11, invoker(t2));
Assert.Equal(11, invoker(t3));
}
public void SetterThrowsIfWrongType()
{
var c = new SomeClass3 {
CanSet = 2, P2 = "test"
};
Assert.Throws <NullReferenceException>(
() => typeof(SomeClass3).Property("CanSet").SetterAs <Action <SomeClass3, object> >()(c, null));
Assert.Throws <InvalidCastException>(
() => typeof(SomeClass3).Property("P2").SetterAs <Action <SomeClass3, object> >()(c, 2.5));
}
public void GetterWorksForIndexed()
{
var c = new SomeClass3 {
CanSet = 2, P2 = "test"
};
var prop = typeof(SomeClass3).Property("Item");
var getter = prop.GetterAs <Func <object, int, object> >();
Assert.NotNull(getter);
Assert.Equal(15, getter(c, 14));
}
public void SetterWorksForPublic()
{
var c = new SomeClass3 {
CanSet = 2, P2 = "test"
};
typeof(SomeClass3).Property("P2").SetterAs <Action <object, string> >()(c, "test1");
typeof(SomeClass3).Property("CanSet").SetterAs <Action <object, int> >()(c, 5);
Assert.Equal("test1", c.P2);
Assert.Equal(5, c.CanGet);
}
public void SetterWorksForIndexed()
{
var c = new SomeClass3 {
CanSet = 2, P2 = "test"
};
var prop = typeof(SomeClass3).Property("Item");
var setter = prop.SetterAs <Action <object, int, int> >();
Assert.NotNull(setter);
setter(c, 4, 3);
Assert.Equal(12, c.CanGet);
}
public void InvokesIntMethodAs()
{
var t2 = new SomeClass2();
var t3 = new SomeClass3();
var method = typeof(SomeClass2).Method("GetF1");
var invoker1 = method.InvokerAs <Func <SomeClass2, int> >();
var invoker2 = method.InvokerAs <Func <object, object> >();
Assert.Equal(11, invoker1(t2));
Assert.Equal(11, invoker2(t2));
Assert.Equal(11, invoker1(t3));
Assert.Equal(11, invoker2(t3));
}
public SomeClass2(SomeClass3 c3) { }
public void GetterWorksForPrivate()
{
var c = new SomeClass3();
Assert.Equal(0, typeof(SomeClass3).Property("Priv").GetterAs <Func <object, object> >()(c));
}
