public void Constructor1_Deny_Unrestricted () { CodeExpression to_throw = new CodeExpression (); CodeThrowExceptionStatement ctes = new CodeThrowExceptionStatement (to_throw); Assert.AreSame (to_throw, ctes.ToThrow, "ToThrow"); ctes.ToThrow = new CodeExpression (); }
/// <summary> /// Inspects the specified code unit. /// </summary> /// <param name="unit">The code unit.</param> /// <param name="ns">The code namespace declaration.</param> /// <param name="type">The code type declaration.</param> /// <param name="executeMethod">The code method declaration for the Execute method.</param> public void Inspect(CodeCompileUnit unit, CodeNamespace ns, CodeTypeDeclaration type, CodeMemberMethod executeMethod) { var statement = new CodeThrowExceptionStatement( new CodeObjectCreateExpression( new CodeTypeReference(typeof(System.InvalidOperationException)), new CodeExpression[] {})); executeMethod.Statements.Insert(0, statement); }
// Generate a codedom throw statement public static CodeStatement Emit(Throw th) { var codeThrow = new CodeThrowExceptionStatement(); codeThrow.ToThrow = CodeDomEmitter.EmitCodeExpression(th.ChildExpressions[0]); return codeThrow; }
public TypescriptThrowExceptionStatement( IExpressionFactory expressionFactory, CodeThrowExceptionStatement statement, CodeGeneratorOptions options) { _expressionFactory = expressionFactory; _statement = statement; _options = options; }
public static CodeThrowExceptionStatement Clone(this CodeThrowExceptionStatement statement) { if (statement == null) return null; CodeThrowExceptionStatement s = new CodeThrowExceptionStatement(); s.EndDirectives.AddRange(statement.EndDirectives); s.LinePragma = statement.LinePragma; s.StartDirectives.AddRange(statement.StartDirectives); s.ToThrow = statement.ToThrow.Clone(); s.UserData.AddRange(statement.UserData); return s; }
private CodeThrowExceptionStatement GenerateExceptionStatement(GenerateErrorActivity activity) { var parameters = DefaultActivityBuilder.GenerateParameters(new List<string> { @"""Message : {0}\nMessage code : {1} """ }, activity); CodeMethodInvokeExpression stringFormatCall = new CodeMethodInvokeExpression(); stringFormatCall.Parameters.AddRange(parameters); CodeMethodReferenceExpression formatMethod = new CodeMethodReferenceExpression(); formatMethod.MethodName = "Format"; CodeVariableReferenceExpression stringObject = new CodeVariableReferenceExpression(); stringObject.VariableName = "String"; formatMethod.TargetObject = stringObject; stringFormatCall.Method = formatMethod; CodeThrowExceptionStatement throwException = new CodeThrowExceptionStatement(new CodeObjectCreateExpression(new CodeTypeReference(typeof(System.Exception)), stringFormatCall)); return throwException; }
public void Visit (CodeThrowExceptionStatement o) { g.GenerateThrowExceptionStatement (o); }
private static void PrintThrowExceptionStatement(TextWriter output, CodeThrowExceptionStatement statement) { output.Write("throw "); if (statement.ToThrow != null) { PrintExpression(output, statement.ToThrow); } }
internal static void EmitCodeToAddIntoCustomStdBinding(Type standardBindingType, string generatedElementClassName, string generatedCollectionElementClassName, string srcFile) { CodeMemberMethod applyCfgMethodForStdBinding = new CodeMemberMethod(); applyCfgMethodForStdBinding.Name = MethodNameConstants.ApplyConfigurationMethod; string paramConfigName = "configurationName"; CodeVariableReferenceExpression paramVarRef = new CodeVariableReferenceExpression(paramConfigName); applyCfgMethodForStdBinding.Parameters.Add(new CodeParameterDeclarationExpression( CodeDomHelperObjects.stringTypeRef, paramConfigName)); string bindingsString = "bindings"; CodeVariableReferenceExpression bindingsVarRef = new CodeVariableReferenceExpression(bindingsString); string sectionString = "section"; CodeVariableReferenceExpression sectionVarRef = new CodeVariableReferenceExpression(sectionString); string elementString = "element"; CodeVariableReferenceExpression elementVarRef = new CodeVariableReferenceExpression(elementString); string topLevelSectionNameInConfig = "system.serviceModel/bindings/"; string subSectionNameInConfig = Helpers.TurnFirstCharLower(standardBindingType.Name); CodeVariableDeclarationStatement bindingsInit = new CodeVariableDeclarationStatement( new CodeTypeReference(TypeNameConstants.BindingsSection), bindingsString, new CodeCastExpression(TypeNameConstants.BindingsSection, new CodeMethodInvokeExpression( new CodeTypeReferenceExpression(TypeNameConstants.ConfigurationManager), MethodNameConstants.GetSectionMethod, new CodePrimitiveExpression(topLevelSectionNameInConfig)))); applyCfgMethodForStdBinding.Statements.Add(bindingsInit); CodeVariableDeclarationStatement sectionInit = new CodeVariableDeclarationStatement( new CodeTypeReference(generatedCollectionElementClassName), sectionString, new CodeCastExpression(generatedCollectionElementClassName, new CodeArrayIndexerExpression( bindingsVarRef, new CodePrimitiveExpression(subSectionNameInConfig)))); applyCfgMethodForStdBinding.Statements.Add(sectionInit); CodeVariableDeclarationStatement elementInit = new CodeVariableDeclarationStatement( new CodeTypeReference(generatedElementClassName), elementString, new CodeArrayIndexerExpression( new CodeFieldReferenceExpression( sectionVarRef, PropertyNameConstants.BindingsProperty), paramVarRef)); applyCfgMethodForStdBinding.Statements.Add(elementInit); CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression( elementVarRef, CodeBinaryOperatorType.IdentityEquality, CodeDomHelperObjects.NullRef); CodeThrowExceptionStatement ctes = new CodeThrowExceptionStatement( new CodeObjectCreateExpression( new CodeTypeReference(typeof(ConfigurationErrorsException)), new CodeMethodInvokeExpression( new CodeTypeReferenceExpression(CodeDomHelperObjects.stringTypeRef), MethodNameConstants.FormatMethod, CodeDomHelperObjects.cultureInfoCurrent, new CodePrimitiveExpression("There is no binding named {0} at {1}."), paramVarRef, new CodePropertyReferenceExpression( sectionVarRef, PropertyNameConstants.BindingNameProperty)))); CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression( elementVarRef, MethodNameConstants.ApplyConfigurationMethod, CodeDomHelperObjects.ThisRef); CodeStatement[] trueStatements = { ctes }; CodeStatement[] falseStatements = { new CodeExpressionStatement(cmie) }; CodeConditionStatement ccs = new CodeConditionStatement(cboe, trueStatements, falseStatements); applyCfgMethodForStdBinding.Statements.Add(ccs); string indent = " "; CodeDomProvider provider = new Microsoft.CSharp.CSharpCodeProvider(); using (System.IO.StreamWriter sbSW = new System.IO.StreamWriter(srcFile, false)) { using (IndentedTextWriter sbTW = new IndentedTextWriter(sbSW, indent)) { provider.GenerateCodeFromMember( applyCfgMethodForStdBinding, sbTW, new CodeGeneratorOptions()); } } }
public CodeStatement ParseStatement() { if (IsKeyword("var")) { GetNextToken(); CodeTypeReference type = ParseType(); string name = EatKeyword(); if (TokenType == CDILToken.Assign) { Expect(CDILToken.Assign); CodeExpression expr = ParseExpression(); return new CodeVariableDeclarationStatement(type, name, expr); } else { return new CodeVariableDeclarationStatement(type, name); } } if (IsKeyword("call")) { GetNextToken(); return new CodeExpressionStatement(ParseExpression()); } if (IsKeyword("return")) { CodeMethodReturnStatement retVal; GetNextToken(); retVal = new CodeMethodReturnStatement(); if (TokenType != CDILToken.Semicolon && TokenType != CDILToken.EOF) retVal.Expression = ParseExpression(); return retVal; } if (IsKeyword("throw")) { CodeThrowExceptionStatement retVal; GetNextToken(); retVal = new CodeThrowExceptionStatement(); if (TokenType != CDILToken.Semicolon && TokenType != CDILToken.EOF) retVal.ToThrow = ParseExpression(); return retVal; } if (IsKeyword("if")) { CodeConditionStatement retVal = new CodeConditionStatement(); GetNextToken(); retVal.Condition = ParseExpression(); ExpectKeyword("then"); while (TokenType != CDILToken.EOF && !IsKeyword("else") && !IsKeyword("endif")) { retVal.TrueStatements.Add(ParseStatement()); if (TokenType == CDILToken.Semicolon) GetNextToken(); } if (IsKeyword("else")) { ExpectKeyword("else"); while (TokenType != CDILToken.EOF && !IsKeyword("endif")) { retVal.FalseStatements.Add(ParseStatement()); if (TokenType == CDILToken.Semicolon) GetNextToken(); } } ExpectKeyword("endif"); return retVal; } if (IsKeyword("let")) { CodeAssignStatement retVal = new CodeAssignStatement(); GetNextToken(); retVal.Left = ParseExpression(); Expect(CDILToken.Assign); retVal.Right = ParseExpression(); return retVal; } if (IsKeyword("comment")) { GetNextToken(); string s = TokenValue.ToString(); GetNextToken(); return new CodeCommentStatement(s); } throw BuildException("Invalid token: '" + TokenType + "': " + TokenValue); }
internal static new CodeThrowExceptionStatement ThrowArgOutExceptionImpl(string idlMethodName, int nOutArgCounter, string idlMethodArgName, CodeTypeReference typerefParam, CodeTypeReferenceExpression typerefexprArgumentOut) { CodeThrowExceptionStatement throwargOutPrev = new CodeThrowExceptionStatement( // * throw Udbus.Core.Exceptions.UdbusMessageSignalArgumentException.Create( new CodeMethodInvokeExpression(typerefexprArgumentOut, "Create", new CodePrimitiveExpression(nOutArgCounter), // * <nOutArg>, new CodePrimitiveExpression(idlMethodArgName), // * "<signal_arg>", new CodeTypeOfExpression(typerefParam), // * typeof(<signal_type>), fieldrefResult, // * this.result, new CodePrimitiveExpression(idlMethodName), // * "<signal>", new CodeObjectCreateExpression( new CodeTypeReference(typeof(Udbus.Core.DbusSignalParams)), new CodePropertyReferenceExpression(fieldrefConnectionParameters, "Interface"), new CodePropertyReferenceExpression(fieldrefConnectionParameters, "Path")), // * new Udbus.DbusSignalParams(this.connectionParameters.Path, this.connectionParameters.Interface), proprefResponseData // * messageData.Data); ) ); return throwargOutPrev; }
private void CheckOccurrence(CodeStatementCollection getStatements) { Debug.Assert(!this.IsList); CodeStatement returnStatement = null; if (IsNullable && DefaultValue == null) { if (typeRef.IsValueType) { // Need to return T?, since parseValue handles only T, // checking for null returnStatement = new CodeMethodReturnStatement( new CodePrimitiveExpression(null)); } } else if (VerifyRequired) { Debug.Assert(this.occursInSchema == Occurs.One); string origin = this.propertyOrigin == SchemaOrigin.Element ? "Element" : this.propertyOrigin == SchemaOrigin.Attribute ? "Attribute": // otherwise null; returnStatement = new CodeThrowExceptionStatement(new CodeObjectCreateExpression(Constants.LinqToXsdException, new CodePrimitiveExpression("Missing required " + origin))); } if (returnStatement != null) { getStatements.Add( new CodeConditionStatement( new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression("x"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)), returnStatement)); } }
private static void GenerateConstructors(Type t, CodeTypeDeclaration codeType) { CodeFieldReferenceExpression omObjectFieldReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), OmObject); ConstructorInfo[] constructors = t.GetConstructors(); ConstructorInfo publicParameterless = null; ConstructorInfo publicSystemParams = null; ConstructorInfo publicEnumParams = null; List<ConstructorInfo> publicGeneralParams = new List<ConstructorInfo>(); foreach (ConstructorInfo con in constructors.Where(c => c.IsPublic || c.IsStatic)) { ParameterInfo[] parameters = con.GetParameters(); if (parameters == null || parameters.Length == 0) { publicParameterless = con; } else if (con.IsStatic) { } else { publicGeneralParams.Add(con); } } if (publicParameterless != null) { CodeConstructor constructor = new CodeConstructor(); constructor.Attributes = MemberAttributes.Public; CodeObjectCreateExpression createExpression = new CodeObjectCreateExpression(t); constructor.Statements.Add(new CodeAssignStatement(omObjectFieldReference, createExpression)); codeType.Members.Add(constructor); } foreach (ConstructorInfo c in publicGeneralParams) { AddConstructorWithCopiedParameters(codeType, t, omObjectFieldReference, c); } // Default internal constructor that accepts the OM object to wrap CodeConstructor defaultConstructor = new CodeConstructor(); defaultConstructor.Attributes = MemberAttributes.Assembly; CodeParameterDeclarationExpression omObjectParameter = new CodeParameterDeclarationExpression(t, OmObject); defaultConstructor.Parameters.Add(omObjectParameter); CodeArgumentReferenceExpression omObjectArgumentReference = new CodeArgumentReferenceExpression(OmObject); CodeObjectCreateExpression createException = new CodeObjectCreateExpression(typeof(ArgumentNullException), new CodePrimitiveExpression(OmObject)); CodeThrowExceptionStatement throwException = new CodeThrowExceptionStatement(createException); CodeBinaryOperatorExpression nullCheck = new CodeBinaryOperatorExpression(omObjectArgumentReference, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)); // if the parameter is null, throw an exception defaultConstructor.Statements.Add(new CodeConditionStatement(nullCheck, throwException)); defaultConstructor.Statements.Add(new CodeAssignStatement(omObjectFieldReference, omObjectArgumentReference)); codeType.Members.Add(defaultConstructor); }
protected override void GenerateThrowExceptionStatement(CodeThrowExceptionStatement e) { base.Output.Write("Throw"); if (e.ToThrow != null) { base.Output.Write(" "); base.GenerateExpression(e.ToThrow); } base.Output.WriteLine(""); }
protected override void GenerateThrowExceptionStatement (CodeThrowExceptionStatement statement) { Output.Write ("Throw"); if (statement.ToThrow != null) { Output.Write (' '); GenerateExpression (statement.ToThrow); } Output.WriteLine (); }
protected abstract void GenerateThrowExceptionStatement (CodeThrowExceptionStatement s);
public void CodeThrowExceptionStatementTest () { CodeThrowExceptionStatement ctes = new CodeThrowExceptionStatement (); statement = ctes; Assert.AreEqual (string.Format (CultureInfo.InvariantCulture, "throw;{0}", NewLine), Generate (), "#1"); ctes.ToThrow = new CodeSnippetExpression ("whatever"); Assert.AreEqual (string.Format (CultureInfo.InvariantCulture, "throw whatever;{0}", NewLine), Generate (), "#2"); }
/// <summary> /// Generates code for the specified throw exception statement. /// </summary> /// <remarks><c>throw TOTHROW;</c></remarks> protected override void GenerateThrowExceptionStatement(CodeThrowExceptionStatement e) { Output.Write(Keywords.Throw + WhiteSpace.Space); GenerateExpression(e.ToThrow); Output.WriteLine(Tokens.Semicolon); }
void EmitOnApplyConfigurationMethod(ref CodeTypeDeclaration customSBConfigSectionClass) { CodeMemberMethod onApplyCfgMethod = new CodeMemberMethod(); onApplyCfgMethod.Name = MethodNameConstants.OnApplyConfigurationMethod; ; onApplyCfgMethod.Parameters.Add(bindingMethodParamRef); onApplyCfgMethod.Attributes = CodeDomHelperObjects.ProtectedOverride; CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression( CodeDomHelperObjects.bindingVarRef, CodeBinaryOperatorType.IdentityEquality, CodeDomHelperObjects.NullRef); CodeThrowExceptionStatement ctes = new CodeThrowExceptionStatement( new CodeObjectCreateExpression( new CodeTypeReference(typeof(System.ArgumentNullException)), new CodePrimitiveExpression(Constants.bindingParamName))); CodeConditionStatement ccs = new CodeConditionStatement(cboe, ctes); onApplyCfgMethod.Statements.Add(ccs); CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression( CodeDomHelperObjects.bindingVarRef, MethodNameConstants.GetTypeMethod); cboe = new CodeBinaryOperatorExpression( cmie, CodeBinaryOperatorType.IdentityInequality, customSBTypeOfRef); ctes = new CodeThrowExceptionStatement( new CodeObjectCreateExpression( new CodeTypeReference(typeof(System.ArgumentException)), new CodeMethodInvokeExpression( new CodeTypeReferenceExpression(CodeDomHelperObjects.stringTypeRef), MethodNameConstants.FormatMethod, CodeDomHelperObjects.cultureInfoCurrent, new CodePrimitiveExpression("Invalid type for binding. Expected type: {0}. Type passed in: {1}."), new CodeMethodReferenceExpression( customSBTypeOfRef, PropertyNameConstants.AssemblyQualifiedNameProperty), new CodeMethodReferenceExpression( cmie, PropertyNameConstants.AssemblyQualifiedNameProperty)))); ccs = new CodeConditionStatement(cboe, ctes); onApplyCfgMethod.Statements.Add(ccs); string varInstanceName = Helpers.TurnFirstCharLower(standardBindingType.Name); CodeVariableDeclarationStatement cvds = new CodeVariableDeclarationStatement( customSBTypeRef, varInstanceName, new CodeCastExpression( standardBindingType.Name, CodeDomHelperObjects.bindingVarRef)); onApplyCfgMethod.Statements.Add(cvds); foreach (PropertyNameType nameType in propertiesGenerated) { CodeAssignStatement assignment = new CodeAssignStatement( new CodeFieldReferenceExpression( new CodeVariableReferenceExpression(varInstanceName), nameType.propertyName), new CodeFieldReferenceExpression( CodeDomHelperObjects.ThisRef, nameType.propertyName)); onApplyCfgMethod.Statements.Add(assignment); } customSBConfigSectionClass.Members.Add(onApplyCfgMethod); }
public void Generate(CodeThrowExceptionStatement statement) { Write("raise "); Generate(statement.ToThrow); WriteLine(); }
private CodeTypeDeclaration CreateSoapExtensionEx() { CodeTypeReference ctrSoapMessage = new CodeTypeReference(typeof(System.Web.Services.Protocols.SoapMessage)); CodeTypeReference ctrStream = new CodeTypeReference(typeof(System.IO.Stream)); CodeTypeReference ctrMemoryStream = new CodeTypeReference(typeof(System.IO.MemoryStream)); CodeTypeReference ctrByteArray = new CodeTypeReference(typeof(System.Byte[])); CodeTypeReference ctrEncoder = new CodeTypeReference(typeof(System.Text.UTF8Encoding)); CodeVariableReferenceExpression cvreMessage = new CodeVariableReferenceExpression(); cvreMessage.VariableName = "Message"; CodeVariableReferenceExpression cvreStrFrom = new CodeVariableReferenceExpression(); cvreStrFrom.VariableName = "StrFrom"; CodeVariableReferenceExpression cvreStrTo = new CodeVariableReferenceExpression(); cvreStrTo.VariableName = "StrTo"; CodeVariableReferenceExpression cvreByteBuf = new CodeVariableReferenceExpression(); cvreByteBuf.VariableName = "ByteBuf"; CodeVariableReferenceExpression cvreEncoder = new CodeVariableReferenceExpression(); cvreEncoder.VariableName = "Encoder"; // SoapMessage Message CodeParameterDeclarationExpression cpdeMessage = new CodeParameterDeclarationExpression(); cpdeMessage.Name = cvreMessage.VariableName; cpdeMessage.Type = ctrSoapMessage; cpdeMessage.Direction = FieldDirection.In; // Stream StrFrom CodeParameterDeclarationExpression cpdeStrFrom = new CodeParameterDeclarationExpression(); cpdeStrFrom.Name = cvreStrFrom.VariableName; cpdeStrFrom.Type = ctrStream; cpdeStrFrom.Direction = FieldDirection.In; // Stream StrFrom CodeParameterDeclarationExpression cpdeStrTo = new CodeParameterDeclarationExpression(); cpdeStrTo.Name = cvreStrTo.VariableName; cpdeStrTo.Type = ctrStream; cpdeStrTo.Direction = FieldDirection.In; // Class Declaration CodeTypeDeclaration ctd = new CodeTypeDeclaration(); ctd.Name = "SoapExtensionEx"; ctd.Comments.AddRange(GetSummaryStatements()); ctd.BaseTypes.Add(typeof(System.Web.Services.Protocols.SoapExtension)); // Field mStrOld CodeMemberField cmfStrOld = new CodeMemberField(); cmfStrOld.Attributes = MemberAttributes.Private | MemberAttributes.Final; cmfStrOld.Name = "mStrOld"; cmfStrOld.Type = new CodeTypeReference(typeof(System.IO.Stream)); ctd.Members.Add(cmfStrOld); // Field mStrNew CodeMemberField cmfStrNew = new CodeMemberField(); cmfStrNew.Attributes = MemberAttributes.Private | MemberAttributes.Final; cmfStrNew.Name = "mStrNew"; cmfStrNew.Type = new CodeTypeReference(typeof(System.IO.Stream)); ctd.Members.Add(cmfStrNew); // Reference to the created field CodeFieldReferenceExpression cfreStrOld = new CodeFieldReferenceExpression(null, cmfStrOld.Name); // Reference to the created field CodeFieldReferenceExpression cfreStrNew = new CodeFieldReferenceExpression(null, cmfStrNew.Name); // Methods GetInitializer(MethodInfo, Attribute) CodeMemberMethod cmmGetInitializerLM = new CodeMemberMethod(); cmmGetInitializerLM.Attributes = MemberAttributes.Public | MemberAttributes.Override; cmmGetInitializerLM.Comments.AddRange(GetSummaryStatements()); cmmGetInitializerLM.Comments.Add(new CodeCommentStatement("<param name=\"MethodInfo\"></param>", true)); cmmGetInitializerLM.Comments.Add(new CodeCommentStatement("<param name=\"Attribute\"></param>", true)); cmmGetInitializerLM.Comments.Add(new CodeCommentStatement("<returns></returns>", true)); cmmGetInitializerLM.Name = "GetInitializer"; cmmGetInitializerLM.ReturnType = new CodeTypeReference(typeof(System.Object)); CodeParameterDeclarationExpression cpdeMethodInfo = new CodeParameterDeclarationExpression(); cpdeMethodInfo.Type = new CodeTypeReference(typeof(System.Web.Services.Protocols.LogicalMethodInfo)); cpdeMethodInfo.Name = "MethodInfo"; cpdeMethodInfo.Direction = FieldDirection.In; CodeParameterDeclarationExpression cpdeAttribute = new CodeParameterDeclarationExpression(); cpdeAttribute.Type = new CodeTypeReference(typeof(System.Web.Services.Protocols.SoapExtensionAttribute)); cpdeAttribute.Name = "Attribute"; cpdeAttribute.Direction = FieldDirection.In; cmmGetInitializerLM.Parameters.Add(cpdeMethodInfo); cmmGetInitializerLM.Parameters.Add(cpdeAttribute); cmmGetInitializerLM.Statements.Add( new CodeMethodReturnStatement( new CodePrimitiveExpression(null) ) ); ctd.Members.Add(cmmGetInitializerLM); // Methods GetInitializer(ServiceType) CodeMemberMethod cmmGetInitializerST = new CodeMemberMethod(); cmmGetInitializerST.Attributes = MemberAttributes.Public | MemberAttributes.Override; cmmGetInitializerST.Comments.AddRange(GetSummaryStatements()); cmmGetInitializerST.Comments.Add(new CodeCommentStatement("<param name=\"ServiceType\"></param>", true)); cmmGetInitializerST.Comments.Add(new CodeCommentStatement("<returns></returns>", true)); cmmGetInitializerST.Name = "GetInitializer"; cmmGetInitializerST.ReturnType = new CodeTypeReference(typeof(System.Object)); CodeParameterDeclarationExpression cpdeServiceType = new CodeParameterDeclarationExpression(); cpdeServiceType.Type = new CodeTypeReference(typeof(System.Type)); cpdeServiceType.Name = "ServiceType"; cpdeServiceType.Direction = FieldDirection.In; cmmGetInitializerST.Parameters.Add(cpdeServiceType); cmmGetInitializerST.Statements.Add( new CodeMethodReturnStatement(new CodeTypeOfExpression(new CodeTypeReference("SoapExtensionEx")))); ctd.Members.Add(cmmGetInitializerST); // Methods Initialize CodeMemberMethod cmmInitialize = new CodeMemberMethod(); cmmInitialize.Attributes = MemberAttributes.Public | MemberAttributes.Override; cmmInitialize.Comments.AddRange(GetSummaryStatements()); cmmInitialize.Comments.Add(new CodeCommentStatement("<param name=\"Initializer\"></param>", true)); cmmInitialize.Name = "Initialize"; CodeParameterDeclarationExpression cpdeInitializer = new CodeParameterDeclarationExpression(); cpdeInitializer.Type = new CodeTypeReference(typeof(System.Object)); cpdeInitializer.Name = "Initializer"; cpdeInitializer.Direction = FieldDirection.In; cmmInitialize.Parameters.Add(cpdeInitializer); ctd.Members.Add(cmmInitialize); // Methods ProcessMessage CodeMemberMethod cmmProcessMessage = new CodeMemberMethod(); cmmProcessMessage.Attributes = MemberAttributes.Public | MemberAttributes.Override; cmmProcessMessage.Comments.AddRange(GetSummaryStatements()); cmmProcessMessage.Comments.Add(new CodeCommentStatement("<param name=\"Message\"></param>", true)); cmmProcessMessage.Name = "ProcessMessage"; cmmProcessMessage.Parameters.Add(cpdeMessage); CodePropertyReferenceExpression cpreMessageStage = new CodePropertyReferenceExpression(cvreMessage, "Stage"); CodeVariableReferenceExpression cvreSoapMessageStage = new CodeVariableReferenceExpression("System.Web.Services.Protocols.SoapMessageStage"); CodeConditionStatement cdsBeforeSerialize = new CodeConditionStatement(); cdsBeforeSerialize.Condition = new CodeBinaryOperatorExpression(cpreMessageStage, CodeBinaryOperatorType.ValueEquality, new CodePropertyReferenceExpression(cvreSoapMessageStage, "BeforeSerialize")); CodeConditionStatement cdsAfterSerialize = new CodeConditionStatement(); cdsAfterSerialize.Condition = new CodeBinaryOperatorExpression(cpreMessageStage, CodeBinaryOperatorType.ValueEquality, new CodePropertyReferenceExpression(cvreSoapMessageStage, "AfterSerialize")); CodeMethodInvokeExpression cmieSaveRequest = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "SaveRequestMessage", cvreMessage); CodeMethodInvokeExpression cmieCopy = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Copy", new CodeExpression[] {cfreStrNew, cfreStrOld}); cdsAfterSerialize.TrueStatements.Add(cmieSaveRequest); cdsAfterSerialize.TrueStatements.Add(cmieCopy); CodeConditionStatement cdsBeforeDeserialize = new CodeConditionStatement(); cdsBeforeDeserialize.Condition = new CodeBinaryOperatorExpression(cpreMessageStage, CodeBinaryOperatorType.ValueEquality, new CodePropertyReferenceExpression(cvreSoapMessageStage, "BeforeDeserialize")); CodeMethodInvokeExpression cmieSaveResponse = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "SaveResponseMessage", cvreMessage); cdsBeforeDeserialize.TrueStatements.Add(cmieSaveResponse); CodeConditionStatement cdsAfterDeserialize = new CodeConditionStatement(); cdsAfterDeserialize.Condition = new CodeBinaryOperatorExpression(cpreMessageStage, CodeBinaryOperatorType.ValueEquality, new CodePropertyReferenceExpression(cvreSoapMessageStage, "AfterDeserialize")); CodeMethodInvokeExpression cmieStringFormat = new CodeMethodInvokeExpression(null, "System.String.Format", new CodeExpression[]{new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("System.Globalization.CultureInfo"), "InvariantCulture"), new CodePrimitiveExpression("Invalid Soap Message stage [{0}]"), cpreMessageStage}); CodeThrowExceptionStatement ctesException = new CodeThrowExceptionStatement(new CodeObjectCreateExpression(typeof(System.ArgumentException), new CodeExpression[] {cmieStringFormat, new CodePrimitiveExpression("Message")})); cdsBeforeSerialize.FalseStatements.Add(cdsAfterSerialize); cdsAfterSerialize.FalseStatements.Add(cdsBeforeDeserialize); cdsBeforeDeserialize.FalseStatements.Add(cdsAfterDeserialize); cdsAfterDeserialize.FalseStatements.Add(ctesException); cmmProcessMessage.Statements.Add(cdsBeforeSerialize); ctd.Members.Add(cmmProcessMessage); // Methods ChainStream CodeMemberMethod cmmChainStream = new CodeMemberMethod(); cmmChainStream.Attributes = MemberAttributes.Public | MemberAttributes.Override; cmmChainStream.Comments.AddRange(GetSummaryStatements()); cmmChainStream.Comments.Add(new CodeCommentStatement("<param name=\"StrFrom\"></param>", true)); cmmChainStream.Name = "ChainStream"; cmmChainStream.ReturnType = ctrStream; cmmChainStream.Parameters.Add(cpdeStrFrom); cmmChainStream.Statements.Add( new CodeAssignStatement( cfreStrOld, cvreStrFrom)); cmmChainStream.Statements.Add( new CodeAssignStatement( cfreStrNew, new CodeObjectCreateExpression(ctrMemoryStream, new CodeExpression[] {}))); cmmChainStream.Statements.Add( new CodeMethodReturnStatement(cfreStrNew)); ctd.Members.Add(cmmChainStream); // Methods SaveRequestMessage CodeMemberMethod cmmSaveRequestMessage = new CodeMemberMethod(); cmmSaveRequestMessage.Attributes = MemberAttributes.Private | MemberAttributes.Final; cmmSaveRequestMessage.Comments.AddRange(GetSummaryStatements()); cmmSaveRequestMessage.Comments.Add(new CodeCommentStatement("<param name=\"Message\"></param>", true)); cmmSaveRequestMessage.Name = "SaveRequestMessage"; cmmSaveRequestMessage.Parameters.Add(cpdeMessage); CodeVariableDeclarationStatement cvdsEncoder = new CodeVariableDeclarationStatement(); cvdsEncoder.Name = cvreEncoder.VariableName; cvdsEncoder.Type = ctrEncoder; cvdsEncoder.InitExpression = new CodeObjectCreateExpression(ctrEncoder, new CodeExpression[] {}); CodeVariableDeclarationStatement cvdsByteBuf = new CodeVariableDeclarationStatement(); cvdsByteBuf.Name = cvreByteBuf.VariableName; cvdsByteBuf.Type = ctrByteArray; cvdsByteBuf.InitExpression = new CodeArrayCreateExpression(ctrByteArray, new CodePropertyReferenceExpression(cfreStrNew, "Length")); CodeMethodInvokeExpression cmieStrNewRead = new CodeMethodInvokeExpression(cfreStrNew, "Read", new CodeExpression[] {cvreByteBuf, new CodePrimitiveExpression(0), new CodePropertyReferenceExpression(cvreByteBuf, "Length") }); CodeMethodInvokeExpression cmieEncoderGetString = new CodeMethodInvokeExpression(cvreEncoder, "GetString", new CodeCastExpression(typeof(byte[]), cvreByteBuf)); CodeAssignStatement casSoapRequest = new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeCastExpression("SoapHttpClientProtocolEx", new CodePropertyReferenceExpression(new CodeCastExpression(typeof(System.Web.Services.Protocols.SoapClientMessage), cvreMessage), "Client")),"SoapRequest"), cmieEncoderGetString); cmmSaveRequestMessage.Statements.Add(cvdsEncoder); cmmSaveRequestMessage.Statements.Add( new CodeAssignStatement( new CodePropertyReferenceExpression(cfreStrNew, "Position"), new CodePrimitiveExpression(0))); cmmSaveRequestMessage.Statements.Add(cvdsByteBuf); cmmSaveRequestMessage.Statements.Add(cmieStrNewRead); cmmSaveRequestMessage.Statements.Add(casSoapRequest); ctd.Members.Add(cmmSaveRequestMessage); // Methods SaveResponseMessage CodeMemberMethod cmmSaveResponseMessage = new CodeMemberMethod(); cmmSaveResponseMessage.Attributes = MemberAttributes.Private | MemberAttributes.Final; cmmSaveResponseMessage.Comments.AddRange(GetSummaryStatements()); cmmSaveResponseMessage.Comments.Add(new CodeCommentStatement("<param name=\"Message\"></param>", true)); cmmSaveResponseMessage.Name = "SaveResponseMessage"; cmmSaveResponseMessage.Parameters.Add(cpdeMessage); CodeVariableReferenceExpression cvreStrTemp = new CodeVariableReferenceExpression(); cvreStrTemp.VariableName = "StrTemp"; CodeVariableDeclarationStatement cvdsStrTemp = new CodeVariableDeclarationStatement(); cvdsStrTemp.Name = cvreStrTemp.VariableName; cvdsStrTemp.Type = ctrStream; cvdsStrTemp.InitExpression = new CodeObjectCreateExpression(ctrMemoryStream, new CodeExpression[] {}); CodeMethodInvokeExpression cmieCopyToTemp = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Copy", new CodeExpression[] {cfreStrOld, cvreStrTemp}); CodeVariableDeclarationStatement cvdsByteBuf2 = new CodeVariableDeclarationStatement(); cvdsByteBuf2.Name = cvreByteBuf.VariableName; cvdsByteBuf2.Type = ctrByteArray; cvdsByteBuf2.InitExpression = new CodeArrayCreateExpression(ctrByteArray, new CodePropertyReferenceExpression(cvreStrTemp, "Length")); CodeMethodInvokeExpression cmieStrTempRead = new CodeMethodInvokeExpression(cvreStrTemp, "Read", new CodeExpression[] {cvreByteBuf, new CodePrimitiveExpression(0), new CodePropertyReferenceExpression(cvreByteBuf, "Length")}); CodeAssignStatement casSoapResponse = new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeCastExpression("SoapHttpClientProtocolEx", new CodePropertyReferenceExpression(new CodeCastExpression(typeof(System.Web.Services.Protocols.SoapClientMessage), cvreMessage), "Client")),"SoapResponse"), cmieEncoderGetString); CodeMethodInvokeExpression cmieCopyToNew = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Copy", new CodeExpression[] {cvreStrTemp, cfreStrNew }); cmmSaveResponseMessage.Statements.Add(cvdsEncoder); cmmSaveResponseMessage.Statements.Add(cvdsStrTemp); cmmSaveResponseMessage.Statements.Add(cmieCopyToTemp); cmmSaveResponseMessage.Statements.Add(cvdsByteBuf2); cmmSaveResponseMessage.Statements.Add(cmieStrTempRead); cmmSaveResponseMessage.Statements.Add(casSoapResponse); cmmSaveResponseMessage.Statements.Add(cmieCopyToNew); ctd.Members.Add(cmmSaveResponseMessage); // Methods Copy CodeMemberMethod cmmCopy = new CodeMemberMethod(); cmmCopy.Attributes = MemberAttributes.Private | MemberAttributes.Final; cmmCopy.Comments.AddRange(GetSummaryStatements()); cmmCopy.Comments.Add(new CodeCommentStatement("<param name=\"StrFrom\"></param>", true)); cmmCopy.Comments.Add(new CodeCommentStatement("<param name=\"StrTo\"></param>", true)); cmmCopy.Name = "Copy"; cmmCopy.Parameters.Add(cpdeStrFrom); cmmCopy.Parameters.Add(cpdeStrTo); CodeAssignStatement casStrFromPosition = new CodeAssignStatement(new CodePropertyReferenceExpression(cvreStrFrom, "Position"), new CodePrimitiveExpression(0) ); CodeConditionStatement ccsStrFromCanSeek = new CodeConditionStatement(new CodePropertyReferenceExpression(cvreStrFrom, "CanSeek"), new CodeStatement[] {casStrFromPosition}); CodeVariableReferenceExpression cvreTxtReader = new CodeVariableReferenceExpression("TxtReader"); CodeVariableDeclarationStatement cvdsTxtReader = new CodeVariableDeclarationStatement(); cvdsTxtReader.Name = cvreTxtReader.VariableName; cvdsTxtReader.Type = new CodeTypeReference(typeof(System.IO.TextReader)); cvdsTxtReader.InitExpression = new CodeObjectCreateExpression(typeof(System.IO.StreamReader), new CodeExpression[] {cvreStrFrom}); CodeVariableReferenceExpression cvreTxtWriter = new CodeVariableReferenceExpression("TxtWriter"); CodeVariableDeclarationStatement cvdsTxtWriter = new CodeVariableDeclarationStatement(); cvdsTxtWriter.Name = cvreTxtWriter.VariableName; cvdsTxtWriter.Type = new CodeTypeReference(typeof(System.IO.TextWriter)); cvdsTxtWriter.InitExpression = new CodeObjectCreateExpression(typeof(System.IO.StreamWriter), new CodeExpression[] {cvreStrTo }); CodeMethodInvokeExpression cmieTxtWriterWriteLine = new CodeMethodInvokeExpression(cvreTxtWriter, "WriteLine", new CodeExpression[] {new CodeMethodInvokeExpression(cvreTxtReader, "ReadToEnd", new CodeExpression[] {})}); CodeMethodInvokeExpression cmiTxtWriterFlush = new CodeMethodInvokeExpression(cvreTxtWriter, "Flush", new CodeExpression[] {}); CodeConditionStatement ccsStrToCanSeek = new CodeConditionStatement(new CodePropertyReferenceExpression(cvreStrTo, "CanSeek"), new CodeStatement[] {new CodeAssignStatement(new CodePropertyReferenceExpression(cvreStrTo, "Position"), new CodePrimitiveExpression(0) )}); cmmCopy.Statements.Add(ccsStrFromCanSeek); cmmCopy.Statements.Add(cvdsTxtReader); cmmCopy.Statements.Add(cvdsTxtWriter); cmmCopy.Statements.Add(cmieTxtWriterWriteLine); cmmCopy.Statements.Add(cmiTxtWriterFlush); cmmCopy.Statements.Add(ccsStrToCanSeek); ctd.Members.Add(cmmCopy); return ctd; }
private void CreateServiceType() { // We can create the service type(s) only if we have one or more service // contract. if (code.ServiceContracts.Count > 0) { // Take a reference to the first ServiceContract available. // IMPORTANT!:(Currently we only support single service type) // May be want to support multiple service contracts in the next version. CodeTypeExtension srvContract = code.ServiceContracts[0]; // Notify if srvContract is null. This would mean that we have constructed a bad // GeneratedCode instance from our CodeFactory. Debug.Assert(srvContract != null, "Generated service contract could not be null."); // Construct the service type name by removing the leading "I" character from // the service contract name that was added for generation of the interface. string srvTypeName = srvContract.ExtendedObject.Name.Substring(1); // Create a new instance of CodeTypeDeclaration type representing the service type. CodeTypeDeclaration srvType = new CodeTypeDeclaration(srvTypeName); // Also wrap the CodeTypeDeclaration in an extension. CodeTypeExtension typeExt = new CodeTypeExtension(srvType); // This class. srvType.IsClass = true; switch (options.MethodImplementation) { case MethodImplementation.PartialClassMethodCalls: // The service type is partial so that the implementation methods can be written in separate file. srvType.IsPartial = true; break; case MethodImplementation.AbstractMethods: // The service type is abstract so that the operation methods can be made abstract. srvType.TypeAttributes |= TypeAttributes.Abstract; break; } // And this implements the service contract interface. if (code.CodeLanguauge == CodeLanguage.VisualBasic) { srvType.Members.Add(new CodeSnippetTypeMember("Implements " + srvContract.ExtendedObject.Name)); } else { srvType.BaseTypes.Add(new CodeTypeReference(srvContract.ExtendedObject.Name)); } // Now itterate the srvContractObject.Members and add each and every method in // the service contract type to the new type being created. foreach (CodeTypeMemberExtension methodExtension in srvContract.Methods) { // Get a referece to the actual CodeMemberMethod object extended // by ext. CodeMemberMethod method = methodExtension.ExtendedObject as CodeMemberMethod; // Create a new CodeMemeberMethod and copy the attributes. CodeMemberMethod newMethod = new CodeMemberMethod(); newMethod.Name = method.Name; // Implemented method has to be public. newMethod.Attributes = MemberAttributes.Public; // Notify that this member is implementing a method in the service contract. if (code.CodeLanguauge == CodeLanguage.VisualBasic) { newMethod.ImplementationTypes.Add(new CodeTypeReference(srvContract.ExtendedObject.Name)); } else { newMethod.ImplementationTypes.Add(srvType.BaseTypes[0]); } // Add all parametes to the newly created method. foreach (CodeParameterDeclarationExpression cpde in method.Parameters) { newMethod.Parameters.Add(cpde); } // Set the return type. newMethod.ReturnType = method.ReturnType; switch (options.MethodImplementation) { case MethodImplementation.PartialClassMethodCalls: { // Gather the parameters from the operation to pass into the implementation method. IEnumerable<CodeArgumentReferenceExpression> parameters = newMethod.Parameters .OfType<CodeParameterDeclarationExpression>() .Select(p => new CodeArgumentReferenceExpression(p.Name)); // Create an expression to invoke the implementation method. CodeMethodInvokeExpression methodInvocation = new CodeMethodInvokeExpression(null, newMethod.Name + "Implementation", parameters.ToArray()); // Check if the method has a return type. if (newMethod.ReturnType.BaseType != "System.Void") { // Make sure the call to the implementation method is returned. CodeMethodReturnStatement returnStatement = new CodeMethodReturnStatement(methodInvocation); newMethod.Statements.Add(returnStatement); } else { // Add the call to the implementation method without a return. newMethod.Statements.Add(methodInvocation); } } break; case MethodImplementation.NotImplementedException: { // Create a new code statement to throw NotImplementedExcption. CodeThrowExceptionStatement niex = new CodeThrowExceptionStatement( new CodeObjectCreateExpression( new CodeTypeReference(typeof(NotImplementedException)), new CodeExpression[] { }) ); // Add it to the statements collection in the new method. newMethod.Statements.Add(niex); } break; case MethodImplementation.AbstractMethods: { // No statement is required for the abstract methods. newMethod.Attributes |= MemberAttributes.Abstract; break; } } // Wrap the CodeMemberMethod in an extension. This could be useful for other extensions. CodeTypeMemberExtension newMethodExt = new CodeTypeMemberExtension(newMethod, typeExt); srvType.Members.Add(newMethodExt); } // Add the ServiceBehaviorAttribute attribute. CodeAttributeDeclaration serviceBehaviorAttribute = new CodeAttributeDeclaration( new CodeTypeReference(typeof(ServiceBehaviorAttribute))); if (!string.IsNullOrEmpty(options.InstanceContextMode)) { CodeTypeReferenceExpression instanceContextModeEnum = new CodeTypeReferenceExpression(typeof(InstanceContextMode)); CodeFieldReferenceExpression instanceContextModeValue = new CodeFieldReferenceExpression(instanceContextModeEnum, options.InstanceContextMode); CodeAttributeArgument instanceContextModeArgument = new CodeAttributeArgument("InstanceContextMode", instanceContextModeValue); serviceBehaviorAttribute.Arguments.Add(instanceContextModeArgument); } if (!string.IsNullOrEmpty(options.ConcurrencyMode)) { CodeTypeReferenceExpression concurrencyModeEnum = new CodeTypeReferenceExpression(typeof(ConcurrencyMode)); CodeFieldReferenceExpression concurrencyModeValue = new CodeFieldReferenceExpression(concurrencyModeEnum, options.ConcurrencyMode); CodeAttributeArgument concurrencyModeArgument = new CodeAttributeArgument("ConcurrencyMode", concurrencyModeValue); serviceBehaviorAttribute.Arguments.Add(concurrencyModeArgument); } if (!options.UseSynchronizationContext) { CodeAttributeArgument useSynchronizationContextAttribute = new CodeAttributeArgument("UseSynchronizationContext", new CodePrimitiveExpression(false)); serviceBehaviorAttribute.Arguments.Add(useSynchronizationContextAttribute); } typeExt.AddAttribute(serviceBehaviorAttribute); this.serviceTypeName = srvType.Name; // Finally add the newly created type to the code being generated. code.ServiceTypes.Add(typeExt); } }
public CodeThrowExceptionStatement Throw(CodeExpression expr) { CodeThrowExceptionStatement st = new CodeThrowExceptionStatement(expr); csc.Add(st); return st; }
protected override void GenerateThrowExceptionStatement (CodeThrowExceptionStatement e) { }
public bool ValidateCodeThrowExceptionStatement (CodeThrowExceptionStatement exp) { PushError ("CodeThrowExceptionStatement is not in the subset."); return false; }
private void ValidateThrowExceptionStatement(CodeThrowExceptionStatement e) { if (e.ToThrow != null) { ValidateExpression(e.ToThrow); } }
protected override void GenerateThrowExceptionStatement(System.CodeDom.CodeThrowExceptionStatement e) { throw new Exception("The method or operation is not implemented."); }
protected override void GenerateThrowExceptionStatement(CodeThrowExceptionStatement e) { Output.WriteLine("[CodeThrowExceptionStatement: {0}]", e.ToString()); }
/// <devdoc> /// <para> /// Generates code for the specified CodeDom based throw exception statement /// representation. /// </para> /// </devdoc> private void GenerateThrowExceptionStatement(CodeThrowExceptionStatement e) { Output.Write("throw"); if (e.ToThrow != null) { Output.Write(" "); GenerateExpression(e.ToThrow); } Output.WriteLine(";"); }
public override object Visit(ThrowStatement throwStatement, object data) { ProcessSpecials(throwStatement.Specials); CodeThrowExceptionStatement throwStmt = new CodeThrowExceptionStatement((CodeExpression)throwStatement.ThrowExpression.AcceptVisitor(this, data)); // Add Statement to Current Statement Collection AddStmt(throwStmt); return throwStmt; }
public override void PrefixOutParams(ref CodeConditionStatement condOut, ref CodeConditionStatement condOutIter, string idlMethodName, ref int nOutArgCounter, ref CodeThrowExceptionStatement throwargOutPrev) { CodeVariableReferenceExpression varrefVariantSignature = new CodeVariableReferenceExpression("variantSignature"); CodeConditionStatement condVariantSignature = new CodeConditionStatement( // * if (this.result == 0) exprResultOk, new CodeStatement[] // True statements { // * dbus_sig variantSignature; new CodeVariableDeclarationStatement(typerefSig, "variantSignature") // * this.result = Udbus.Core.UdbusMessageReader.MarshalSignature(reader, out variantSignature); , new CodeAssignStatement(fieldrefResult, new CodeMethodInvokeExpression(CodeBuilderCommon.typerefexprMessageReader, "ReadSignature", varrefReader, new CodeDirectionExpression(FieldDirection.Out, varrefVariantSignature))) } , new CodeStatement[] // False statements { throwargOutPrev } ); throwargOutPrev = ThrowArgOutException(idlMethodName, nOutArgCounter, "variantSignature", typerefSig); this.StoreCondIterator(ref condOut, ref condOutIter, condVariantSignature); ++nOutArgCounter; }