private CodeTypeDeclaration CreateType(string xmlName, bool includeInSchema)
{
int i = 1;
string clrName = CodeIdentifier.MakeValid(xmlName);
if (CodeTypeContains(clrName))
{
while (CodeTypeContains(clrName + i))
{
i++;
}
clrName = clrName + i;
}
CodeTypeDeclaration decl = new CodeTypeDeclaration(clrName);
if (includeInSchema)
{
if (xmlName != clrName)
{
decl.CustomAttributes.Add(CreateXmlAttribute(typeof(XmlTypeAttribute), xmlName));
}
}
else
{
CodeAttributeDeclaration xt = new CodeAttributeDeclaration(typeof(XmlTypeAttribute).FullName);
xt.Arguments.Add(new CodeAttributeArgument(
"IncludeInSchema",
new CodePrimitiveExpression(false)));
decl.CustomAttributes.Add(xt);
}
return(decl);
}
void ImportEnum(CodeTypeDeclaration td, XmlSchemaSet schemas, XmlSchemaSimpleTypeRestriction r, XmlSchemaType type, XmlQualifiedName qname, bool isFlag)
{
if (isFlag && !r.BaseTypeName.Equals(new XmlQualifiedName("string", XmlSchema.Namespace)))
{
throw new InvalidDataContractException(String.Format("For flags enumeration '{0}', the base type for the simple type restriction must be XML schema string", qname));
}
td.IsEnum = true;
AddTypeAttributes(td, type);
if (isFlag)
{
td.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(FlagsAttribute))));
}
foreach (var facet in r.Facets)
{
var e = facet as XmlSchemaEnumerationFacet;
if (e == null)
{
throw new InvalidDataContractException(String.Format("Invalid simple type restriction (type {0}). Only enumeration is allowed.", qname));
}
var em = new CodeMemberField()
{
Name = CodeIdentifier.MakeValid(e.Value)
};
var ea = new CodeAttributeDeclaration(enum_member_att_ref);
if (e.Value != em.Name)
{
ea.Arguments.Add(new CodeAttributeArgument("Value", new CodePrimitiveExpression(e.Value)));
}
em.CustomAttributes.Add(ea);
td.Members.Add(em);
}
}
void DoImport(XmlSchemaSet schemas, XmlSchemaType type, XmlQualifiedName qname)
{
CodeNamespace cns = null;
CodeTypeReference clrRef;
cns = GetCodeNamespace(qname);
clrRef = new CodeTypeReference(cns.Name.Length > 0 ? cns.Name + "." + qname.Name : qname.Name);
var td = new CodeTypeDeclaration()
{
Name = GetUniqueName(CodeIdentifier.MakeValid(qname.Name), cns),
TypeAttributes = GenerateInternal ? TypeAttributes.NotPublic : TypeAttributes.Public
};
cns.Types.Add(td);
var info = new TypeImportInfo()
{
ClrType = clrRef, XsdType = type, XsdTypeName = qname
};
imported_types.Add(info);
var st = type as XmlSchemaSimpleType;
if (st != null)
{
ImportSimpleType(td, schemas, st, qname);
}
else
{
var ct = (XmlSchemaComplexType)type;
var sc = ct.ContentModel as XmlSchemaSimpleContent;
if (sc != null)
{
if (sc.Content is XmlSchemaSimpleContentExtension)
{
throw new InvalidDataContractException(String.Format("complex type '{0}' with simple content extension is not supported", type.QualifiedName));
}
}
if (!ImportComplexType(td, schemas, ct, qname))
{
cns.Types.Remove(td);
if (cns.Types.Count == 0)
{
CodeCompileUnit.Namespaces.Remove(cns);
}
}
foreach (var impinfo in imported_types)
{
for (; impinfo.KnownTypeOutputIndex < impinfo.KnownClrTypes.Count; impinfo.KnownTypeOutputIndex++)
{
td.CustomAttributes.Add(new CodeAttributeDeclaration(
new CodeTypeReference(typeof(KnownTypeAttribute)),
new CodeAttributeArgument(new CodeTypeOfExpression(impinfo.KnownClrTypes [impinfo.KnownTypeOutputIndex]))));
}
}
}
}
public void ValidateWithExceptions()
{
if (MemSize <= 0)
{
throw new Exception("Invalid memSize, must be greater than 0!");
}
if (MemType != "byte" && MemType != "int" && MemType != "long")
{
throw new Exception($"Invalid memType '{MemType}'! Valid types are byte, int, long");
}
if (!EoFValue.Equals("same", StringComparison.OrdinalIgnoreCase) &&
!(MemType == "byte" && byte.TryParse(EoFValue, out byte _)) &&
!(MemType == "int" && int.TryParse(EoFValue, out int _)) &&
!(MemType == "long" && long.TryParse(EoFValue, out long _)))
{
throw new Exception($"Invalid eofValue '{EoFValue}'! Does it match the memType '{MemType}'?");
}
if (CodeIdentifier.MakeValid(ClassName) != ClassName)
{
throw new Exception($"Invalid class name '{ClassName}'!");
}
}
internal static CodeTypeDeclaration CreateClassDeclaration(XmlSchemaType type)
{
string className = CodeIdentifier.MakeValid(type.QualifiedName.Name);
CodeTypeDeclaration codeClass = new CodeTypeDeclaration(className);
codeClass.TypeAttributes |= TypeAttributes.Public;
return(codeClass);
}
MimeParameter ImportUrlParameter(MessagePart part)
{
// CONSIDER, check to see that it's a primitive type
MimeParameter parameter = new MimeParameter();
parameter.Name = CodeIdentifier.MakeValid(part.Name);
parameter.TypeName = IsRepeatingParameter(part) ? typeof(string[]).FullName : typeof(string).FullName;
return(parameter);
}
public static string MakeValidIdentifier(string identifierName)
{
identifierName = CodeIdentifier.MakeValid(identifierName);
if (isKeyword(identifierName))
{
return("@" + identifierName);
}
return(identifierName);
}
MimeParameter ImportUrlParameter(MessagePart part)
{
//
MimeParameter parameter = new MimeParameter();
parameter.Name = CodeIdentifier.MakeValid(XmlConvert.DecodeName(part.Name));
parameter.TypeName = IsRepeatingParameter(part) ? typeof(string[]).FullName : typeof(string).FullName;
return(parameter);
}
static void GenerateComponentCode(object component, SteticCompilationUnit globalUnit, CodeNamespace globalNs, CodeExpression cobj, CodeStatementCollection statements, CodeTypeDeclaration globalType, GenerationOptions options, List <SteticCompilationUnit> units, CodeIdentifiers ids, ArrayList warnings)
{
Gtk.Widget widget = component as Gtk.Widget;
Wrapper.Widget wwidget = Stetic.Wrapper.Widget.Lookup(widget);
Wrapper.ActionGroup agroup = component as Wrapper.ActionGroup;
string name = widget != null ? widget.Name : agroup.Name;
string internalClassName = ids.MakeUnique(CodeIdentifier.MakeValid(name));
string typeName = widget != null ? wwidget.WrappedTypeName : "Gtk.ActionGroup";
// Create the build method for the top level
CodeMemberMethod met;
met = GetBuildMethod(name, internalClassName, typeName, globalUnit, options, units);
// Generate the build code
CodeVariableDeclarationStatement varDecHash = new CodeVariableDeclarationStatement(typeof(System.Collections.Hashtable), "bindings");
met.Statements.Add(varDecHash);
varDecHash.InitExpression = new CodeObjectCreateExpression(
typeof(System.Collections.Hashtable),
new CodeExpression [0]
);
CodeVariableReferenceExpression targetObjectVar = new CodeVariableReferenceExpression("cobj");
Stetic.WidgetMap map;
if (widget != null)
{
map = Stetic.CodeGenerator.GenerateCreationCode(globalNs, globalType, widget, targetObjectVar, met.Statements, options, warnings);
CodeGenerator.BindSignalHandlers(targetObjectVar, wwidget, map, met.Statements, options);
}
else
{
map = Stetic.CodeGenerator.GenerateCreationCode(globalNs, globalType, agroup, targetObjectVar, met.Statements, options, warnings);
foreach (Wrapper.Action ac in agroup.Actions)
{
CodeGenerator.BindSignalHandlers(targetObjectVar, ac, map, met.Statements, options);
}
}
GenerateBindFieldCode(met.Statements, cobj);
// Add a method call to the build method
statements.Add(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(options.GlobalNamespace + ".SteticGenerated." + internalClassName),
"Build",
new CodeCastExpression(typeName, cobj)
)
);
}
string MakeStringNamespaceComponentsValid(string ns)
{
var arr = ns.Split(split_tokens, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < arr.Length; i++)
{
arr [i] = CodeIdentifier.MakeValid(arr [i]);
}
return(String.Join(".", arr));
}
void DoImport(XmlSchemaSet schemas, XmlSchemaType type, XmlQualifiedName qname)
{
CodeNamespace cns = null;
CodeTypeReference clrRef;
cns = GetCodeNamespace(qname);
clrRef = new CodeTypeReference(cns.Name.Length > 0 ? cns.Name + "." + qname.Name : qname.Name);
var td = new CodeTypeDeclaration();
td.Name = CodeIdentifier.MakeValid(qname.Name);
cns.Types.Add(td);
var info = new TypeImportInfo()
{
ClrType = clrRef, XsdType = type, XsdTypeName = qname
};
imported_types.Add(info);
var st = type as XmlSchemaSimpleType;
if (st != null)
{
ImportSimpleType(td, schemas, st, qname);
}
else
{
var ct = (XmlSchemaComplexType)type;
var sc = ct.ContentModel as XmlSchemaSimpleContent;
if (sc != null)
{
if (sc.Content is XmlSchemaSimpleContentExtension)
{
throw new InvalidDataContractException(String.Format("complex type '{0}' with simple content extension is not supported", type.QualifiedName));
}
}
if (!ImportComplexType(td, schemas, ct, qname))
{
cns.Types.Remove(td);
if (cns.Types.Count == 0)
{
CodeCompileUnit.Namespaces.Remove(cns);
}
}
}
}
internal override MimeReturn ImportReturn()
{
MimeTextBinding binding = (MimeTextBinding)base.ImportContext.OperationBinding.Output.Extensions.Find(typeof(MimeTextBinding));
if (binding == null)
{
return(null);
}
if (binding.Matches.Count == 0)
{
base.ImportContext.UnsupportedOperationBindingWarning(Res.GetString("MissingMatchElement0"));
return(null);
}
this.methodName = CodeIdentifier.MakeValid(base.ImportContext.OperationBinding.Name);
return(new MimeTextReturn {
TypeName = base.ImportContext.ClassNames.AddUnique(this.methodName + "Matches", binding), TextBinding = binding, ReaderType = typeof(TextReturnReader)
});
}
public static string MakeValidIdentifier(string identifierName, bool nameMangler2)
{
string str;
if (!nameMangler2)
{
identifierName = CodeIdentifier.MakeValid(identifierName);
}
else
{
if (char.IsDigit(identifierName[0]))
{
identifierName = string.Concat("_", identifierName);
}
identifierName = identifierName.Replace('.', '\u005F').Replace('-', '\u005F');
}
str = (!NameGenerator.isKeyword(identifierName) ? identifierName : string.Concat("@", identifierName));
return(str);
}
public static string MakeValidIdentifier(string identifierName, bool nameMangler2)
{
if (nameMangler2)
{
if (System.Char.IsDigit(identifierName[0]))
{
identifierName = "_" + identifierName;
}
identifierName = identifierName.Replace('.', '_').Replace('-', '_');
}
else
{
identifierName = CodeIdentifier.MakeValid(identifierName);
}
if (isKeyword(identifierName))
{
return("@" + identifierName);
}
return(identifierName);
}
internal override MimeReturn ImportReturn()
{
MimeTextBinding mimeTextBinding = (MimeTextBinding)ImportContext.OperationBinding.Output.Extensions.Find(typeof(MimeTextBinding));
if (mimeTextBinding == null)
{
return(null);
}
if (mimeTextBinding.Matches.Count == 0)
{
ImportContext.UnsupportedOperationBindingWarning(Res.GetString(Res.MissingMatchElement0));
return(null);
}
methodName = CodeIdentifier.MakeValid(ImportContext.OperationBinding.Name);
MimeTextReturn importedReturn = new MimeTextReturn();
importedReturn.TypeName = ImportContext.ClassNames.AddUnique(methodName + "Matches", mimeTextBinding);
importedReturn.TextBinding = mimeTextBinding;
importedReturn.ReaderType = typeof(TextReturnReader);
return(importedReturn);
}
internal string GenerateBaseSerializer(string baseSerializer, string readerClass, string writerClass, CodeIdentifiers classes)
{
baseSerializer = CodeIdentifier.MakeValid(baseSerializer);
baseSerializer = classes.AddUnique(baseSerializer, baseSerializer);
_writer.WriteLine();
_writer.Write("public abstract class ");
_writer.Write(CodeIdentifier.GetCSharpName(baseSerializer));
_writer.Write(" : ");
_writer.Write(typeof(XmlSerializer).FullName);
_writer.WriteLine(" {");
_writer.Indent++;
_writer.Write("protected override ");
_writer.Write(typeof(XmlSerializationReader).FullName);
_writer.WriteLine(" CreateReader() {");
_writer.Indent++;
_writer.Write("return new ");
_writer.Write(readerClass);
_writer.WriteLine("();");
_writer.Indent--;
_writer.WriteLine("}");
_writer.Write("protected override ");
_writer.Write(typeof(XmlSerializationWriter).FullName);
_writer.WriteLine(" CreateWriter() {");
_writer.Indent++;
_writer.Write("return new ");
_writer.Write(writerClass);
_writer.WriteLine("();");
_writer.Indent--;
_writer.WriteLine("}");
_writer.Indent--;
_writer.WriteLine("}");
return(baseSerializer);
}
void AddProperty(CodeTypeDeclaration td, XmlSchemaElement xe)
{
var att = GenerateInternal ? MemberAttributes.Assembly : MemberAttributes.Public;
var fi = new CodeMemberField()
{
Name = CodeIdentifier.MakeValid(xe.QualifiedName.Name + "Field"), Type = GetCodeTypeReference(xe.ElementSchemaType.QualifiedName, xe)
};
td.Members.Add(fi);
var pi = new CodeMemberProperty()
{
Name = xe.QualifiedName.Name, Attributes = att, HasGet = true, HasSet = true, Type = fi.Type
};
// [DataMember(Name=foobar, IsRequired=!nillable)]
var dma = new CodeAttributeDeclaration(
new CodeTypeReference(typeof(DataMemberAttribute)));
if (fi.Name != xe.QualifiedName.Name)
{
new CodeAttributeArgument("Name", new CodePrimitiveExpression(xe.QualifiedName.Name));
}
if (!xe.IsNillable)
{
new CodeAttributeArgument("IsRequired", new CodePrimitiveExpression(true));
}
pi.CustomAttributes.Add(dma);
pi.GetStatements.Add(new CodeMethodReturnStatement()
{
Expression = new CodeFieldReferenceExpression(this_expr, fi.Name)
});
pi.SetStatements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(this_expr, fi.Name), arg_value_expr));
td.Members.Add(pi);
}
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);
}
void ImportHeader(CodeMemberMethod method, SoapHeaderBinding hb, SoapHeaderDirection direction)
{
Message msg = ServiceDescriptions.GetMessage(hb.Message);
if (msg == null)
{
throw new InvalidOperationException("Message " + hb.Message + " not found");
}
MessagePart part = msg.Parts [hb.Part];
if (part == null)
{
throw new InvalidOperationException("Message part " + hb.Part + " not found in message " + hb.Message);
}
XmlTypeMapping map;
string hname;
if (hb.Use == SoapBindingUse.Literal)
{
map = xmlImporter.ImportDerivedTypeMapping(part.Element, typeof(SoapHeader));
hname = part.Element.Name;
xmlExporter.ExportTypeMapping(map);
}
else
{
map = soapImporter.ImportDerivedTypeMapping(part.Type, typeof(SoapHeader), true);
hname = part.Type.Name;
soapExporter.ExportTypeMapping(map);
}
string varName = headerVariables [map] as string;
if (varName == null)
{
if (hname == map.TypeName)
{
varName = memberIds.AddUnique(CodeIdentifier.MakeValid(hname + "Value"), hb);
}
else
{
varName = memberIds.AddUnique(CodeIdentifier.MakeValid(hname), hb);
}
#if NET_2_0
string propName = varName;
varName = varName + "Field";
#endif
headerVariables.Add(map, varName);
CodeMemberField codeField = new CodeMemberField(map.TypeFullName, varName);
CodeTypeDeclaration.Members.Add(codeField);
#if NET_2_0
codeField.Attributes = MemberAttributes.Private;
CodeMemberProperty codeProperty = new CodeMemberProperty();
codeProperty.Name = propName;
codeProperty.Type = new CodeTypeReference(map.TypeFullName);
codeProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final;
codeProperty.HasGet = codeProperty.HasSet = true;
CodeExpression ce = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), varName);
codeProperty.SetStatements.Add(new CodeAssignStatement(ce, new CodePropertySetValueReferenceExpression()));
codeProperty.GetStatements.Add(new CodeMethodReturnStatement(ce));
CodeTypeDeclaration.Members.Add(codeProperty);
varName = propName;
#else
codeField.Attributes = MemberAttributes.Public;
#endif
}
CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Web.Services.Protocols.SoapHeaderAttribute");
att.Arguments.Add(GetArg(varName));
#if ONLY_1_0
att.Arguments.Add(GetArg("Required", false));
#endif
if (direction != SoapHeaderDirection.In)
{
att.Arguments.Add(GetEnumArg("Direction", "System.Web.Services.Protocols.SoapHeaderDirection", direction.ToString()));
}
AddCustomAttribute(method, att, true);
}
void ImportPortBinding(bool multipleBindings)
{
if (port != null)
{
if (multipleBindings)
{
className = binding.Name;
}
else
{
className = service.Name;
}
}
else
{
className = binding.Name;
}
className = classNames.AddUnique(CodeIdentifier.MakeValid(className), port);
className = className.Replace("_x0020_", ""); // MS.NET seems to do this
try
{
portType = ServiceDescriptions.GetPortType(binding.Type);
if (portType == null)
{
throw new Exception("Port type not found: " + binding.Type);
}
CodeTypeDeclaration codeClass = BeginClass();
codeTypeDeclaration = codeClass;
AddCodeType(codeClass, port != null ? port.Documentation : null);
codeClass.Attributes = MemberAttributes.Public;
if (service != null && service.Documentation != null && service.Documentation != "")
{
AddComments(codeClass, service.Documentation);
}
if (Style == ServiceDescriptionImportStyle.Client)
{
CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Diagnostics.DebuggerStepThroughAttribute");
AddCustomAttribute(codeClass, att, true);
att = new CodeAttributeDeclaration("System.ComponentModel.DesignerCategoryAttribute");
att.Arguments.Add(GetArg("code"));
AddCustomAttribute(codeClass, att, true);
}
else
{
codeClass.TypeAttributes = System.Reflection.TypeAttributes.Abstract | System.Reflection.TypeAttributes.Public;
}
if (binding.Operations.Count == 0)
{
warnings |= ServiceDescriptionImportWarnings.NoMethodsGenerated;
return;
}
foreach (OperationBinding oper in binding.Operations)
{
operationBinding = oper;
operation = FindPortOperation();
if (operation == null)
{
throw new Exception("Operation " + operationBinding.Name + " not found in portType " + PortType.Name);
}
inputMessage = null;
outputMessage = null;
foreach (OperationMessage omsg in operation.Messages)
{
Message msg = ServiceDescriptions.GetMessage(omsg.Message);
if (msg == null)
{
throw new Exception("Message not found: " + omsg.Message);
}
if (omsg is OperationInput)
{
inputMessage = msg;
}
else
{
outputMessage = msg;
}
}
CodeMemberMethod method = GenerateMethod();
if (method != null)
{
methodName = method.Name;
if (operation.Documentation != null && operation.Documentation != "")
{
AddComments(method, operation.Documentation);
}
#if NET_2_0
if (Style == ServiceDescriptionImportStyle.Client)
{
AddAsyncMembers(method.Name, method);
}
#endif
}
}
#if NET_2_0
if (Style == ServiceDescriptionImportStyle.Client)
{
AddAsyncTypes();
}
#endif
EndClass();
}
catch (InvalidOperationException ex)
{
warnings |= ServiceDescriptionImportWarnings.NoCodeGenerated;
UnsupportedBindingWarning(ex.Message);
}
}
// Returns false if it should remove the imported type.
// FIXME: also support ImportXmlType
bool ImportComplexType(CodeTypeDeclaration td, XmlSchemaSet schemas, XmlSchemaComplexType type, XmlQualifiedName qname)
{
foreach (XmlSchemaAttribute att in type.AttributeUses.Values)
{
if (att.Use != XmlSchemaUse.Optional || att.QualifiedName.Namespace != KnownTypeCollection.MSSimpleNamespace)
{
throw new InvalidDataContractException(String.Format("attribute in DataContract complex type '{0}' is limited to those in {1} namespace, and optional.", qname, KnownTypeCollection.MSSimpleNamespace));
}
}
CodeTypeReference baseClrType = null;
var particle = type.Particle;
if (type.ContentModel != null)
{
var xsscr = type.ContentModel.Content as XmlSchemaSimpleContentRestriction;
if (xsscr != null)
{
if (xsscr.BaseType != null)
{
Import(schemas, xsscr.BaseType);
}
else
{
Import(schemas, xsscr.BaseTypeName);
}
// The above will result in an error, but make sure to show we don't support it.
throw new InvalidDataContractException(String.Format("complex type simple content restriction is not supported in DataContract (type '{0}')", qname));
}
var xscce = type.ContentModel.Content as XmlSchemaComplexContentExtension;
if (xscce != null)
{
Import(schemas, xscce.BaseTypeName);
baseClrType = GetCodeTypeReferenceInternal(xscce.BaseTypeName, false);
if (baseClrType != null)
{
td.BaseTypes.Add(baseClrType);
}
var baseInfo = GetTypeInfo(xscce.BaseTypeName, false);
if (baseInfo != null)
{
baseInfo.KnownClrTypes.Add(imported_types.First(it => it.XsdType == type).ClrType);
}
particle = xscce.Particle;
}
var xsccr = type.ContentModel.Content as XmlSchemaComplexContentRestriction;
if (xsccr != null)
{
throw new InvalidDataContractException(String.Format("complex content type (for type '{0}') has a restriction content model, which is not supported in DataContract.", qname));
}
}
var seq = particle as XmlSchemaSequence;
if (seq == null && particle != null)
{
throw new InvalidDataContractException(String.Format("Not supported particle {1}. In DataContract, only sequence particle is allowed as the top-level content of a complex type (type '{0}')", qname, particle));
}
if (seq != null)
{
foreach (var child in seq.Items)
{
if (!(child is XmlSchemaElement))
{
throw new InvalidDataContractException(String.Format("Only local element is allowed as the content of the sequence of the top-level content of a complex type '{0}'. Other particles (sequence, choice, all, any, group ref) are not supported.", qname));
}
}
if (seq.Items.Count == 1)
{
var xe = (XmlSchemaElement)seq.Items [0];
if (xe.MaxOccursString == "unbounded")
{
// import as a collection contract.
if (type.QualifiedName.Namespace == KnownTypeCollection.MSArraysNamespace &&
IsPredefinedType(xe.ElementSchemaType.QualifiedName))
{
// then this CodeTypeDeclaration is to be removed, and CodeTypeReference to this type should be an array instead.
var cti = imported_types.First(i => i.XsdType == type);
cti.ClrType = new CodeTypeReference(GetCodeTypeReference(xe.ElementSchemaType.QualifiedName), 1);
return(false);
}
else
{
Import(schemas, xe.ElementSchemaType);
}
td.BaseTypes.Add(new CodeTypeReference("System.Collections.Generic.List", GetCodeTypeReference(xe.ElementSchemaType.QualifiedName)));
AddTypeAttributes(td, type, CodeIdentifier.MakeValid(xe.QualifiedName.Name));
return(true);
}
}
// import as a (normal) contract.
var elems = new List <XmlSchemaElement> ();
foreach (XmlSchemaElement xe in seq.Items)
{
if (xe.MaxOccurs != 1)
{
throw new InvalidDataContractException(String.Format("schema complex type '{0}' has a content sequence containing an element '{1}' with 'maxOccurs' value as more than 1, which is not supported in DataContract.", qname, xe.QualifiedName));
}
if (elems.Any(e => e.QualifiedName.Name == xe.QualifiedName.Name))
{
throw new InvalidDataContractException(String.Format("In schema type '{0}', there already is an element whose name is {1}, where duplicate of element names are not supported.", qname, xe.QualifiedName.Name));
}
elems.Add(xe);
}
foreach (var xe in elems)
{
// import property type in prior.
Import(schemas, xe.ElementSchemaType.QualifiedName);
AddProperty(td, xe);
}
} // if (seq != 0)
AddTypeAttributes(td, type, null);
AddExtensionData(td);
return(true);
}
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);
}
void GenerateClassForBinding()
{
try {
if (bindingCount == 1 && service != null && Style != ServiceDescriptionImportStyle.ServerInterface)
{
// If there is only one binding, then use the name of the service
className = XmlConvert.DecodeName(service.Name);
}
else
{
// If multiple bindings, then use the name of the binding
className = binding.Name;
if (Style == ServiceDescriptionImportStyle.ServerInterface)
{
// append "I" if we are generating interfaces
className = "I" + CodeIdentifier.MakePascal(className);
}
}
className = XmlConvert.DecodeName(className);
className = ClassNames.AddUnique(CodeIdentifier.MakeValid(className), null);
this.codeClass = BeginClass();
int methodCount = 0;
for (int i = 0; i < portType.Operations.Count; i++)
{
MoveToOperation(portType.Operations[i]);
if (!IsOperationFlowSupported(operation.Messages.Flow))
{
//
switch (operation.Messages.Flow)
{
case OperationFlow.SolicitResponse:
UnsupportedOperationWarning(Res.GetString(Res.SolicitResponseIsNotSupported0));
continue;
case OperationFlow.RequestResponse:
UnsupportedOperationWarning(Res.GetString(Res.RequestResponseIsNotSupported0));
continue;
case OperationFlow.OneWay:
UnsupportedOperationWarning(Res.GetString(Res.OneWayIsNotSupported0));
continue;
case OperationFlow.Notification:
UnsupportedOperationWarning(Res.GetString(Res.NotificationIsNotSupported0));
continue;
}
}
CodeMemberMethod method;
try {
method = GenerateMethod();
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
throw new InvalidOperationException(Res.GetString(Res.UnableToImportOperation1, operation.Name), e);
}
if (method != null)
{
AddExtensionWarningComments(codeClass.Comments, operationBinding.Extensions);
if (operationBinding.Input != null)
{
AddExtensionWarningComments(codeClass.Comments, operationBinding.Input.Extensions);
}
if (operationBinding.Output != null)
{
AddExtensionWarningComments(codeClass.Comments, operationBinding.Output.Extensions);
}
methodCount++;
}
}
bool newAsync = (ServiceImporter.CodeGenerationOptions & CodeGenerationOptions.GenerateNewAsync) != 0 &&
ServiceImporter.CodeGenerator.Supports(GeneratorSupport.DeclareEvents) &&
ServiceImporter.CodeGenerator.Supports(GeneratorSupport.DeclareDelegates);
if (newAsync && methodCount > 0 && Style == ServiceDescriptionImportStyle.Client)
{
CodeAttributeDeclarationCollection metadata = new CodeAttributeDeclarationCollection();
string cancelAsync = "CancelAsync";
string cancelMethodName = MethodNames.AddUnique(cancelAsync, cancelAsync);
CodeMemberMethod asyncCancelMethod = WebCodeGenerator.AddMethod(this.CodeTypeDeclaration, cancelMethodName,
new CodeFlags[1], new string[] { typeof(object).FullName }, new string[] { "userState" },
typeof(void).FullName,
metadata,
CodeFlags.IsPublic | (cancelAsync != cancelMethodName ? 0 : CodeFlags.IsNew));
asyncCancelMethod.Comments.Add(new CodeCommentStatement(Res.GetString(Res.CodeRemarks), true));
CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), cancelAsync);
invoke.Parameters.Add(new CodeArgumentReferenceExpression("userState"));
asyncCancelMethod.Statements.Add(invoke);
}
EndClass();
if (portType.Operations.Count == 0)
{
NoMethodsGeneratedWarning();
}
AddExtensionWarningComments(codeClass.Comments, binding.Extensions);
if (port != null)
{
AddExtensionWarningComments(codeClass.Comments, port.Extensions);
}
codeNamespace.Types.Add(codeClass);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
throw new InvalidOperationException(Res.GetString(Res.UnableToImportBindingFromNamespace2, binding.Name, binding.ServiceDescription.TargetNamespace), e);
}
}
internal static bool GenerateSerializerToStream(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, Assembly assembly, Hashtable assemblies, Stream stream)
{
var compiler = new Compiler();
try
{
var scopeTable = new Hashtable();
foreach (XmlMapping mapping in xmlMappings)
{
scopeTable[mapping.Scope] = mapping;
}
var scopes = new TypeScope[scopeTable.Keys.Count];
scopeTable.Keys.CopyTo(scopes, 0);
assemblies.Clear();
var importedTypes = new Hashtable();
foreach (TypeScope scope in scopes)
{
foreach (Type t in scope.Types)
{
compiler.AddImport(t, importedTypes);
Assembly a = t.Assembly;
string name = a.FullName;
if (assemblies[name] != null)
{
continue;
}
if (!a.GlobalAssemblyCache)
{
assemblies[name] = a;
}
}
}
for (int i = 0; i < types.Length; i++)
{
compiler.AddImport(types[i], importedTypes);
}
compiler.AddImport(typeof(object).Assembly);
compiler.AddImport(typeof(System.Xml.Serialization.XmlSerializer).Assembly);
var writer = new IndentedWriter(compiler.Source, false);
writer.WriteLine("[assembly:System.Security.AllowPartiallyTrustedCallers()]");
writer.WriteLine("[assembly:System.Security.SecurityTransparent()]");
writer.WriteLine("[assembly:System.Security.SecurityRules(System.Security.SecurityRuleSet.Level1)]");
if (assembly != null && types.Length > 0)
{
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
if (type == null)
{
continue;
}
if (DynamicAssemblies.IsTypeDynamic(type))
{
throw new InvalidOperationException(SR.Format(SR.XmlPregenTypeDynamic, types[i].FullName));
}
}
writer.Write("[assembly:");
writer.Write(typeof(XmlSerializerVersionAttribute).FullName);
writer.Write("(");
writer.Write("ParentAssemblyId=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, GenerateAssemblyId(types[0]));
writer.Write(", Version=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, ThisAssembly.Version);
if (defaultNamespace != null)
{
writer.Write(", Namespace=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, defaultNamespace);
}
writer.WriteLine(")]");
}
var classes = new CodeIdentifiers();
classes.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
classes.AddUnique("XmlSerializationReader", "XmlSerializationReader");
string suffix = null;
if (types != null && types.Length == 1 && types[0] != null)
{
suffix = CodeIdentifier.MakeValid(types[0].Name);
if (types[0].IsArray)
{
suffix += "Array";
}
}
writer.WriteLine("namespace " + GeneratedAssemblyNamespace + " {");
writer.Indent++;
writer.WriteLine();
string writerClass = "XmlSerializationWriter" + suffix;
writerClass = classes.AddUnique(writerClass, writerClass);
var writerCodeGen = new XmlSerializationWriterCodeGen(writer, scopes, "public", writerClass);
writerCodeGen.GenerateBegin();
string[] writeMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
writeMethodNames[i] = writerCodeGen.GenerateElement(xmlMappings[i]);
}
writerCodeGen.GenerateEnd();
writer.WriteLine();
string readerClass = "XmlSerializationReader" + suffix;
readerClass = classes.AddUnique(readerClass, readerClass);
var readerCodeGen = new XmlSerializationReaderCodeGen(writer, scopes, "public", readerClass);
readerCodeGen.GenerateBegin();
string[] readMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
readMethodNames[i] = readerCodeGen.GenerateElement(xmlMappings[i]);
}
readerCodeGen.GenerateEnd(readMethodNames, xmlMappings, types);
string baseSerializer = readerCodeGen.GenerateBaseSerializer("XmlSerializer1", readerClass, writerClass, classes);
var serializers = new Hashtable();
for (int i = 0; i < xmlMappings.Length; i++)
{
if (serializers[xmlMappings[i].Key] == null)
{
serializers[xmlMappings[i].Key] = readerCodeGen.GenerateTypedSerializer(readMethodNames[i], writeMethodNames[i], xmlMappings[i], classes, baseSerializer, readerClass, writerClass);
}
}
readerCodeGen.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, readerClass, readMethodNames, writerClass, writeMethodNames, serializers);
writer.Indent--;
writer.WriteLine("}");
string codecontent = compiler.Source.ToString();
Byte[] info = new UTF8Encoding(true).GetBytes(codecontent);
stream.Write(info, 0, info.Length);
stream.Flush();
return(true);
}
finally
{
compiler.Close();
}
}
internal static Assembly GenerateRefEmitAssembly(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace)
{
var scopeTable = new Dictionary <TypeScope, XmlMapping>();
foreach (XmlMapping mapping in xmlMappings)
{
scopeTable[mapping.Scope] = mapping;
}
TypeScope[] scopes = new TypeScope[scopeTable.Keys.Count];
scopeTable.Keys.CopyTo(scopes, 0);
string assemblyName = "Microsoft.GeneratedCode";
AssemblyBuilder assemblyBuilder = CodeGenerator.CreateAssemblyBuilder(assemblyName);
// Add AssemblyVersion attribute to match parent accembly version
if (types != null && types.Length > 0 && types[0] != null)
{
ConstructorInfo AssemblyVersionAttribute_ctor = typeof(AssemblyVersionAttribute).GetConstructor(
new Type[] { typeof(String) }
);
string assemblyVersion = types[0].Assembly.GetName().Version.ToString();
assemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(AssemblyVersionAttribute_ctor, new Object[] { assemblyVersion }));
}
CodeIdentifiers classes = new CodeIdentifiers();
classes.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
classes.AddUnique("XmlSerializationReader", "XmlSerializationReader");
string suffix = null;
if (types != null && types.Length == 1 && types[0] != null)
{
suffix = CodeIdentifier.MakeValid(types[0].Name);
if (types[0].IsArray)
{
suffix += "Array";
}
}
ModuleBuilder moduleBuilder = CodeGenerator.CreateModuleBuilder(assemblyBuilder, assemblyName);
string writerClass = "XmlSerializationWriter" + suffix;
writerClass = classes.AddUnique(writerClass, writerClass);
XmlSerializationWriterILGen writerCodeGen = new XmlSerializationWriterILGen(scopes, "public", writerClass);
writerCodeGen.ModuleBuilder = moduleBuilder;
writerCodeGen.GenerateBegin();
string[] writeMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
writeMethodNames[i] = writerCodeGen.GenerateElement(xmlMappings[i]);
}
Type writerType = writerCodeGen.GenerateEnd();
string readerClass = "XmlSerializationReader" + suffix;
readerClass = classes.AddUnique(readerClass, readerClass);
XmlSerializationReaderILGen readerCodeGen = new XmlSerializationReaderILGen(scopes, "public", readerClass);
readerCodeGen.ModuleBuilder = moduleBuilder;
readerCodeGen.CreatedTypes.Add(writerType.Name, writerType);
readerCodeGen.GenerateBegin();
string[] readMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
readMethodNames[i] = readerCodeGen.GenerateElement(xmlMappings[i]);
}
readerCodeGen.GenerateEnd(readMethodNames, xmlMappings, types);
string baseSerializer = readerCodeGen.GenerateBaseSerializer("XmlSerializer1", readerClass, writerClass, classes);
var serializers = new Dictionary <string, string>();
for (int i = 0; i < xmlMappings.Length; i++)
{
if (!serializers.ContainsKey(xmlMappings[i].Key))
{
serializers[xmlMappings[i].Key] = readerCodeGen.GenerateTypedSerializer(readMethodNames[i], writeMethodNames[i], xmlMappings[i], classes, baseSerializer, readerClass, writerClass);
}
}
readerCodeGen.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, readerClass, readMethodNames, writerClass, writeMethodNames, serializers);
return(writerType.Assembly);
}
internal string GenerateTypedSerializer(string readMethod, string writeMethod, XmlMapping mapping, CodeIdentifiers classes, string baseSerializer, string readerClass, string writerClass)
{
string serializerName = CodeIdentifier.MakeValid(Accessor.UnescapeName(mapping.Accessor.Mapping.TypeDesc.Name));
serializerName = classes.AddUnique(serializerName + "Serializer", mapping);
_writer.WriteLine();
_writer.Write("public sealed class ");
_writer.Write(CodeIdentifier.GetCSharpName(serializerName));
_writer.Write(" : ");
_writer.Write(baseSerializer);
_writer.WriteLine(" {");
_writer.Indent++;
_writer.WriteLine();
_writer.Write("public override ");
_writer.Write(typeof(bool).FullName);
_writer.Write(" CanDeserialize(");
_writer.Write(typeof(XmlReader).FullName);
_writer.WriteLine(" xmlReader) {");
_writer.Indent++;
if (mapping.Accessor.Any)
{
_writer.WriteLine("return true;");
}
else
{
_writer.Write("return xmlReader.IsStartElement(");
WriteQuotedCSharpString(mapping.Accessor.Name);
_writer.Write(", ");
WriteQuotedCSharpString(mapping.Accessor.Namespace);
_writer.WriteLine(");");
}
_writer.Indent--;
_writer.WriteLine("}");
if (writeMethod != null)
{
_writer.WriteLine();
_writer.Write("protected override void Serialize(object objectToSerialize, ");
_writer.Write(typeof(XmlSerializationWriter).FullName);
_writer.WriteLine(" writer) {");
_writer.Indent++;
_writer.Write("((");
_writer.Write(writerClass);
_writer.Write(")writer).");
_writer.Write(writeMethod);
_writer.Write("(");
if (mapping is XmlMembersMapping)
{
_writer.Write("(object[])");
}
_writer.WriteLine("objectToSerialize);");
_writer.Indent--;
_writer.WriteLine("}");
}
if (readMethod != null)
{
_writer.WriteLine();
_writer.Write("protected override object Deserialize(");
_writer.Write(typeof(XmlSerializationReader).FullName);
_writer.WriteLine(" reader) {");
_writer.Indent++;
_writer.Write("return ((");
_writer.Write(readerClass);
_writer.Write(")reader).");
_writer.Write(readMethod);
_writer.WriteLine("();");
_writer.Indent--;
_writer.WriteLine("}");
}
_writer.Indent--;
_writer.WriteLine("}");
return(serializerName);
}
private void GenerateCode(string typeName, MimeTextMatchCollection matches, CodeGenerationOptions options)
{
CodeIdentifiers identifiers = new CodeIdentifiers();
CodeTypeDeclaration codeClass = WebCodeGenerator.AddClass(base.ImportContext.CodeNamespace, typeName, string.Empty, new string[0], null, CodeFlags.IsPublic, base.ImportContext.ServiceImporter.CodeGenerator.Supports(GeneratorSupport.PartialTypes));
string[] strArray = new string[matches.Count];
for (int i = 0; i < matches.Count; i++)
{
string fullName;
MimeTextMatch match = matches[i];
string memberName = identifiers.AddUnique(CodeIdentifier.MakeValid((match.Name.Length == 0) ? (this.methodName + "Match") : match.Name), match);
CodeAttributeDeclarationCollection metadata = new CodeAttributeDeclarationCollection();
if (match.Pattern.Length == 0)
{
throw new ArgumentException(Res.GetString("WebTextMatchMissingPattern"));
}
CodeExpression expression = new CodePrimitiveExpression(match.Pattern);
int index = 0;
if (match.Group != 1)
{
index++;
}
if (match.Capture != 0)
{
index++;
}
if (match.IgnoreCase)
{
index++;
}
if ((match.Repeats != 1) && (match.Repeats != 0x7fffffff))
{
index++;
}
CodeExpression[] propValues = new CodeExpression[index];
string[] propNames = new string[propValues.Length];
index = 0;
if (match.Group != 1)
{
propValues[index] = new CodePrimitiveExpression(match.Group);
propNames[index] = "Group";
index++;
}
if (match.Capture != 0)
{
propValues[index] = new CodePrimitiveExpression(match.Capture);
propNames[index] = "Capture";
index++;
}
if (match.IgnoreCase)
{
propValues[index] = new CodePrimitiveExpression(match.IgnoreCase);
propNames[index] = "IgnoreCase";
index++;
}
if ((match.Repeats != 1) && (match.Repeats != 0x7fffffff))
{
propValues[index] = new CodePrimitiveExpression(match.Repeats);
propNames[index] = "MaxRepeats";
index++;
}
WebCodeGenerator.AddCustomAttribute(metadata, typeof(MatchAttribute), new CodeExpression[] { expression }, propNames, propValues);
if (match.Matches.Count > 0)
{
fullName = base.ImportContext.ClassNames.AddUnique(CodeIdentifier.MakeValid((match.Type.Length == 0) ? memberName : match.Type), match);
strArray[i] = fullName;
}
else
{
fullName = typeof(string).FullName;
}
if (match.Repeats != 1)
{
fullName = fullName + "[]";
}
CodeTypeMember member = WebCodeGenerator.AddMember(codeClass, fullName, memberName, null, metadata, CodeFlags.IsPublic, options);
if ((match.Matches.Count == 0) && (match.Type.Length > 0))
{
HttpProtocolImporter importContext = base.ImportContext;
importContext.Warnings |= ServiceDescriptionImportWarnings.OptionalExtensionsIgnored;
ProtocolImporter.AddWarningComment(member.Comments, Res.GetString("WebTextMatchIgnoredTypeWarning"));
}
}
for (int j = 0; j < strArray.Length; j++)
{
string str3 = strArray[j];
if (str3 != null)
{
this.GenerateCode(str3, matches[j].Matches, options);
}
}
}
static void BuildProxy(ServiceData fd, bool rebuild, ArrayList proxies, XmlElement errdoc)
{
string wsdl = GetWsdlFile(fd);
if (!File.Exists(wsdl))
{
return;
}
if (fd.Protocols == null)
{
ReportError("Client test '" + fd.Name + "': no protocols declared", "");
return;
}
foreach (string prot in fd.Protocols)
{
string ns = fd.Namespace;
ns = CodeIdentifier.MakeValid(ns) + "." + prot;
string pfile = GetProxyFile(fd, prot);
if (File.Exists(pfile) && !rebuild)
{
proxies.Add(pfile); continue;
}
CreateFolderForFile(pfile);
Console.Write(prot + " proxy for " + wsdl + "... ");
Process proc = new Process();
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.RedirectStandardOutput = true;
proc.StartInfo.RedirectStandardError = true;
proc.StartInfo.FileName = "wsdl";
proc.StartInfo.Arguments = "/out:" + pfile + " /nologo /namespace:" + ns + " /protocol:" + prot + " " + wsdl;
proc.Start();
if (!proc.WaitForExit(30000))
{
try {
proc.Kill();
} catch {}
Console.WriteLine("FAIL (timeout)");
if (File.Exists(pfile))
{
File.Delete(pfile);
}
WriteError(errdoc, ns, "Errors found while generating " + prot + " proxy for WSDL: " + wsdl, "wsdl.exe timeout");
}
else if (proc.ExitCode != 0)
{
Console.WriteLine("FAIL " + proc.ExitCode);
string err = proc.StandardOutput.ReadToEnd();
err += "\n" + proc.StandardError.ReadToEnd();
if (File.Exists(pfile))
{
if (proc.ExitCode == 1)
{
string fn = fd.Name + prot + "Proxy.cs";
fn = Path.Combine(GetErrorPath(), fn);
CreateFolderForFile(fn);
File.Move(pfile, fn);
StreamWriter sw = new StreamWriter(fn, true);
sw.WriteLine();
sw.WriteLine("// " + fd.Wsdl);
sw.WriteLine();
sw.Close();
}
else
{
File.Delete(pfile);
}
}
WriteError(errdoc, ns, "Errors found while generating " + prot + " proxy for WSDL: " + wsdl, err);
}
else
{
if (File.Exists(pfile))
{
Console.WriteLine("OK");
proxies.Add(pfile);
}
else
{
Console.WriteLine("FAIL");
string err = proc.StandardOutput.ReadToEnd();
err += "\n" + proc.StandardError.ReadToEnd();
WriteError(errdoc, ns, "Errors found while generating " + prot + " proxy for WSDL: " + wsdl, err);
}
}
}
}
void GenerateCode(string typeName, MimeTextMatchCollection matches, CodeGenerationOptions options)
{
CodeIdentifiers members = new CodeIdentifiers();
CodeTypeDeclaration codeClass = WebCodeGenerator.AddClass(ImportContext.CodeNamespace, typeName, string.Empty, new string[0], null, CodeFlags.IsPublic,
ImportContext.ServiceImporter.CodeGenerator.Supports(GeneratorSupport.PartialTypes));
string[] fieldTypeNames = new string[matches.Count];
for (int i = 0; i < matches.Count; i++)
{
MimeTextMatch match = matches[i];
string name = members.AddUnique(CodeIdentifier.MakeValid(match.Name.Length == 0 ? methodName + "Match" : match.Name), match);
CodeAttributeDeclarationCollection metadata = new CodeAttributeDeclarationCollection();
if (match.Pattern.Length == 0)
{
throw new ArgumentException(Res.GetString(Res.WebTextMatchMissingPattern));
}
CodeExpression pattern = new CodePrimitiveExpression(match.Pattern);
int numPropValues = 0;
if (match.Group != 1)
{
numPropValues++;
}
if (match.Capture != 0)
{
numPropValues++;
}
if (match.IgnoreCase)
{
numPropValues++;
}
if (match.Repeats != 1 && match.Repeats != int.MaxValue)
{
numPropValues++;
}
CodeExpression[] propertyValues = new CodeExpression[numPropValues];
string[] propertyNames = new string[propertyValues.Length];
numPropValues = 0;
if (match.Group != 1)
{
propertyValues[numPropValues] = new CodePrimitiveExpression(match.Group);
propertyNames[numPropValues] = "Group";
numPropValues++;
}
if (match.Capture != 0)
{
propertyValues[numPropValues] = new CodePrimitiveExpression(match.Capture);
propertyNames[numPropValues] = "Capture";
numPropValues++;
}
if (match.IgnoreCase)
{
propertyValues[numPropValues] = new CodePrimitiveExpression(match.IgnoreCase);
propertyNames[numPropValues] = "IgnoreCase";
numPropValues++;
}
if (match.Repeats != 1 && match.Repeats != int.MaxValue)
{
propertyValues[numPropValues] = new CodePrimitiveExpression(match.Repeats);
propertyNames[numPropValues] = "MaxRepeats";
numPropValues++;
}
WebCodeGenerator.AddCustomAttribute(metadata, typeof(MatchAttribute), new CodeExpression[] { pattern }, propertyNames, propertyValues);
string fieldTypeName;
if (match.Matches.Count > 0)
{
fieldTypeName = ImportContext.ClassNames.AddUnique(CodeIdentifier.MakeValid(match.Type.Length == 0 ? name : match.Type), match);
fieldTypeNames[i] = fieldTypeName;
}
else
{
fieldTypeName = typeof(string).FullName;
}
if (match.Repeats != 1)
{
fieldTypeName += "[]";
}
CodeTypeMember member = WebCodeGenerator.AddMember(codeClass, fieldTypeName, name, null, metadata, CodeFlags.IsPublic, options);
if (match.Matches.Count == 0 && match.Type.Length > 0)
{
ImportContext.Warnings |= ServiceDescriptionImportWarnings.OptionalExtensionsIgnored;
ProtocolImporter.AddWarningComment(member.Comments, Res.GetString(Res.WebTextMatchIgnoredTypeWarning));
}
}
for (int i = 0; i < fieldTypeNames.Length; i++)
{
string fieldTypeName = fieldTypeNames[i];
if (fieldTypeName != null)
{
GenerateCode(fieldTypeName, matches[i].Matches, options);
}
}
}
void AddTypeAttributes(CodeTypeDeclaration td, XmlSchemaType type, params XmlSchemaElement [] collectionArgs)
{
var name = type.QualifiedName;
// [GeneratedCode (assembly_name, assembly_version)]
td.CustomAttributes.Add(new CodeAttributeDeclaration(
new CodeTypeReference(typeof(GeneratedCodeAttribute)),
new CodeAttributeArgument(new CodePrimitiveExpression(ass_name)),
new CodeAttributeArgument(new CodePrimitiveExpression(ass_version))));
var ct = type as XmlSchemaComplexType;
// [DataContract(Name="foobar",Namespace="urn:foobar")] (optionally IsReference=true),
// or [CollectionDataContract(ditto, ItemType/KeyType/ValueType)]
var dca = new CodeAttributeDeclaration(
collectionArgs != null && collectionArgs.Length > 0 ? typeref_coll_contract : typeref_data_contract,
new CodeAttributeArgument("Name", new CodePrimitiveExpression(name.Name)),
new CodeAttributeArgument("Namespace", new CodePrimitiveExpression(name.Namespace)));
if (collectionArgs != null)
{
if (collectionArgs.Length > 0)
{
dca.Arguments.Add(new CodeAttributeArgument("ItemName", new CodePrimitiveExpression(CodeIdentifier.MakeValid(collectionArgs [0].QualifiedName.Name))));
}
if (collectionArgs.Length > 2)
{
dca.Arguments.Add(new CodeAttributeArgument("KeyName", new CodePrimitiveExpression(CodeIdentifier.MakeValid(collectionArgs [1].QualifiedName.Name))));
dca.Arguments.Add(new CodeAttributeArgument("ValueName", new CodePrimitiveExpression(CodeIdentifier.MakeValid(collectionArgs [2].QualifiedName.Name))));
}
}
if (ct != null && ct.AttributeUses [new XmlQualifiedName("Ref", KnownTypeCollection.MSSimpleNamespace)] != null)
{
dca.Arguments.Add(new CodeAttributeArgument("IsReference", new CodePrimitiveExpression(true)));
}
td.CustomAttributes.Add(dca);
// optional [Serializable]
if (Options != null && Options.GenerateSerializable)
{
td.CustomAttributes.Add(new CodeAttributeDeclaration("System.SerializableAttribute"));
}
}