public void TestClass2()
        {
            NClass builder = NClass.RandomDomain();

            var mb = builder.GetMethodBuilder();

            mb.Public().Name("Apple").Type <int>().Body("return 0;");
            var pb = builder.GetPropertyBuilder();

            pb.Public()
            .Name("Banana")
            .Type <NClass>()
            .Setter("int a = value.ToString().Length;")
            .Getter("return default;");


            var script = builder
                         .CustomUsing()
                         .HiddenNamespace()
                         .Access(Natasha.Reverser.Model.AccessFlags.Public)
                         .Name("EnumUT1")
                         .Script;

            Assert.Equal($"using System;{Environment.NewLine}using Natasha.CSharp;{Environment.NewLine}public class EnumUT1{{{Environment.NewLine}public System.Int32 Apple(){{return 0;}}{Environment.NewLine}public Natasha.CSharp.NClass Banana{{{Environment.NewLine}get{{return default;}}{Environment.NewLine}set{{int a = value.ToString().Length;}}{Environment.NewLine}}}{Environment.NewLine}}}", script);
            Assert.Equal($"using System;{Environment.NewLine}using Natasha.CSharp;{Environment.NewLine}public class EnumUT1{{{Environment.NewLine}public System.Int32 Apple(){{return 0;}}{Environment.NewLine}public Natasha.CSharp.NClass Banana{{{Environment.NewLine}get{{return default;}}{Environment.NewLine}set{{int a = value.ToString().Length;}}{Environment.NewLine}}}{Environment.NewLine}}}", script);

            Assert.NotNull(builder.GetType());
        }
Exemple #2
0
        public static void TestMemoery2()
        {
            Console.WriteLine("Memory2");
            var domain1 = DomainManagment.Create("TempDomain2");

            for (int i = 0; i < 10; i += 1)
            {
                Thread.Sleep(5000);
                Console.WriteLine("new");
                NClass nStruct = new NClass();
                nStruct
                .Namespace("Core30")
                .OopName($"Test{i}")

                .Ctor(builder => builder
                      .MemberAccess(AccessTypes.Public)
                      .Param <string>("name")
                      .Body("Name=name;"))
                .PublicField <string>("Name")
                .PublicField <string>("Name1")
                .PublicField <string>("Name2")
                .PublicField <string>("Name3")
                .PublicField <string>("Name4");
                var type = nStruct.GetType();
            }
            DomainManagment.Get("TempDomain2").Dispose();
            DomainManagment.Get("TempDomain2").Unload();
        }
Exemple #3
0
        public static void TestMemoery()
        {
            Console.WriteLine("Memory1");
            List <Type> list    = new List <Type>();
            var         domain1 = DomainManagment.Create("TempDomain1");

            for (int i = 0; i < 500; i += 1)
            {
                Console.WriteLine("new");
                NClass nStruct = new NClass();
                nStruct
                .Namespace("Core301")
                .OopName($"Test{i}")

                .Ctor(builder => builder
                      .MemberAccess(AccessTypes.Public)
                      .Param <string>("name")
                      .Body("Name=name;"))
                .PublicField <string>("Name")
                .PublicField <string>("Name1")
                .PublicField <string>("Name2")
                .PublicField <string>("Name3")
                .PublicField <string>("Name4");
                list.Add(nStruct.GetType());
            }
            DomainManagment.Get("TempDomain1").Dispose();
        }
        public void TestClass()
        {
            NClass builder = NClass.RandomDomain();
            var    script  = builder
                             .CustomUsing()
                             .HiddenNamespace()
                             .Access(Natasha.Reverser.Model.AccessFlags.Public)
                             .Name("EnumUT1")
                             .Field(item => { item.Public().Name("Apple").Type <int>(); })
                             .Field(item => { item.Public().Name("Orange").Type <string>(); })
                             .Property(item => { item.Public().Name("Banana").Type <NClass>(); })
                             .Script;

            Assert.Equal($"using System;{Environment.NewLine}using Natasha.CSharp;{Environment.NewLine}public class EnumUT1{{{Environment.NewLine}public System.Int32 Apple;{Environment.NewLine}public System.String Orange;{Environment.NewLine}public Natasha.CSharp.NClass Banana{{{Environment.NewLine}get;{Environment.NewLine}set;{Environment.NewLine}}}{Environment.NewLine}}}", script);
            Assert.NotNull(builder.GetType());
        }
Exemple #5
0
        public void Test1()
        {
            NClass builder = new NClass();

            builder
            .Public()
            .Static()
            .Using <OopBuildTest>()
            .Namespace("TestNamespace")
            .DefinedName("TestExceptionUt1")
            .Body(@"public static void 1 Test(){}")
            .PublicStaticField <string>("Name")
            .PrivateStaticField <int>("_age")
            .Builder();
            var type = builder.GetType();

            Assert.Null(type);
            Assert.Equal(CompileError.Syntax, builder.Compiler.CompileException.ErrorFlag);
        }
Exemple #6
0
        public void Test1()
        {
            NClass classBuilder = new NClass();

            classBuilder.AssemblyBuilder.Syntax.ErrorBehavior = ExceptionBehavior.None;
            classBuilder
            .Public()
            .Static()
            .Using <ClassExceptionTest>()
            .Namespace("TestNamespace")
            .DefinedName("TestExceptionUt1")
            .Body(@"public static void 1 Test(){}")
            .PublicStaticField <string>("Name")
            .PrivateStaticField <int>("_age")
            .BuilderScript();
            var type = classBuilder.GetType();

            Assert.Null(type);
            Assert.Equal(ExceptionKind.Syntax, classBuilder.Exception.ErrorFlag);
        }
        public void TestClass1()
        {
            NClass builder = NClass.Random();
            var    script  = builder
                             .CurstomeUsing()
                             .HiddenNamespace()
                             .Access(Natasha.Reverser.Model.AccessTypes.Public)
                             .DefinedName("EnumUT1")
                             .Method(item => { item.Public().DefinedName("Apple").DefinedType <int>().Body("return 0;"); })
                             .Property(item => { item
                                                 .Public()
                                                 .DefinedName("Banana")
                                                 .DefinedType <NClass>()
                                                 .Setter("int a = value.ToString().Length;")
                                                 .Getter("return default;"); })
                             .Script;

            Assert.Equal($"using System;{Environment.NewLine}using Natasha.CSharp;{Environment.NewLine}public class EnumUT1{{{Environment.NewLine}public System.Int32 Apple(){{return 0;}}{Environment.NewLine}public Natasha.CSharp.NClass Banana{{{Environment.NewLine}get{{return default;}}{Environment.NewLine}set{{int a = value.ToString().Length;}}{Environment.NewLine}}}{Environment.NewLine}}}", script);
            Assert.NotNull(builder.GetType());
        }
Exemple #8
0
        static void Main(string[] args)
        {
            DomainManagement.RegisterDefault <AssemblyDomain>();
            //var @operator = FastMethodOperator.DefaultDomain();
            //var actionDelegate = @operator
            //    .Param(typeof(string), "parameter")
            //    .Body("Console.WriteLine(parameter);")
            //    .Compile();

            //actionDelegate.DynamicInvoke("HelloWorld!");
            //var action = (Action<string>)actionDelegate;
            //action("HelloWorld!");
            //actionDelegate.DisposeDomain();

            //起个类
            NClass nClass = NClass.DefaultDomain();

            nClass
            .Namespace("MyNamespace")
            .Public()
            .Name("MyClass")
            .Ctor(ctor => ctor.Public().Body("MyField=\"Hello\";"))
            .Property(prop => prop
                      .Type(typeof(string))
                      .Name("MyProperty")
                      .Public()
                      .OnlyGetter("return \"World!\";")
                      );


            //添加方法
            MethodBuilder mb = new MethodBuilder();

            mb
            .Public()
            .Override()
            .Name("ToString")
            .Body("return MyField+\" \"+MyProperty;")
            .Return(typeof(string));
            nClass.Method(mb);


            //添加字段
            FieldBuilder fb = nClass.GetFieldBuilder();

            fb.Public()
            .Name("MyField")
            .Type <string>();


            //动态调用动态创建的类
            var action = NDelegate
                         .RandomDomain()
                         .Action("Console.WriteLine((new MyClass()).ToString());", nClass.GetType());

            action();
            action.DisposeDomain();
            //Console.WriteLine(typeof(List<int>[]).GetRuntimeName());
            //Console.WriteLine(typeof(List<int>[,]).GetRuntimeName());
            //Console.WriteLine(typeof(int[,]).GetRuntimeName());
            //Console.WriteLine(typeof(int[][]).GetRuntimeName());
            //Console.WriteLine(typeof(int[][,,,]).GetRuntimeName());
            Console.ReadKey();
        }