C# CodeStatementCollection.Cast方法代码示例

 public virtual void TryCatchSend(CodeStatementCollection statements, CodeVariableReferenceExpression varrefSendHandle, CodeStatementCollection statementsTrySend)
 {
     CodeTryCatchFinallyStatement trycatchSend = new CodeTryCatchFinallyStatement(
         statementsTrySend.Cast<CodeStatement>().ToArray(),
         new CodeCatchClause[] { },
         new CodeStatement[] // Finally
         {
             // Dispose in finally block.
             new CodeConditionStatement(new CodeBinaryOperatorExpression(varrefSendHandle, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)),
                 new CodeExpressionStatement(new CodeMethodInvokeExpression(varrefSendHandle, "Dispose"))
             )
         }
     );
     statements.Add(trycatchSend);
 }

        public virtual CodeTryCatchFinallyStatement ReceiveMessage(string methodName, CodeStatementCollection statementsTryRecv)
        {
            CodeTryCatchFinallyStatement trycatchReceive = new CodeTryCatchFinallyStatement(
                new CodeStatement[]
                {
                    // ReceiveMessage
                    this.ReceiveMessage(),
                    // * if (((this.result == 0) && (msgHandleResp != null))) // If received message ok
                    new CodeConditionStatement(
                        new CodeBinaryOperatorExpression(
                            exprResultOk,
                            CodeBinaryOperatorType.BooleanAnd,
                            this.IfResponseHandleNotNull()
                        )
                        ,new CodeStatement[] // True statements
                        {
                            // * if ((msgResp.Data.typefield.type == Udbus.Core.dbus_msg_type.DBUS_TYPE_ERROR))
                            new CodeConditionStatement(
                                this.IfResponseIsDbusError()
                                ,new CodeStatement[]
                                {
                                    // * throw Udbus.Core.Exceptions.UdbusMessageMethodErrorException.Create("<method_name>", this.ConnectionParameters, msgStructResp);
                                    this.ThrowMethodErrorException(methodName)
                                }
                                ,statementsTryRecv.Cast<CodeStatement>().ToArray() // False statements
                            )
                        }
                        ,new CodeStatement[] // False statements
                        {
                            // * throw Udbus.Core.Exceptions.UdbusMethodReceiveException.Create("<method_name>", this.result, this.ConnectionParameters);
                            this.ThrowMethodReceiveException(methodName)
                        }
                    )

                },
                new CodeCatchClause[] { },
                new CodeStatement[] // Finally
                {
                    new CodeConditionStatement(
                        compResponseOk, new CodeExpressionStatement(new CodeMethodInvokeExpression(varrefResponseMessagePair, "Dispose"))
                    )
                }
            );
            return trycatchReceive;
        }

 /// <summary>
 /// Visits a <see cref="CodeStatementCollection"/>.
 /// </summary>
 /// <param name="codeStatementCollection">The <see cref="CodeStatementCollection"/> to visit.</param>
 protected virtual void VisitCodeStatementCollection(CodeStatementCollection codeStatementCollection)
 {
     // Visit all of the CodeStatement items in the collection.
     foreach (CodeStatement item in codeStatementCollection.Cast<CodeStatement>())
     {
         this.VisitCodeStatement(item);
     }
 }

        public virtual void AssignResults(CodeStatementCollection statementsTryRecv
            , CodeConditionStatement condOut, CodeConditionStatement condOutIter
            , CodeStatementCollection stmtsFinishResult, CodeThrowExceptionStatement throwargOutPrev
            
            , string idlMethodName, ref int nOutArgCounter
            )
        {
            if (condOut != null) // If there are out parameters
            {
                if (stmtsFinishResult.Count > 0) // If there's any out result parameters
                {
                    // Assign if successful.
                    condOutIter.TrueStatements.Add(new CodeConditionStatement(
                        // * if (this.result == 0)
                        exprResultOk,
                        stmtsFinishResult.Cast<CodeStatement>().ToArray() // True statements
                        , new CodeStatement[] // False statements
                        {
                            throwargOutPrev
                        }
                    ));

                } // Ends if there's any out result parameters

                // Add the root condition variable.
                statementsTryRecv.Add(condOut);

            } // Ends if there are out parameters
        }

        static public void MakeSignalParameters(CodeTypeDeclaration typedeclArgs,
            CodeTypeFactory codetypefactoryOut,
            Udbus.Parsing.CodeMemberDeferredClassHolder declarationHolder,
            IDLInterface idlIntf,
            string methodName,
            string idlSignalName,
            IList<IDLSignalArgument> arguments,
            CodeParameterDeclarationExpressionCollection parameters,
            CodeStatementCollection statements,
            Udbus.Parsing.BuildContext context,
            MarshalBuilderHelper codebuilder)
        {
            CodeStatementCollection statementsTryRecv = new CodeStatementCollection();
            int nOutArgCounter = 0;
            List<CodeMethodInvokeExpression> invokemethodsBuild = new List<CodeMethodInvokeExpression>();
            CodeConditionStatement condOut = null; // Root if statement for out parameters.
            CodeConditionStatement condOutIter = null; // Most nested if statement for out parameters.
            CodeStatementCollection stmtsFinishResult = new CodeStatementCollection();
            CodeTypeReference typerefParamIter = CodeBuilderCommon.typerefUnknownParameters;
            string argNameIter = arguments != null && arguments.Count > 0 ? arguments[0].Name : "UnknownParameters";

            CodeThrowExceptionStatement throwargOutPrev = codebuilder.CreateArgumentOutException(idlSignalName);

            // WAXME
            //CodeConstructor constructorArgs = new CodeConstructor();
            //constructorArgs.Attributes = MemberAttributes.Public;
            foreach (IDLSignalArgument idlSignalArg in arguments)
            {
                argNameIter = idlSignalArg.Name;

                // Parse the type string for the argument, creating required structs as we go, and returning a type for the argument.
                //Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLMethodArgumentTypeNameBuilder(idlIntf, idlMethod, idlMethodArg);
                Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLArgumentTypeNameBuilder(idlIntf, methodName);
                ParamCodeTypeHolderMarshalBase paramtypeHolder = null;
                CodeTypeReference typerefParam = null;
                if (condOut == null)
                {
                    codebuilder.PrefixOutParams(ref condOut, ref condOutIter, idlSignalName, ref nOutArgCounter, ref throwargOutPrev);
                }

                // Handle the signal argument in the message.
                CodeConditionStatement condVarResult;
                codebuilder.MakeOutArgument(statements
                    , stmtsFinishResult
                    , idlSignalName
                    , codetypefactoryOut // Yeah I messed up the naming
                    , ref nOutArgCounter
                    , context
                    , ref throwargOutPrev
                    , idlSignalArg
                    , nameBuilder
                    , ref paramtypeHolder
                    , ref typerefParam
                    , out condVarResult
                );

                codebuilder.StoreCondIterator(ref condOut, ref condOutIter, condVarResult);

                // WAXME
                // Add a field to the <signal>Args class.
                //string argFieldName = CodeBuilderCommon.GetSignalArgFieldName(idlSignalArg.Name);
                //CodeFieldReferenceExpression fielrefdRefArgField = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), argFieldName);
                //typedeclArgs.Members.Add(new CodeMemberField(paramtypeHolder.paramtype.CodeType, argFieldName));
                //CodeMemberProperty propArgField = new CodeMemberProperty();
                //propArgField.Attributes = MemberAttributes.Public | MemberAttributes.Final;
                //propArgField.Type = paramtypeHolder.paramtype.CodeType;
                //propArgField.Name = PropertyNameFromFieldName(argFieldName);
                //propArgField.GetStatements.Add(new CodeMethodReturnStatement(fielrefdRefArgField));
                //typedeclArgs.Members.Add(propArgField);
                //constructorArgs.Parameters.Add(new CodeParameterDeclarationExpression(paramtypeHolder.paramtype.CodeType, argFieldName));
                //// * this.<signal_arg> = <signal_arg>;
                //constructorArgs.Statements.Add(new CodeAssignStatement(fielrefdRefArgField, new CodeArgumentReferenceExpression(argFieldName)));

            } // Ends loop over arguments

            //typedeclArgs.Members.Add(constructorArgs);

            codebuilder.AssignResults(statementsTryRecv, condOut, condOutIter, stmtsFinishResult, throwargOutPrev
                , idlSignalName, ref nOutArgCounter
            );
            List<CodeStatement> statementsReponse = new List<CodeStatement>();

            // Now receive the response.
            // Create message reader.
            // * Udbus.Core.UdbusMessageReader reader = new Udbus.Core.UdbusMessageReader(msgHandleResp);
            statementsTryRecv.Insert(0, codebuilder.CreateMessageReader());
            statementsReponse.AddRange(statementsTryRecv.Cast<CodeStatement>());
            statements.Add(new CodeConditionStatement(exprResultOk, statementsReponse.ToArray()));
        }