C# (CSharp) CilDocumentSyntax.Class_示例

示例#1

 protected override CilDocumentSyntax DoGenerate(CilDocumentSyntax docCode)
 {
     return(docCode
            .Class_().Public.Named(typeName)
            .Method()
            .Public.Static
            .Returning(docCode.Types.Import(resultType))
            .Named(methodName)
            .BeginArgs()
            .Do(DefineArgs)
            .EndArgs()
            .BeginBody()
            .Do(il => codeBuilder(il, inputArgs))
            .EndBody()
            .EndClass()
            );
 }

示例#2

文件： CachedMethodAssemblyProvider.cs 项目： bkushnir/IronTextLibrary

 protected override CilDocumentSyntax DoGenerate(CilDocumentSyntax docCode)
 {
     return docCode
         .Class_().Public.Named(typeName)
            .Method()
                .Public.Static
                .Returning(docCode.Types.Import(resultType))
                .Named(methodName)
                .BeginArgs()
                    .Do(DefineArgs)
                .EndArgs()
            .BeginBody()
                .Do(il => codeBuilder(il, inputArgs))
            .EndBody()
         .EndClass()
         ;
 }

示例#3

文件： ImplementationGenerator.cs 项目： bkushnir/IronTextLibrary

        private CilDocumentSyntax GenerateImpl(PlannedClass entry, CilDocumentSyntax cil)
        {
            ClassExtendsSyntax wantBaseClass =
                    cil.Class_()
                        .Public
                        .Named(entry.ClassName)
                        ;

            var baseClassRef = cil.Types.Import(entry.BaseClass);

            ClassImplementsSyntax wantContract =
                    wantBaseClass
                        .Extends(baseClassRef);

            var baseCtor = entry.BaseClass.GetConstructor(Type.EmptyTypes);
            Ref<Methods> baseCtorRef;

            if (baseCtor != null)
            {
                baseCtorRef = cil.Methods.Import(baseCtor);
            }
            else
            {
                baseCtorRef = null;
            }

            foreach (Type c in entry.Contracts)
            {
                wantContract = wantContract.Implements(cil.Types.Import(c));
            }

            ClassSyntax classCode = wantContract;

            classCode = classCode
                .Method()
                        .Public.Instance
                        .Returning(classCode.Types.Void)
                        .Named(".ctor")
                            .BeginArgs().EndArgs()
                            .BeginBody()
                                .Do(il =>
                                    {
                                        if (baseCtorRef != null)
                                        {
                                            il = il
                                                .Ldarg(0)
                                                .Callvirt(baseCtorRef);
                                        }

                                        return il;
                                    })
                                .Ret()
                            .EndBody()
                            ;

            foreach (var method in entry.Methods)
            {
                WantArgsBase wantArgs =
                    classCode.Method()
                        .Private.Hidebysig.Newslot
                        .Virtual.Final.Instance
                        .Returning(classCode.Types.Import(method.ReturnType))
                        .Named(method.DeclaringType + "." + method.Name)
                        .BeginArgs();

                foreach (var parameter in method.GetParameters())
                {
                    wantArgs = wantArgs.Argument(
                                classCode.Types.Import(parameter.ParameterType),
                                wantArgs.Args.Generate(parameter.Name));
                }

                var emit = wantArgs.EndArgs().BeginBody();

                emit = emit.Override(emit.Methods.Import(method));

                emit = EmitFactoryCode(
                            emit,
                            entry,
                            method.ReturnType,
                            !forceNonNullResult(method));

                classCode = emit.Ret().EndBody();
            }

            return classCode.EndClass();
        }

示例#4

        private CilDocumentSyntax GenerateImpl(PlannedClass entry, CilDocumentSyntax cil)
        {
            ClassExtendsSyntax wantBaseClass =
                cil.Class_()
                .Public
                .Named(entry.ClassName)
            ;

            var baseClassRef = cil.Types.Import(entry.BaseClass);

            ClassImplementsSyntax wantContract =
                wantBaseClass
                .Extends(baseClassRef);

            var           baseCtor = entry.BaseClass.GetConstructor(Type.EmptyTypes);
            Ref <Methods> baseCtorRef;

            if (baseCtor != null)
            {
                baseCtorRef = cil.Methods.Import(baseCtor);
            }
            else
            {
                baseCtorRef = null;
            }

            foreach (Type c in entry.Contracts)
            {
                wantContract = wantContract.Implements(cil.Types.Import(c));
            }

            ClassSyntax classCode = wantContract;

            classCode = classCode
                        .Method()
                        .Public.Instance
                        .Returning(classCode.Types.Void)
                        .Named(".ctor")
                        .BeginArgs().EndArgs()
                        .BeginBody()
                        .Do(il =>
            {
                if (baseCtorRef != null)
                {
                    il = il
                         .Ldarg(0)
                         .Callvirt(baseCtorRef);
                }

                return(il);
            })
                        .Ret()
                        .EndBody()
            ;

            foreach (var method in entry.Methods)
            {
                WantArgsBase wantArgs =
                    classCode.Method()
                    .Private.Hidebysig.Newslot
                    .Virtual.Final.Instance
                    .Returning(classCode.Types.Import(method.ReturnType))
                    .Named(method.DeclaringType + "." + method.Name)
                    .BeginArgs();

                foreach (var parameter in method.GetParameters())
                {
                    wantArgs = wantArgs.Argument(
                        classCode.Types.Import(parameter.ParameterType),
                        wantArgs.Args.Generate(parameter.Name));
                }

                var emit = wantArgs.EndArgs().BeginBody();

                emit = emit.Override(emit.Methods.Import(method));

                emit = EmitFactoryCode(
                    emit,
                    entry,
                    method.ReturnType,
                    !forceNonNullResult(method));

                classCode = emit.Ret().EndBody();
            }

            return(classCode.EndClass());
        }