// Generates a codedom instantiation expression: new foo() or new foo[x]. public static CodeExpression Emit(Instantiation instantiation) { // Array instantiation needs a different treatment. if (instantiation.IsArray) { var c = new CodeArrayCreateExpression(); c.CreateType = new CodeTypeReference(instantiation.Name); c.SizeExpression = CodeDomEmitter.EmitCodeExpression(instantiation.Parameters.ChildExpressions[0]); return c; } else // Non-array instantiation { var c = new CodeObjectCreateExpression(); // The type that is being created var createType = new CodeTypeReference(instantiation.Name); // Apply the generic type names, if any. foreach (var g in instantiation.GenericTypes) { createType.TypeArguments.Add(new CodeTypeReference(g)); } c.CreateType = createType; // Translate the instantiation parameters. foreach (var a in instantiation.Parameters.ChildExpressions) c.Parameters.Add(CodeDomEmitter.EmitCodeExpression(a)); return c; } }
public void EmitGetFingerprint (CodeTypeDeclaration ctd) { byte[] hash = Hash; CodeArrayCreateExpression mkdata = new CodeArrayCreateExpression (CDH.Byte, hash.Length); for (int i = 0; i < hash.Length; i++) // well, this for loop sucks mkdata.Initializers.Add (new CodePrimitiveExpression (hash[i])); CodeMemberMethod m = new CodeMemberMethod (); m.Name = "GetFingerprint"; m.Attributes = MemberAttributes.Public | MemberAttributes.Override; m.ReturnType = CDH.Fingerprint; m.Parameters.Add (CDH.Param (CDH.IContext, "unused1")); m.Parameters.Add (CDH.Param (CDH.Fingerprint, "unused2")); CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression (); invoke.Method = new CodeMethodReferenceExpression (Generic, "Constant"); invoke.Parameters.Add (mkdata); m.Statements.Add (new CodeMethodReturnStatement (invoke)); ctd.Members.Add (m); }
public void Constructor1_Deny_Unrestricted () { CodeArrayCreateExpression cace = new CodeArrayCreateExpression (ctr, ce); Assert.AreEqual ("System.Void", cace.CreateType.BaseType, "CreateType.BaseType"); Assert.AreEqual (0, cace.Initializers.Count, "Initializers"); Assert.AreEqual (0, cace.Size, "Size"); Assert.AreSame (ce, cace.SizeExpression, "SizeExpression"); }
public static CodeMethodInvokeExpression GetConcatExpression(IList<ExpressionStringToken> values) { var stringType = new CodeTypeReference(typeof(string)); var arrayExpression = new CodeArrayCreateExpression { CreateType = new CodeTypeReference("System.String", 1) { ArrayElementType = stringType }, Size = 0 }; foreach (var expressionStringToken in values) { if (expressionStringToken.IsExpression) { var toStringExpression = new CodeMethodInvokeExpression { Method = new CodeMethodReferenceExpression { MethodName = "ToString", TargetObject = new CodeVariableReferenceExpression { VariableName = "Convert" } } }; toStringExpression.Parameters.Add(new CodeSnippetExpression { Value = expressionStringToken.Value }); arrayExpression.Initializers.Add(toStringExpression); } else { var _value3 = new CodePrimitiveExpression { Value = expressionStringToken.Value }; arrayExpression.Initializers.Add(_value3); } } var concatExpression = new CodeMethodInvokeExpression { Method = new CodeMethodReferenceExpression { MethodName = "Concat", TargetObject = new CodeTypeReferenceExpression { Type = stringType } } }; concatExpression.Parameters.Add(arrayExpression); return concatExpression; }
// // Methods // protected override void GenerateArrayCreateExpression (CodeArrayCreateExpression expression) { // // This tries to replicate MS behavior as good as // possible. // // The Code-Array stuff in ms.net seems to be broken // anyways, or I'm too stupid to understand it. // // I'm sick of it. If you try to develop array // creations, test them on windows. If it works there // but not in mono, drop me a note. I'd be especially // interested in jagged-multidimensional combinations // with proper initialization :} // TextWriter output = Output; output.Write ("new "); CodeExpressionCollection initializers = expression.Initializers; CodeTypeReference createType = expression.CreateType; if (initializers.Count > 0) { OutputType (createType); if (expression.CreateType.ArrayRank == 0) { output.Write ("[]"); } OutputStartBrace (); ++Indent; OutputExpressionList (initializers, true); --Indent; output.Write ("}"); } else { CodeTypeReference arrayType = createType.ArrayElementType; while (arrayType != null) { createType = arrayType; arrayType = arrayType.ArrayElementType; } OutputType (createType); output.Write ('['); CodeExpression size = expression.SizeExpression; if (size != null) GenerateExpression (size); else output.Write (expression.Size); output.Write(']'); } }
public void NullCreateType () { CodeArrayCreateExpression cace = new CodeArrayCreateExpression ((CodeTypeReference) null, 0); Assert.IsNotNull (cace.CreateType, "#1"); Assert.AreEqual (typeof (void).FullName, cace.CreateType.BaseType, "#2"); cace.CreateType = null; Assert.IsNotNull (cace.CreateType, "#3"); Assert.AreEqual (typeof (void).FullName, cace.CreateType.BaseType, "#4"); }
/// <summary> /// Visits a <see cref="CodeArrayCreateExpression"/>. /// </summary> /// <param name="codeArrayCreateExpression">The <see cref="CodeArrayCreateExpression"/> to visit.</param> protected virtual void VisitCodeArrayCreateExpression(CodeArrayCreateExpression codeArrayCreateExpression) { if (codeArrayCreateExpression == null) { return; } this.VisitCodeTypeReference(codeArrayCreateExpression.CreateType); this.VisitCodeExpressionCollection(codeArrayCreateExpression.Initializers); this.VisitCodeExpression(codeArrayCreateExpression.SizeExpression); }
public static CodeArrayCreateExpression Clone(this CodeArrayCreateExpression expression) { if (expression == null) return null; CodeArrayCreateExpression e = new CodeArrayCreateExpression(); e.CreateType = expression.CreateType.Clone(); e.Initializers.AddRange(expression.Initializers.Clone()); e.Size = expression.Size; e.SizeExpression = expression.SizeExpression.Clone(); e.UserData.AddRange(expression.UserData); return e; }
public TypescriptArrayCreateExpression( IExpressionFactory expressionFactory, CodeArrayCreateExpression codeExpression, CodeGeneratorOptions options, ITypescriptTypeMapper typescriptTypeMapper) { _expressionFactory = expressionFactory; _codeExpression = codeExpression; _options = options; _typescriptTypeMapper = typescriptTypeMapper; System.Diagnostics.Debug.WriteLine("TypescriptArrayCreateExpression Created"); }
internal static CodeExpression MaterializeSimpleTypeDef( ClrSimpleTypeInfo typeInfo, Dictionary<XmlSchemaObject, string> nameMappings, LinqToXsdSettings settings) { CodeObjectCreateExpression simpleTypeCreate = null; CodeExpressionCollection expressions = null; switch(typeInfo.Variety) { case XmlSchemaDatatypeVariety.Atomic: simpleTypeCreate = new CodeObjectCreateExpression( Constants.AtomicSimpleTypeValidator); expressions = simpleTypeCreate.Parameters; expressions.Add(CreateGetBuiltInSimpleType(typeInfo.TypeCode)); expressions.Add(CreateFacets(typeInfo)); break; case XmlSchemaDatatypeVariety.List: simpleTypeCreate = new CodeObjectCreateExpression( Constants.ListSimpleTypeValidator); expressions = simpleTypeCreate.Parameters; expressions.Add(CreateGetBuiltInSimpleType(typeInfo.TypeCode)); expressions.Add(CreateFacets(typeInfo)); ListSimpleTypeInfo listType = typeInfo as ListSimpleTypeInfo; ClrSimpleTypeInfo itemType = listType.ItemType; expressions.Add(CreateSimpleTypeDef( itemType, nameMappings, settings, true)); break; case XmlSchemaDatatypeVariety.Union: simpleTypeCreate = new CodeObjectCreateExpression( Constants.UnionSimpleTypeValidator); expressions = simpleTypeCreate.Parameters; expressions.Add(CreateGetBuiltInSimpleType(typeInfo.TypeCode)); expressions.Add(CreateFacets(typeInfo)); UnionSimpleTypeInfo unionType = typeInfo as UnionSimpleTypeInfo; CodeArrayCreateExpression memberTypeCreate = new CodeArrayCreateExpression(); memberTypeCreate.CreateType = new CodeTypeReference( Constants.SimpleTypeValidator); foreach (ClrSimpleTypeInfo st in unionType.MemberTypes) { memberTypeCreate.Initializers.Add(CreateSimpleTypeDef( st, nameMappings, settings, true)); } expressions.Add(memberTypeCreate); break; } return simpleTypeCreate; }
internal override CodeExpression Clone(CodeExpression expression) { CodeArrayCreateExpression expression2 = (CodeArrayCreateExpression) expression; CodeArrayCreateExpression expression3 = new CodeArrayCreateExpression { CreateType = TypeReferenceExpression.CloneType(expression2.CreateType), Size = expression2.Size }; if (expression2.SizeExpression != null) { expression3.SizeExpression = RuleExpressionWalker.Clone(expression2.SizeExpression); } foreach (CodeExpression expression4 in expression2.Initializers) { expression3.Initializers.Add(RuleExpressionWalker.Clone(expression4)); } return expression3; }
public override void Generate(object codeObject, Entity entity) { base.Generate(codeObject, entity); var attribute = (CodeAttributeDeclaration)codeObject; var docType = (DocumentType)entity; var info = (DocumentTypeInfo)docType.Info; AddAttributeArgumentIfValue(attribute, "DefaultTemplate", info.DefaultTemplate); var allowedTemplates = info.AllowedTemplates .NonNullOrWhiteSpace() .AsPrimitiveExpressions(); var arrayCreateExpression = new CodeArrayCreateExpression("String", allowedTemplates); if (allowedTemplates.Any()) AddAttributeArgument(attribute, "AllowedTemplates", arrayCreateExpression); }
public CodeExpression[] Generate(Table table, HardwireCodeGenerationContext generator, CodeTypeMemberCollection members) { List<CodeExpression> initializers = new List<CodeExpression>(); generator.DispatchTablePairs(table.Get("overloads").Table, members, exp => { initializers.Add(exp); }); var name = new CodePrimitiveExpression((table["name"] as string)); var type = new CodeTypeOfExpression(table["decltype"] as string); var array = new CodeArrayCreateExpression(typeof(IOverloadableMemberDescriptor), initializers.ToArray()); return new CodeExpression[] { new CodeObjectCreateExpression(typeof(OverloadedMethodMemberDescriptor), name, type, array) }; }
protected override void GenerateArrayCreateExpression(System.CodeDom.CodeArrayCreateExpression e) { //throw new Exception("The method or operation is not implemented."); Output.Write("new "); OutputType(e.CreateType); Output.Write("["); Output.Write(e.Initializers.Count); Output.Write("]"); if (e.Initializers.Count > 0) { Output.Write("("); GenerateExpression(e.Initializers[0]); for (int i = 1; i < e.Initializers.Count; i++) { Output.Write(", "); GenerateExpression(e.Initializers[i]); } Output.Write(")"); } }
void EmitArray(CodeArrayCreateExpression array) { writer.Write(Parser.ArrayOpen); bool first = true; depth++; foreach (CodeExpression expr in array.Initializers) { if (first) first = false; else { writer.Write(Parser.DefaultMulticast); writer.Write(Parser.SingleSpace); } EmitExpression(expr); } depth--; writer.Write(Parser.ArrayClose); }
public override void Generate(object codeObject, Entity entity) { var contentType = (ContentType) entity; var attribute = (CodeAttributeDeclaration) codeObject; var structure = contentType.Structure; if (structure.All(String.IsNullOrWhiteSpace)) return; var typeofExpressions = structure .Where(allowedType => !String.IsNullOrWhiteSpace(allowedType)) .Select(allowedType => new CodeTypeOfExpression(allowedType.PascalCase())) .Cast<CodeExpression>() .ToArray(); var expression = new CodeArrayCreateExpression( typeof(Type[]), typeofExpressions ); AddAttributeArgument(attribute, "Structure", expression); }
protected override void GenerateArrayCreateExpression (CodeArrayCreateExpression expression) { TextWriter output = Output; output.Write ("new "); CodeExpressionCollection initializers = expression.Initializers; CodeTypeReference createType = expression.CreateType; if (initializers.Count > 0) { OutputType (createType); if (expression.CreateType.ArrayRank == 0) output.Write ("[]"); output.Write ('['); ++Indent; OutputExpressionList (initializers, true); --Indent; output.Write (']'); } else { CodeTypeReference arrayType = createType.ArrayElementType; while (arrayType != null) { createType = arrayType; arrayType = arrayType.ArrayElementType; } OutputType (createType); output.Write ('['); CodeExpression size = expression.SizeExpression; if (size != null) GenerateExpression (size); else output.Write (expression.Size); output.Write (']'); } }
protected override void GenerateArrayCreateExpression(CodeArrayCreateExpression e) { CodeExpressionCollection initializers = e.Initializers; // Literal array if (initializers.Count > 0) { // the syntax is something like <int>{ 10,12,14 } this.Output.Write("<"); // Is a specific type indicated ? if (e.CreateType.ArrayElementType != null) { this.OutputType(e.CreateType.ArrayElementType); } else { this.OutputType(e.CreateType); } // this.Output.Write(">{ "); this.OutputExpressionList(initializers, false); this.Output.Write(" }"); } else { // Standard Array declaration base.Output.Write(this.GetBaseTypeOutput(e.CreateType)); base.Output.Write("["); if (e.SizeExpression != null) { base.GenerateExpression(e.SizeExpression); } else { base.Output.Write(e.Size); } base.Output.Write("]"); } }
CodeExpression StringConcat(params CodeExpression[] parts) { var list = new List<CodeExpression>(parts.Length); foreach (var part in parts) { if (part is CodePrimitiveExpression) { var value = ((CodePrimitiveExpression)part).Value; if (value is string && string.IsNullOrEmpty((string)value)) continue; } list.Add(part); } if (list.Count == 1) return list[0]; Type str = typeof(string); var method = (CodeMethodReferenceExpression)InternalMethods.Concat; var all = new CodeArrayCreateExpression(str, list.ToArray()); return new CodeMethodInvokeExpression(method, all); }
private void AddFindByMethods(CodeTypeDeclaration dataTableClass) { DataTable dataTable = this.designTable.DataTable; for (int i = 0; i < dataTable.Constraints.Count; i++) { if ((dataTable.Constraints[i] is UniqueConstraint) && ((UniqueConstraint) dataTable.Constraints[i]).IsPrimaryKey) { DataColumn[] columns = ((UniqueConstraint) dataTable.Constraints[i]).Columns; string inVarName = "FindBy"; bool flag = true; for (int j = 0; j < columns.Length; j++) { inVarName = inVarName + this.codeGenerator.TableHandler.Tables[columns[j].Table.TableName].DesignColumns[columns[j].ColumnName].GeneratorColumnPropNameInRow; if (columns[j].ColumnMapping != MappingType.Hidden) { flag = false; } } if (!flag) { CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.Type(this.rowClassName), NameHandler.FixIdName(inVarName), MemberAttributes.Public | MemberAttributes.Final); for (int k = 0; k < columns.Length; k++) { method.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.Type(columns[k].DataType), this.codeGenerator.TableHandler.Tables[columns[k].Table.TableName].DesignColumns[columns[k].ColumnName].GeneratorColumnPropNameInRow)); } CodeArrayCreateExpression par = new CodeArrayCreateExpression(typeof(object), columns.Length); for (int m = 0; m < columns.Length; m++) { par.Initializers.Add(CodeGenHelper.Argument(this.codeGenerator.TableHandler.Tables[columns[m].Table.TableName].DesignColumns[columns[m].ColumnName].GeneratorColumnPropNameInRow)); } method.Statements.Add(CodeGenHelper.Return(CodeGenHelper.Cast(CodeGenHelper.Type(this.rowClassName), CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.This(), "Rows"), "Find", par)))); dataTableClass.Members.Add(method); } } } }
protected override void GenerateArrayCreateExpression(CodeArrayCreateExpression e) { Output.Write("[CodeArrayCreateExpression: {0}]", e.ToString()); }
public void GenerateModelCode(ViewModel model, DirectoryInfo saveDir) { //TODO: Make code more modular, add more comments CodeCompileUnit compileUnit = new CodeCompileUnit(); CodeNamespace globalNamespace = new CodeNamespace(); globalNamespace.Imports.AddRange( configuration.Namespaces.Select(x => new CodeNamespaceImport(x)).ToArray()); //Add global using statements compileUnit.Namespaces.Add(globalNamespace); CodeTypeDeclaration modelClass = new CodeTypeDeclaration(model.Name); // Sets the member attributes for the type to public modelClass.Attributes = MemberAttributes.Public; // Set the base class which the model inherits from modelClass.BaseTypes.Add(model.BaseClass.Name); //Add the View Model Attribute modelClass.CustomAttributes.Add(new CodeAttributeDeclaration("ViewModel", new CodeAttributeArgument(new CodePrimitiveExpression(model.SchemaName)), //Schema Name new CodeAttributeArgument(new CodePrimitiveExpression(true)) //Is Default )); foreach (var field in model.FieldProperties) { if (configuration.FieldAttributeTypes.ContainsKey(field.FieldType)) { CodeAttributeDeclaration fieldAttribute = new CodeAttributeDeclaration( configuration.FieldAttributeTypes[field.FieldType].Name, //Field Attribute Name new CodeAttributeArgument(new CodePrimitiveExpression(field.FieldName))); //Schema Field Name if (field.FieldType == FieldType.Linked) { //Field is a Linked Component, we need to assemble the list of possible Types var modelTypes = new List<CodeExpression>(); //Populate list of Types foreach (var modelName in field.LinkedComponentTypeNames) { modelTypes.Add(new CodeTypeOfExpression(modelName)); } if (modelTypes.Count > 0) { //Create Array of Types and pass in the list of Types CodeArrayCreateExpression codeArrayCreate = new CodeArrayCreateExpression("Type", modelTypes.ToArray()); //Add the array of Types to the Attribute arguments fieldAttribute.Arguments.Add( new CodeAttributeArgument(configuration.LinkedComponentTypesAttributeParameterName, codeArrayCreate)); } } else if (field.FieldType == FieldType.Embedded && !string.IsNullOrEmpty(field.EmbeddedTypeName)) { //Add the required Type argument for embedded fields fieldAttribute.Arguments.Add( new CodeAttributeArgument(new CodeTypeOfExpression(field.EmbeddedTypeName))); } if (field.IsMultiValue) { //Add boolean value for multiple values fieldAttribute.Arguments.Add(new CodeAttributeArgument("AllowMultipleValues", new CodePrimitiveExpression(true))); } if (field.IsMetadata) { //Add boolean for metadata fields fieldAttribute.Arguments.Add(new CodeAttributeArgument("IsMetadata", new CodePrimitiveExpression(true))); } //Create and populate the model Property CodeMemberField property = new CodeMemberField { Name = field.PropertyName }; //Use CodeMemberField as a hack to add a blank getter/setter property.Attributes = MemberAttributes.Public; property.Type = GetPropertyType(model.BaseClass, field); property.CustomAttributes.Add(fieldAttribute); //Add the Field Attribute property.Name += " { get; set; }"; //Hack to add empty get/set modelClass.Members.Add(property); } } if (configuration.ModelAttributeTypes.ContainsKey(model.ModelType)) { var attrs = configuration.ModelAttributeTypes[model.ModelType]; //loop through all the "extra" model properties in the config that don't necessarily have a direct link to the Schema i.e. multimedia foreach (var attr in attrs) { CodeAttributeDeclaration modelAttribute = new CodeAttributeDeclaration(attr.Name); //Field Attribute Name CodeMemberField property = new CodeMemberField { Name = attr.DefaultPropertyName }; //Use CodeMemberField as a hack to add a blank getter/setter property.Attributes = MemberAttributes.Public; property.Type = new CodeTypeReference(attr.ReturnTypeName); property.CustomAttributes.Add(modelAttribute); //Add the Field Attribute property.Name += " { get; set; }"; //Hack to add empty get/set modelClass.Members.Add(property); } } var ns = new CodeNamespace(namespaceName); ns.Types.Add(modelClass); compileUnit.Namespaces.Add(ns); if (!saveDir.Exists) saveDir.Create(); DirectoryInfo dir = new DirectoryInfo(Path.Combine(saveDir.FullName, model.ContainingFolder)); if (!dir.Exists) dir.Create(); string filePath = Path.Combine(dir.FullName, model.Name + ".cs"); CreateFile(filePath, compileUnit); }
internal override CodeExpression BuildInvokeAsync (string messageName, CodeArrayCreateExpression paramsArray, CodeExpression delegateField, CodeExpression userStateVar) { HttpOperationBinding httpOper = OperationBinding.Extensions.Find (typeof (HttpOperationBinding)) as HttpOperationBinding; CodeThisReferenceExpression ethis = new CodeThisReferenceExpression(); CodeExpression thisURlExp = new CodeFieldReferenceExpression (ethis, "Url"); CodePrimitiveExpression metUrl = new CodePrimitiveExpression (httpOper.Location); CodeBinaryOperatorExpression expMethodLocation = new CodeBinaryOperatorExpression (thisURlExp, CodeBinaryOperatorType.Add, metUrl); CodeMethodInvokeExpression inv2 = new CodeMethodInvokeExpression (ethis, "InvokeAsync"); inv2.Parameters.Add (new CodePrimitiveExpression (messageName)); inv2.Parameters.Add (expMethodLocation); inv2.Parameters.Add (paramsArray); inv2.Parameters.Add (delegateField); inv2.Parameters.Add (userStateVar); return inv2; }
CodeMemberMethod GenerateMethod (CodeIdentifiers memberIds, HttpOperationBinding httpOper, XmlMembersMapping inputMembers, XmlTypeMapping outputMember) { CodeIdentifiers pids = new CodeIdentifiers (); CodeMemberMethod method = new CodeMemberMethod (); CodeMemberMethod methodBegin = new CodeMemberMethod (); CodeMemberMethod methodEnd = new CodeMemberMethod (); method.Attributes = MemberAttributes.Public; methodBegin.Attributes = MemberAttributes.Public; methodEnd.Attributes = MemberAttributes.Public; // Find unique names for temporary variables for (int n=0; n<inputMembers.Count; n++) pids.AddUnique (inputMembers[n].MemberName, inputMembers[n]); string varAsyncResult = pids.AddUnique ("asyncResult","asyncResult"); string varCallback = pids.AddUnique ("callback","callback"); string varAsyncState = pids.AddUnique ("asyncState","asyncState"); string messageName = memberIds.AddUnique(CodeIdentifier.MakeValid(Operation.Name),method); method.Name = Operation.Name; methodBegin.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("Begin" + Operation.Name),method); methodEnd.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("End" + Operation.Name),method); method.ReturnType = new CodeTypeReference (typeof(void)); methodEnd.ReturnType = new CodeTypeReference (typeof(void)); methodEnd.Parameters.Add (new CodeParameterDeclarationExpression (typeof (IAsyncResult),varAsyncResult)); CodeExpression[] paramArray = new CodeExpression [inputMembers.Count]; for (int n=0; n<inputMembers.Count; n++) { string ptype = GetSimpleType (inputMembers[n]); CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (ptype, inputMembers[n].MemberName); param.Direction = FieldDirection.In; method.Parameters.Add (param); methodBegin.Parameters.Add (param); paramArray [n] = new CodeVariableReferenceExpression (param.Name); } bool isVoid = true; if (outputMember != null) { method.ReturnType = new CodeTypeReference (outputMember.TypeFullName); methodEnd.ReturnType = new CodeTypeReference (outputMember.TypeFullName); xmlExporter.AddMappingMetadata (method.ReturnTypeCustomAttributes, outputMember, ""); isVoid = false; } methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (AsyncCallback),varCallback)); methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object),varAsyncState)); methodBegin.ReturnType = new CodeTypeReference (typeof(IAsyncResult)); // Array of input parameters CodeArrayCreateExpression methodParams; if (paramArray.Length > 0) methodParams = new CodeArrayCreateExpression (typeof(object), paramArray); else methodParams = new CodeArrayCreateExpression (typeof(object), 0); // Generate method url CodeThisReferenceExpression ethis = new CodeThisReferenceExpression(); CodeExpression thisURlExp = new CodeFieldReferenceExpression (ethis, "Url"); CodePrimitiveExpression metUrl = new CodePrimitiveExpression (httpOper.Location); CodeBinaryOperatorExpression expMethodLocation = new CodeBinaryOperatorExpression (thisURlExp, CodeBinaryOperatorType.Add, metUrl); // Invoke call CodePrimitiveExpression varMsgName = new CodePrimitiveExpression (messageName); CodeMethodInvokeExpression inv; inv = new CodeMethodInvokeExpression (ethis, "Invoke", varMsgName, expMethodLocation, methodParams); if (!isVoid) method.Statements.Add (new CodeMethodReturnStatement (new CodeCastExpression (method.ReturnType, inv))); else method.Statements.Add (inv); // Begin Invoke Call CodeExpression expCallb = new CodeVariableReferenceExpression (varCallback); CodeExpression expAsyncs = new CodeVariableReferenceExpression (varAsyncState); inv = new CodeMethodInvokeExpression (ethis, "BeginInvoke", varMsgName, expMethodLocation, methodParams, expCallb, expAsyncs); methodBegin.Statements.Add (new CodeMethodReturnStatement (inv)); // End Invoke call CodeExpression varAsyncr = new CodeVariableReferenceExpression (varAsyncResult); inv = new CodeMethodInvokeExpression (ethis, "EndInvoke", varAsyncr); if (!isVoid) methodEnd.Statements.Add (new CodeMethodReturnStatement (new CodeCastExpression (methodEnd.ReturnType, inv))); else methodEnd.Statements.Add (inv); // Attributes CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Web.Services.Protocols.HttpMethodAttribute"); att.Arguments.Add (new CodeAttributeArgument (new CodeTypeOfExpression(GetOutMimeFormatter ()))); att.Arguments.Add (new CodeAttributeArgument (new CodeTypeOfExpression(GetInMimeFormatter ()))); AddCustomAttribute (method, att, true); CodeTypeDeclaration.Members.Add (method); CodeTypeDeclaration.Members.Add (methodBegin); CodeTypeDeclaration.Members.Add (methodEnd); return method; }
CodeMemberMethod GenerateMethod (CodeIdentifiers memberIds, SoapOperationBinding soapOper, SoapBodyBinding bodyBinding, XmlMembersMapping inputMembers, XmlMembersMapping outputMembers) { CodeIdentifiers pids = new CodeIdentifiers (); CodeMemberMethod method = new CodeMemberMethod (); CodeMemberMethod methodBegin = new CodeMemberMethod (); CodeMemberMethod methodEnd = new CodeMemberMethod (); method.Attributes = MemberAttributes.Public | MemberAttributes.Final; methodBegin.Attributes = MemberAttributes.Public | MemberAttributes.Final; methodEnd.Attributes = MemberAttributes.Public | MemberAttributes.Final; SoapBindingStyle style = soapOper.Style != SoapBindingStyle.Default ? soapOper.Style : soapBinding.Style; // Find unique names for temporary variables for (int n=0; n<inputMembers.Count; n++) pids.AddUnique (inputMembers[n].MemberName, inputMembers[n]); if (outputMembers != null) for (int n=0; n<outputMembers.Count; n++) pids.AddUnique (outputMembers[n].MemberName, outputMembers[n]); string varAsyncResult = pids.AddUnique ("asyncResult","asyncResult"); string varResults = pids.AddUnique ("results","results"); string varCallback = pids.AddUnique ("callback","callback"); string varAsyncState = pids.AddUnique ("asyncState","asyncState"); string messageName = memberIds.AddUnique(CodeIdentifier.MakeValid(Operation.Name),method); method.Name = CodeIdentifier.MakeValid(Operation.Name); if (method.Name == ClassName) method.Name += "1"; methodBegin.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("Begin" + method.Name),method); methodEnd.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("End" + method.Name),method); method.ReturnType = new CodeTypeReference (typeof(void)); methodEnd.ReturnType = new CodeTypeReference (typeof(void)); methodEnd.Parameters.Add (new CodeParameterDeclarationExpression (typeof (IAsyncResult),varAsyncResult)); CodeExpression[] paramArray = new CodeExpression [inputMembers.Count]; CodeParameterDeclarationExpression[] outParams = new CodeParameterDeclarationExpression [outputMembers != null ? outputMembers.Count : 0]; for (int n=0; n<inputMembers.Count; n++) { CodeParameterDeclarationExpression param = GenerateParameter (inputMembers[n], FieldDirection.In); method.Parameters.Add (param); GenerateMemberAttributes (inputMembers, inputMembers[n], bodyBinding.Use, param); methodBegin.Parameters.Add (GenerateParameter (inputMembers[n], FieldDirection.In)); paramArray [n] = new CodeVariableReferenceExpression (param.Name); } if (outputMembers != null) { bool hasReturn = false; for (int n=0; n<outputMembers.Count; n++) { CodeParameterDeclarationExpression cpd = GenerateParameter (outputMembers[n], FieldDirection.Out); outParams [n] = cpd; bool found = false; foreach (CodeParameterDeclarationExpression ip in method.Parameters) { if (ip.Name == cpd.Name && ip.Type.BaseType == cpd.Type.BaseType) { ip.Direction = FieldDirection.Ref; methodEnd.Parameters.Add (GenerateParameter (outputMembers[n], FieldDirection.Out)); found = true; break; } } if (found) continue; if (!hasReturn) { hasReturn = true; method.ReturnType = cpd.Type; methodEnd.ReturnType = cpd.Type; GenerateReturnAttributes (outputMembers, outputMembers[n], bodyBinding.Use, method); outParams [n] = null; continue; } method.Parameters.Add (cpd); GenerateMemberAttributes (outputMembers, outputMembers[n], bodyBinding.Use, cpd); methodEnd.Parameters.Add (GenerateParameter (outputMembers[n], FieldDirection.Out)); } } methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (AsyncCallback),varCallback)); methodBegin.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object),varAsyncState)); methodBegin.ReturnType = new CodeTypeReference (typeof(IAsyncResult)); // Array of input parameters CodeArrayCreateExpression methodParams; if (paramArray.Length > 0) methodParams = new CodeArrayCreateExpression (typeof(object), paramArray); else methodParams = new CodeArrayCreateExpression (typeof(object), 0); // Assignment of output parameters CodeStatementCollection outAssign = new CodeStatementCollection (); CodeVariableReferenceExpression arrVar = new CodeVariableReferenceExpression (varResults); for (int n=0; n<outParams.Length; n++) { CodeExpression index = new CodePrimitiveExpression (n); if (outParams[n] == null) { CodeExpression res = new CodeCastExpression (method.ReturnType, new CodeArrayIndexerExpression (arrVar, index)); outAssign.Add (new CodeMethodReturnStatement (res)); } else { CodeExpression res = new CodeCastExpression (outParams[n].Type, new CodeArrayIndexerExpression (arrVar, index)); CodeExpression var = new CodeVariableReferenceExpression (outParams[n].Name); outAssign.Insert (0, new CodeAssignStatement (var, res)); } } if (Style == ServiceDescriptionImportStyle.Client) { // Invoke call CodeThisReferenceExpression ethis = new CodeThisReferenceExpression(); CodePrimitiveExpression varMsgName = new CodePrimitiveExpression (messageName); CodeMethodInvokeExpression inv; CodeVariableDeclarationStatement dec; inv = new CodeMethodInvokeExpression (ethis, "Invoke", varMsgName, methodParams); if (outputMembers != null && outputMembers.Count > 0) { dec = new CodeVariableDeclarationStatement (typeof(object[]), varResults, inv); method.Statements.Add (dec); method.Statements.AddRange (outAssign); } else method.Statements.Add (inv); // Begin Invoke Call CodeExpression expCallb = new CodeVariableReferenceExpression (varCallback); CodeExpression expAsyncs = new CodeVariableReferenceExpression (varAsyncState); inv = new CodeMethodInvokeExpression (ethis, "BeginInvoke", varMsgName, methodParams, expCallb, expAsyncs); methodBegin.Statements.Add (new CodeMethodReturnStatement (inv)); // End Invoke call CodeExpression varAsyncr = new CodeVariableReferenceExpression (varAsyncResult); inv = new CodeMethodInvokeExpression (ethis, "EndInvoke", varAsyncr); if (outputMembers != null && outputMembers.Count > 0) { dec = new CodeVariableDeclarationStatement (typeof(object[]), varResults, inv); methodEnd.Statements.Add (dec); methodEnd.Statements.AddRange (outAssign); } else methodEnd.Statements.Add (inv); } else { method.Attributes = MemberAttributes.Public | MemberAttributes.Abstract; } // Attributes ImportHeaders (method); CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Web.Services.WebMethodAttribute"); if (messageName != method.Name) att.Arguments.Add (GetArg ("MessageName",messageName)); AddCustomAttribute (method, att, (Style == ServiceDescriptionImportStyle.Server)); if (style == SoapBindingStyle.Rpc) { att = new CodeAttributeDeclaration ("System.Web.Services.Protocols.SoapRpcMethodAttribute"); att.Arguments.Add (GetArg (soapOper.SoapAction)); if (inputMembers.ElementName != method.Name) att.Arguments.Add (GetArg ("RequestElementName", inputMembers.ElementName)); if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response")) att.Arguments.Add (GetArg ("ResponseElementName", outputMembers.ElementName)); att.Arguments.Add (GetArg ("RequestNamespace", inputMembers.Namespace)); if (outputMembers != null) att.Arguments.Add (GetArg ("ResponseNamespace", outputMembers.Namespace)); if (outputMembers == null) att.Arguments.Add (GetArg ("OneWay", true)); } else { if (outputMembers != null && (inputMembers.ElementName == "" && outputMembers.ElementName != "" || inputMembers.ElementName != "" && outputMembers.ElementName == "")) throw new InvalidOperationException ("Parameter style is not the same for the input message and output message"); att = new CodeAttributeDeclaration ("System.Web.Services.Protocols.SoapDocumentMethodAttribute"); att.Arguments.Add (GetArg (soapOper.SoapAction)); if (inputMembers.ElementName != "") { if (inputMembers.ElementName != method.Name) att.Arguments.Add (GetArg ("RequestElementName", inputMembers.ElementName)); if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response")) att.Arguments.Add (GetArg ("ResponseElementName", outputMembers.ElementName)); att.Arguments.Add (GetArg ("RequestNamespace", inputMembers.Namespace)); if (outputMembers != null) att.Arguments.Add (GetArg ("ResponseNamespace", outputMembers.Namespace)); att.Arguments.Add (GetEnumArg ("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Wrapped")); } else att.Arguments.Add (GetEnumArg ("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Bare")); if (outputMembers == null) att.Arguments.Add (GetArg ("OneWay", true)); att.Arguments.Add (GetEnumArg ("Use", "System.Web.Services.Description.SoapBindingUse", bodyBinding.Use.ToString())); } AddCustomAttribute (method, att, true); CodeTypeDeclaration.Members.Add (method); if (Style == ServiceDescriptionImportStyle.Client) { CodeTypeDeclaration.Members.Add (methodBegin); CodeTypeDeclaration.Members.Add (methodEnd); } return method; }
private void GenerateInternalTypeHelperImplementation() { if (!IsInternalAccessSupported || !(HasInternals || HasLocalReference) || _hasGeneratedInternalTypeHelper) { return; } _hasGeneratedInternalTypeHelper = true; // namespace XamlGeneratedNamespace // { // CodeNamespace cns = new CodeNamespace(); cns.Name = XamlTypeMapper.GeneratedNamespace; // [EditorBrowsable(EditorBrowsableState.Never)] // public sealed class GeneratedInternalTypeHelper : InternalTypeHelper // { // CodeTypeDeclaration ctdClass = new CodeTypeDeclaration(); ctdClass.Name = XamlTypeMapper.GeneratedInternalTypeHelperClassName; ctdClass.BaseTypes.Add(new CodeTypeReference("System.Windows.Markup.InternalTypeHelper")); ctdClass.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed; AddDebuggerNonUserCodeAttribute(ctdClass); AddGeneratedCodeAttribute(ctdClass); AddEditorBrowsableAttribute(ctdClass); GenerateXmlComments(ctdClass, ctdClass.Name); // protected override object CreateInstance(Type type, CultureInfo culture) // { // return Activator.CreateInstance(type, // BindingFlags.Public | // BindingFlags.NonPublic | // BindingFlags.Instance | // BindingFlags.CreateInstance, // null, // null, // culture); // } // CodeMemberMethod cmmCI = new CodeMemberMethod(); cmmCI.Name = "CreateInstance"; cmmCI.Attributes = MemberAttributes.Family | MemberAttributes.Override; cmmCI.ReturnType = new CodeTypeReference(typeof(Object)); CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(Type), TYPE); CodeParameterDeclarationExpression param4 = new CodeParameterDeclarationExpression(typeof(CultureInfo), CULTURE); cmmCI.Parameters.Add(param1); cmmCI.Parameters.Add(param4); CodeMethodReferenceExpression cmreCI = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Activator)), "CreateInstance"); CodeMethodInvokeExpression cmieCI = new CodeMethodInvokeExpression(); cmieCI.Method = cmreCI; cmieCI.Parameters.Add(new CodeArgumentReferenceExpression(TYPE)); CodeFieldReferenceExpression cfre1 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "Public"); CodeFieldReferenceExpression cfre2 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "NonPublic"); CodeFieldReferenceExpression cfre3 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "Instance"); CodeFieldReferenceExpression cfre4 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "CreateInstance"); CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(cfre1, CodeBinaryOperatorType.BitwiseOr, cfre2); CodeBinaryOperatorExpression cboe2 = new CodeBinaryOperatorExpression(cfre3, CodeBinaryOperatorType.BitwiseOr, cfre4); CodeBinaryOperatorExpression cboeCI = new CodeBinaryOperatorExpression(cboe1, CodeBinaryOperatorType.BitwiseOr, cboe2); cmieCI.Parameters.Add(cboeCI); cmieCI.Parameters.Add(new CodePrimitiveExpression(null)); cmieCI.Parameters.Add(new CodePrimitiveExpression(null)); cmieCI.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE)); cmmCI.Statements.Add(new CodeMethodReturnStatement(cmieCI)); GenerateXmlComments(cmmCI, cmmCI.Name); ctdClass.Members.Add(cmmCI); // protected override object GetPropertyValue(PropertyInfo propertyInfo, object target, CultureInfo culture) // { // return propertyInfo.GetValue(target, BindingFlags.Default, null, null, culture); // } // CodeMemberMethod cmmGPV = new CodeMemberMethod(); cmmGPV.Name = "GetPropertyValue"; cmmGPV.Attributes = MemberAttributes.Family | MemberAttributes.Override; cmmGPV.ReturnType = new CodeTypeReference(typeof(Object)); param1 = new CodeParameterDeclarationExpression(typeof(PropertyInfo), PROPINFO); CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(typeof(object), TARGET); cmmGPV.Parameters.Add(param1); cmmGPV.Parameters.Add(param2); cmmGPV.Parameters.Add(param4); CodeMethodReferenceExpression cmreGPV = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(PROPINFO), "GetValue"); CodeMethodInvokeExpression cmieGPV = new CodeMethodInvokeExpression(); cmieGPV.Method = cmreGPV; cmieGPV.Parameters.Add(new CodeArgumentReferenceExpression(TARGET)); cmieGPV.Parameters.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), DEFAULT)); cmieGPV.Parameters.Add(new CodePrimitiveExpression(null)); cmieGPV.Parameters.Add(new CodePrimitiveExpression(null)); cmieGPV.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE)); cmmGPV.Statements.Add(new CodeMethodReturnStatement(cmieGPV)); GenerateXmlComments(cmmGPV, cmmGPV.Name); ctdClass.Members.Add(cmmGPV); // protected override void SetPropertyValue(PropertyInfo propertyInfo, object target, object value, CultureInfo culture) // { // propertyInfo.SetValue(target, value, BindingFlags.Default, null, null, culture); // } // CodeMemberMethod cmmSPV = new CodeMemberMethod(); cmmSPV.Name = "SetPropertyValue"; cmmSPV.Attributes = MemberAttributes.Family | MemberAttributes.Override; CodeParameterDeclarationExpression param3 = new CodeParameterDeclarationExpression(typeof(object), VALUE); cmmSPV.Parameters.Add(param1); cmmSPV.Parameters.Add(param2); cmmSPV.Parameters.Add(param3); cmmSPV.Parameters.Add(param4); CodeMethodReferenceExpression cmreSPV = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(PROPINFO), "SetValue"); CodeMethodInvokeExpression cmieSPV = new CodeMethodInvokeExpression(); cmieSPV.Method = cmreSPV; cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(TARGET)); cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(VALUE)); cmieSPV.Parameters.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), DEFAULT)); cmieSPV.Parameters.Add(new CodePrimitiveExpression(null)); cmieSPV.Parameters.Add(new CodePrimitiveExpression(null)); cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE)); cmmSPV.Statements.Add(new CodeExpressionStatement(cmieSPV)); GenerateXmlComments(cmmSPV, cmmSPV.Name); ctdClass.Members.Add(cmmSPV); // protected override Delegate CreateDelegate(Type delegateType, object target, string handler) // { // return (Delegate)target.GetType().InvokeMember("_CreateDelegate", // BindingFlags.Instance | // BindingFlags.NonPublic | // BindingFlags.InvokeMethod, // null, // target, // new object[] { delegateType, handler }); // } // CodeMemberMethod cmmCD = new CodeMemberMethod(); cmmCD.Name = "CreateDelegate"; cmmCD.Attributes = MemberAttributes.Family | MemberAttributes.Override; cmmCD.ReturnType = new CodeTypeReference(typeof(Delegate)); param1 = new CodeParameterDeclarationExpression(typeof(Type), DELEGATETYPE); param3 = new CodeParameterDeclarationExpression(typeof(string), HANDLERARG); cmmCD.Parameters.Add(param1); cmmCD.Parameters.Add(param2); cmmCD.Parameters.Add(param3); CodeArgumentReferenceExpression careTarget = new CodeArgumentReferenceExpression(TARGET); CodeMethodReferenceExpression cmreGetType = new CodeMethodReferenceExpression(careTarget, "GetType"); CodeMethodInvokeExpression cmieGetType = new CodeMethodInvokeExpression(); cmieGetType.Method = cmreGetType; CodeMethodReferenceExpression cmreCD = new CodeMethodReferenceExpression(cmieGetType, "InvokeMember"); CodeMethodInvokeExpression cmieCD = new CodeMethodInvokeExpression(); cmieCD.Method = cmreCD; cmieCD.Parameters.Add(new CodePrimitiveExpression(CREATEDELEGATEHELPER)); CodeFieldReferenceExpression cfre5 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "InvokeMethod"); CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression(cfre2, CodeBinaryOperatorType.BitwiseOr, cfre3); CodeBinaryOperatorExpression cboeCD = new CodeBinaryOperatorExpression(cfre5, CodeBinaryOperatorType.BitwiseOr, cboe); cmieCD.Parameters.Add(cboeCD); cmieCD.Parameters.Add(new CodePrimitiveExpression(null)); cmieCD.Parameters.Add(careTarget); CodeArrayCreateExpression caceCD = new CodeArrayCreateExpression(typeof(object)); CodeArgumentReferenceExpression careDelType = new CodeArgumentReferenceExpression(DELEGATETYPE); CodeArgumentReferenceExpression careHandler = new CodeArgumentReferenceExpression(HANDLERARG); caceCD.Initializers.Add(careDelType); caceCD.Initializers.Add(careHandler); cmieCD.Parameters.Add(caceCD); cmieCD.Parameters.Add(new CodePrimitiveExpression(null)); CodeCastExpression cceCD = new CodeCastExpression(typeof(Delegate), cmieCD); cmmCD.Statements.Add(new CodeMethodReturnStatement(cceCD)); GenerateXmlComments(cmmCD, cmmCD.Name); ctdClass.Members.Add(cmmCD); // protected override void AddEventHandler(EventInfo eventInfo, object target, Delegate handler); // { // eventInfo.AddEventHandler(target, handler); // } // CodeMemberMethod cmmAEH = new CodeMemberMethod(); cmmAEH.Name = "AddEventHandler"; cmmAEH.Attributes = MemberAttributes.Family | MemberAttributes.Override; param1 = new CodeParameterDeclarationExpression(typeof(EventInfo), EVENTINFO); param3 = new CodeParameterDeclarationExpression(typeof(Delegate), HANDLERARG); cmmAEH.Parameters.Add(param1); cmmAEH.Parameters.Add(param2); cmmAEH.Parameters.Add(param3); CodeMethodReferenceExpression cmreAEH = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(EVENTINFO), "AddEventHandler"); CodeMethodInvokeExpression cmieAEH = new CodeMethodInvokeExpression(); cmieAEH.Method = cmreAEH; cmieAEH.Parameters.Add(new CodeArgumentReferenceExpression(TARGET)); cmieAEH.Parameters.Add(new CodeArgumentReferenceExpression(HANDLERARG)); cmmAEH.Statements.Add(new CodeExpressionStatement(cmieAEH)); GenerateXmlComments(cmmAEH, cmmAEH.Name); ctdClass.Members.Add(cmmAEH); // } // cns.Types.Add(ctdClass); // } // CodeCompileUnit ccu = new CodeCompileUnit(); ccu.Namespaces.Add(cns); // For VB only we need to let the parser know about the RootNamespace value // in order to look for the XamlGeneratedNamespace.GeneratedInternalTypeHelper // type whose full type name would have been implicitly by the VB comopiler to // RootNS.XamlGeneratedNamespace.GeneratedInternalTypeHelper if (IsLanguageVB && !string.IsNullOrEmpty(DefaultNamespace)) { // [assembly: RootNamespaceAttribute("RootNS")] CodeAttributeDeclaration cad = new CodeAttributeDeclaration( "System.Windows.Markup.RootNamespaceAttribute", new CodeAttributeArgument(new CodePrimitiveExpression(DefaultNamespace))); ccu.AssemblyCustomAttributes.Add(cad); } MemoryStream codeMemStream = new MemoryStream(); // using Disposes the StreamWriter when it ends. Disposing the StreamWriter // also closes the underlying MemoryStream. Furthermore, don't add BOM here since // TaskFileService.WriteGeneratedCodeFile adds it. using (StreamWriter codeStreamWriter = new StreamWriter(codeMemStream, new UTF8Encoding(false))) { CodeGeneratorOptions o = new CodeGeneratorOptions(); CodeDomProvider codeProvider = EnsureCodeProvider(); codeProvider.GenerateCodeFromCompileUnit(ccu, codeStreamWriter, o); codeStreamWriter.Flush(); TaskFileService.WriteGeneratedCodeFile(codeMemStream.ToArray(), TargetPath + SharedStrings.GeneratedInternalTypeHelperFileName, SharedStrings.GeneratedExtension, SharedStrings.IntellisenseGeneratedExtension, LanguageSourceExtension); } }
protected override void GenerateArrayCreateExpression(CodeArrayCreateExpression e) { base.Output.Write("New "); CodeExpressionCollection initializers = e.Initializers; if (initializers.Count > 0) { string typeOutput = this.GetTypeOutput(e.CreateType); base.Output.Write(typeOutput); if (typeOutput.IndexOf('(') == -1) { base.Output.Write("()"); } base.Output.Write(" {"); base.Indent++; this.OutputExpressionList(initializers); base.Indent--; base.Output.Write("}"); } else { string str2 = this.GetTypeOutput(e.CreateType); int index = str2.IndexOf('('); if (index == -1) { base.Output.Write(str2); base.Output.Write('('); } else { base.Output.Write(str2.Substring(0, index + 1)); } if (e.SizeExpression != null) { base.Output.Write("("); base.GenerateExpression(e.SizeExpression); base.Output.Write(") - 1"); } else { base.Output.Write((int)(e.Size - 1)); } if (index == -1) { base.Output.Write(')'); } else { base.Output.Write(str2.Substring(index + 1)); } base.Output.Write(" {}"); } }
private void GenerateStrings(Property property, CodeMemberProperty propertyName) { this.GenerateCommon(property, propertyName, "String", typeof(string), "Value"); string referencedProperty = null; if (property.Values.Count > 0) { CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement("System.String[][]", "switchMap"); List<CodeExpression> list = new List<CodeExpression>(); int num = 0; CodeTypeReference createType = new CodeTypeReference(typeof(string)); foreach (Value value2 in property.Values) { if (this.ContainsCurrentPlatform(value2.SwitchName)) { CodeSnippetExpression[] initializers = new CodeSnippetExpression[2]; initializers[0] = new CodeSnippetExpression(this.SurroundWithQuotes(value2.Name)); if (value2.SwitchName != string.Empty) { initializers[1] = new CodeSnippetExpression(this.SurroundWithQuotes(value2.Prefix + value2.SwitchName)); } else { initializers[1] = new CodeSnippetExpression(this.SurroundWithQuotes("")); } CodeArrayCreateExpression item = new CodeArrayCreateExpression(createType, initializers); list.Add(item); num++; } } CodeArrayCreateExpression expression2 = new CodeArrayCreateExpression("System.String[][]", list.ToArray()); statement.InitExpression = expression2; propertyName.SetStatements.Add(statement); CodeAssignStatement statement2 = new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("switchToAdd"), "SwitchValue"), new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "ReadSwitchMap", new CodeExpression[] { new CodeSnippetExpression(this.SurroundWithQuotes(property.Name)), new CodeVariableReferenceExpression("switchMap"), new CodeVariableReferenceExpression("value") })); propertyName.SetStatements.Add(statement2); CodeAssignStatement statement3 = new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("switchToAdd"), "Name"), new CodeSnippetExpression(this.SurroundWithQuotes(property.Name))); propertyName.SetStatements.Add(statement3); referencedProperty = "Value"; this.GenerateAssignPropertyToValue(propertyName, "AllowMultipleValues", new CodeSnippetExpression("true")); } else { CodeAssignStatement statement4 = new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("switchToAdd"), "Name"), new CodeSnippetExpression(this.SurroundWithQuotes(property.Name))); propertyName.SetStatements.Add(statement4); referencedProperty = "Value"; CodeAssignStatement statement5 = new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("switchToAdd"), "SwitchValue"), (property.SwitchName != string.Empty) ? new CodeSnippetExpression(this.SurroundWithQuotes(property.Prefix + property.SwitchName)) : new CodeSnippetExpression(this.SurroundWithQuotes(""))); propertyName.SetStatements.Add(statement5); this.GenerateAssignToolSwitch(propertyName, "ReverseSwitchValue", property.Prefix, property.ReverseSwitchName); } this.GenerateCommonSetStatements(property, propertyName, referencedProperty); }
private void BuildLinkedStyleSheetMember() { CodeMemberField field = new CodeMemberField(typeof(string[]), "__linkedStyleSheets"); if ((this._themeParser.CssFileList != null) && (this._themeParser.CssFileList.Count > 0)) { CodeExpression[] initializers = new CodeExpression[this._themeParser.CssFileList.Count]; int num = 0; foreach (string str in this._themeParser.CssFileList) { initializers[num++] = new CodePrimitiveExpression(str); } CodeArrayCreateExpression expression = new CodeArrayCreateExpression(typeof(string), initializers); field.InitExpression = expression; } else { field.InitExpression = new CodePrimitiveExpression(null); } base._sourceDataClass.Members.Add(field); }
private void GenerateCodeFromCodeArrayCreateExpression(CodeArrayCreateExpression e, TextWriter w) { w.Write("@("); for (var i = 0; i < e.Initializers.Count; i++) { GenerateCodeFromExpression(e.Initializers[i], w, null); if (i < e.Initializers.Count - 1) w.Write(","); } w.Write(")"); }
private void GenerateConstructor(CodeTypeDeclaration taskClass) { CodeConstructor constructor = new CodeConstructor { Attributes = MemberAttributes.Public }; CodeTypeReference createType = new CodeTypeReference("System.Resources.ResourceManager"); CodeSnippetExpression expression = new CodeSnippetExpression(this.SurroundWithQuotes(this.taskParser.ResourceNamespace)); CodeTypeReferenceExpression targetObject = new CodeTypeReferenceExpression("System.Reflection.Assembly"); CodeMethodReferenceExpression method = new CodeMethodReferenceExpression(targetObject, "GetExecutingAssembly"); CodeMethodInvokeExpression expression4 = new CodeMethodInvokeExpression(method, new CodeExpression[0]); CodeObjectCreateExpression expression5 = new CodeObjectCreateExpression(createType, new CodeExpression[] { expression, expression4 }); CodeTypeReference reference2 = new CodeTypeReference(new CodeTypeReference("System.String"), 1); List<CodeExpression> list = new List<CodeExpression>(); foreach (string str in this.taskParser.SwitchOrderList) { list.Add(new CodeSnippetExpression(this.SurroundWithQuotes(str))); } CodeArrayCreateExpression expression6 = new CodeArrayCreateExpression(reference2, list.ToArray()); constructor.BaseConstructorArgs.Add(expression6); constructor.BaseConstructorArgs.Add(expression5); taskClass.Members.Add(constructor); if (this.GenerateComments) { constructor.Comments.Add(new CodeCommentStatement(Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("StartSummary", new object[0]), true)); string text = Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("ConstructorDescription", new object[0]); constructor.Comments.Add(new CodeCommentStatement(text, true)); constructor.Comments.Add(new CodeCommentStatement(Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("EndSummary", new object[0]), true)); } }