public PublicClass()
{
//inaccessible due to protection level.
this.privateClass = new PrivateClass();
//works!
this.privateClass = PrivateClass.GetInstance();
}
public void HostObjectBinding_PrivateClassImplementingPublicInterface()
{
var c = new PrivateClass();
var result = CSharpScript.EvaluateAsync <int>("Z()", globals: c, globalsType: typeof(I));
Assert.Equal(3, result.Result);
}
public void HostObjectBinding_PrivateClass()
{
var c = new PrivateClass();
ScriptingTestHelpers.AssertCompilationError(() => CSharpScript.EvaluateAsync("Z()", OptionsWithFacades, c),
// (1,1): error CS0122: '<Fully Qualified Name of PrivateClass>.Z()' is inaccessible due to its protection level
Diagnostic(ErrorCode.ERR_BadAccess, "Z").WithArguments(typeof(PrivateClass).FullName.Replace("+", ".") + ".Z()"));
}
public PublicClass()
{
// can't be called, privateClass's ctor/method is private
// privateClass = newPrivateClass();
// can be called, this static method is public
privateClass = PrivateClass.GetInstance();
// can't be called, it's private
// privateClass.DoWork();
}
static void Main(string[] args)
{
var publicClass = new PublicClass();
var internalClass = new InternalClass();
var privateClass = new PrivateClass();
publicClass.PrintAge();
Console.ReadLine();
}
static void Main(string[] args)
{
var faker = new Faker();
Foo foo = faker.Create <Foo>();
PrivateClass clas = faker.Create <PrivateClass>();
Console.WriteLine(foo.Age);
Console.WriteLine(foo.Name);
Console.WriteLine(foo.IsTrue);
Console.WriteLine(foo.Bar.Str);
Console.WriteLine(foo.Bar.NewDouble);
string intArrToString = "Bar IntList = ";
foreach (int i in foo.Bar.IntList)
{
intArrToString += i + "; ";
}
Console.WriteLine(intArrToString);
Console.WriteLine(foo.Bar.DateTime);
Console.ReadLine();
}
public PublicClass()
{
PublicProp = 1;
PrivateProp = 2;
ProtectedProp = 3;
InternalProp = 4;
ProtectedInternalProp = 5;
PrivateProtectedProp = 6;
var publicClass = new PublicClass();
publicClass.PublicProp = 1;
publicClass.PrivateProp = 2;
publicClass.ProtectedProp = 3;
publicClass.InternalProp = 4;
publicClass.ProtectedInternalProp = 5;
publicClass.PrivateProtectedProp = 6;
var privateClass = new PrivateClass();
privateClass.PublicProp = 1;
//privateClass.PrivateProp = 2;
//privateClass.ProtectedProp = 3;
privateClass.InternalProp = 4;
privateClass.ProtectedInternalProp = 5;
//privateClass.PrivateProtectedProp = 6;
var protectedClass = new ProtectedClass();
protectedClass.PublicProp = 1;
//protectedClass.PrivateProp = 2;
//protectedClass.ProtectedProp = 3;
protectedClass.InternalProp = 4;
protectedClass.ProtectedInternalProp = 5;
//protectedClass.PrivateProtectedProp = 6;
var internalClass = new InternalClass();
internalClass.PublicProp = 1;
//internalClass.PrivateProp = 2;
//internalClass.ProtectedProp = 3;
internalClass.InternalProp = 4;
internalClass.ProtectedInternalProp = 5;
//internalClass.PrivateProtectedProp = 6;
var protectedInternalClass = new ProtectedInternalClass();
protectedInternalClass.PublicProp = 1;
//protectedInternalClass.PrivateProp = 2;
//protectedInternalClass.ProtectedProp = 3;
protectedInternalClass.InternalProp = 4;
protectedInternalClass.ProtectedInternalProp = 5;
//protectedInternalClass.PrivateProtectedProp = 6;
var PrivateProtectedClass = new PrivateProtectedClass();
PrivateProtectedClass.PublicProp = 1;
//PrivateProtectedClass.PrivateProp = 2;
//PrivateProtectedClass.ProtectedProp = 3;
PrivateProtectedClass.InternalProp = 4;
PrivateProtectedClass.ProtectedInternalProp = 5;
//PrivateProtectedClass.PrivateProtectedProp = 6;
}
public void PubMethod()
{
InternalClass i = new InternalClass();
PrivateClass p = new PrivateClass();
PubChild c = new PubChild();
}
public void CreateNonPublicInstance()
{
var so = new PrivateStruct()
{
Field = 2,
ClassData = new PrivateClass()
{
Field = 3
}
};
var ss = JSON.ToJSON(so, _JP);
var ps = JSON.ToObject <PrivateStruct> (ss);
Console.WriteLine(ss);
Assert.AreEqual(so.Field, ps.Field);
Assert.AreEqual(2, ps.Field);
Assert.AreEqual(3, ps.ClassData.Field);
var o = new PrivateClass();
o.StructData = new PrivateStruct()
{
Field = 4
};
var s = JSON.ToJSON(o, _JP);
Console.WriteLine(s);
Assert.IsTrue(s.Contains(@"""PrivateField"":1"));
s = s.Replace(@"""PrivateField"":1", @"""PrivateField"":2");
var p = JSON.ToObject <PrivateClass> (s);
Assert.AreEqual(o.Field, p.Field);
Assert.AreEqual(4, p.StructData.Field);
Assert.AreEqual(2, p.GetPrivateField());
var l = new List <PrivateClass> ()
{
new PrivateClass()
{
Field = 1
}
};
var sl = JSON.ToJSON(l, _JP);
Console.WriteLine(sl);
var pl = JSON.ToObject <List <PrivateClass> > (sl);
Assert.AreEqual(l[0].Field, pl[0].Field);
var a = new PrivateClass[] { new PrivateClass()
{
Field = 1
} };
var sa = JSON.ToJSON(a, _JP);
var pa = JSON.ToObject <PrivateClass[]> (sa);
Console.WriteLine(sa);
Assert.AreEqual(a[0].Field, pa[0].Field);
var d = new Dictionary <string, List <PrivateClass> > ()
{
{ "test", l }
};
var sd = JSON.ToJSON(d, _JP);
Console.WriteLine(sd);
var pd = JSON.ToObject <Dictionary <string, List <PrivateClass> > > (sd);
Assert.AreEqual(l[0].Field, d["test"][0].Field);
}
public static void Main(string[] args)
{
MyClass c = new MyClass ();
c.name_internal = "x";
c.name_public = "xx";
MySubClass sc = new MySubClass ();
sc.ttt (); // access proteced modifier
PrivateClass pc = new PrivateClass ();
pc.GetHashCode ();
MyStruct st = new MyStruct ();
st.test2 ();
}
public void CreateNonPublicInstance()
{
var so = new PrivateStruct()
{
Field = 2,
ClassData = new PrivateClass()
{
Field = 3
},
StructData = new NonSerializableStruct {
Field = 4
}
};
var ss = Json.ToJson(so);
var ps = Json.ToObject <PrivateStruct> (ss);
Console.WriteLine(ss);
Assert.AreEqual(so.Field, ps.Field);
Assert.AreEqual(2, ps.Field);
Assert.AreEqual(3, ps.ClassData.Field);
Assert.AreEqual(0, ps.StructData.Field); // invisible member will not be serialized
var o = new PrivateClass();
o.StructData = new PrivateStruct()
{
Field = 4
};
var s = Json.ToJson(o);
Console.WriteLine(s);
Assert.IsTrue(s.Contains(@"""PrivateField"":1"));
s = s.Replace(@"""PrivateField"":1", @"""PrivateField"":2");
var p = Json.ToObject <PrivateClass> (s);
Assert.AreEqual(o.Field, p.Field);
Assert.AreEqual(4, p.StructData.Field);
Assert.AreEqual(2, p.GetPrivateField());
var l = new List <PrivateClass> ()
{
new PrivateClass()
{
Field = 1
}
};
var sl = Json.ToJson(l);
Console.WriteLine(sl);
var pl = Json.ToObject <List <PrivateClass> > (sl);
Assert.AreEqual(l[0].Field, pl[0].Field);
var a = new PrivateClass[] { new PrivateClass()
{
Field = 1
} };
var sa = Json.ToJson(a);
var pa = Json.ToObject <PrivateClass[]> (sa);
Console.WriteLine(sa);
Assert.AreEqual(a[0].Field, pa[0].Field);
var d = new Dictionary <string, List <PrivateClass> > ()
{
{ "test", l }
};
var sd = Json.ToJson(d);
Console.WriteLine(sd);
var pd = Json.ToObject <Dictionary <string, List <PrivateClass> > > (sd);
Assert.AreEqual(l[0].Field, d["test"][0].Field);
s = @"{""readonlyproperty"": 3}";
o = Json.ToObject <PrivateClass> (s);
Assert.AreEqual(3, o.ReadOnlyProperty);
}
public void Start()
{
faker = new Faker.Faker();
foo = faker.Create <Foo>();
exampleClass = faker.Create <PrivateClass>();
}
