void WriteRootElementSample(XmlTextWriter xtw, XmlQualifiedName qname)
{
XmlSchemaElement elem = (XmlSchemaElement)schemas.Find(qname, typeof(XmlSchemaElement));
if (elem == null)
{
throw new InvalidOperationException("Element not found: " + qname);
}
WriteElementSample(xtw, qname.Namespace, elem);
}
public void Bug360541()
{
XmlSchemaComplexType stype = GetStype();
XmlSchemaElement selem1 = new XmlSchemaElement();
selem1.Name = "schema";
selem1.SchemaType = stype;
XmlSchema schema = new XmlSchema();
schema.Items.Add(selem1);
XmlSchemas xs = new XmlSchemas();
xs.Add(schema);
xs.Find(XmlQualifiedName.Empty, typeof(XmlSchemaElement));
selem1 = new XmlSchemaElement();
selem1.Name = "schema1";
selem1.SchemaType = stype;
schema = new XmlSchema();
schema.Items.Add(selem1);
xs = new XmlSchemas();
xs.Add(schema);
xs.Find(XmlQualifiedName.Empty, typeof(XmlSchemaElement));
}
/// <summary>
/// Extends Find so that methods that return a specific type object given a Type parameter can be
/// used as generic method and casting is not required.
/// <example>
/// xmlschemas.Find<int>(name);
/// </example>
/// </summary>
public static T Find <T>(this XmlSchemas xmlschemas, System.Xml.XmlQualifiedName name)
{
if (xmlschemas == null)
{
throw new ArgumentNullException("xmlschemas");
}
return((T)xmlschemas.Find(name, typeof(T)));
}
internal XmlSchemaElement FindDataSetElement(XmlSchema schema, XmlSchemas schemas)
{
foreach (XmlSchemaObject obj2 in schema.Items)
{
if ((obj2 is XmlSchemaElement) && IsDataSet((XmlSchemaElement)obj2))
{
XmlSchemaElement element = (XmlSchemaElement)obj2;
return((XmlSchemaElement)schemas.Find(element.QualifiedName, typeof(XmlSchemaElement)));
}
}
return(null);
}
public List <WSParameter> GetParameters(Message msg)
{
List <WSParameter> parameters = new List <WSParameter>();
foreach (MessagePart msgpart in msg.Parts)
{
if (!msgpart.Element.IsEmpty)
{
XmlQualifiedName typName = msgpart.Element;
XmlSchemaElement lookup = (XmlSchemaElement)schemas.Find(typName, typeof(XmlSchemaElement));
if (lookup != null)
{
XmlSchemaComplexType tt = (XmlSchemaComplexType)lookup.SchemaType;
XmlSchemaSequence sequence = (XmlSchemaSequence)tt.Particle;
//int i = 0;
if (sequence != null)
{
foreach (XmlSchemaElement childElement in sequence.Items)
{
WSParameter param = new WSParameter();
param.Name = childElement.Name;
param.TypeName = childElement.SchemaTypeName.Name;
param.MinOccurs = childElement.MinOccurs;
param.MaxOccurs = childElement.MaxOccurs.ToString();
parameters.Add(param);
//ParameterAndType.Add(childElement.Name, childElement.SchemaTypeName.Name);
//Console.WriteLine("Element: {0} ,{1}", childElement.Name,childElement.SchemaTypeName.Name);
}
}
}
}
else
{
WSParameter param = new WSParameter();
param.Name = msgpart.Name;
param.TypeName = msgpart.Type.Name;
param.MinOccurs = 0;
param.MaxOccurs = "0";
parameters.Add(param);
}
}
return(parameters);
}
public override string ImportSchemaType(
string name,
string ns,
XmlSchemaObject context,
XmlSchemas schemas,
XmlSchemaImporter importer,
CodeCompileUnit compileUnit,
CodeNamespace mainNamespace,
CodeGenerationOptions options,
CodeDomProvider codeProvider)
{
XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType)schemas.Find(new XmlQualifiedName(name, ns), typeof(XmlSchemaSimpleType));
return(ImportSchemaType(
simpleType,
context,
schemas,
importer,
compileUnit,
mainNamespace,
options,
codeProvider));
}
private ServiceDescriptionImportWarnings Import(CodeNamespace codeNamespace, ImportContext importContext, Hashtable exportContext, StringCollection warnings)
{
allSchemas = new XmlSchemas();
foreach (XmlSchema schema in schemas)
{
allSchemas.Add(schema);
}
foreach (ServiceDescription description in serviceDescriptions)
{
foreach (XmlSchema schema in description.Types.Schemas)
{
allSchemas.Add(schema);
}
}
Hashtable references = new Hashtable();
if (!allSchemas.Contains(ServiceDescription.Namespace))
{
allSchemas.AddReference(ServiceDescription.Schema);
references[ServiceDescription.Schema] = ServiceDescription.Schema;
}
if (!allSchemas.Contains(Soap.Encoding))
{
allSchemas.AddReference(ServiceDescription.SoapEncodingSchema);
references[ServiceDescription.SoapEncodingSchema] = ServiceDescription.SoapEncodingSchema;
}
allSchemas.Compile(null, false);
// Segregate the schemas containing abstract types from those
// containing regular XML definitions. This is important because
// when you import something returning the ur-type (object), then
// you need to import ALL types/elements within ALL schemas. We
// don't want the RPC-based types leaking over into the XML-based
// element definitions. This also occurs when you have derivation:
// we need to search the schemas for derived types: but WHICH schemas
// should we search.
foreach (ServiceDescription description in serviceDescriptions)
{
foreach (Message message in description.Messages)
{
foreach (MessagePart part in message.Parts)
{
bool isEncoded;
bool isLiteral;
FindUse(part, out isEncoded, out isLiteral);
if (part.Element != null && !part.Element.IsEmpty)
{
if (isEncoded)
{
throw new InvalidOperationException(Res.GetString(Res.CanTSpecifyElementOnEncodedMessagePartsPart, part.Name, message.Name));
}
XmlSchemaElement element = (XmlSchemaElement)allSchemas.Find(part.Element, typeof(XmlSchemaElement));
if (element != null)
{
AddSchema(element.Parent as XmlSchema, isEncoded, isLiteral, abstractSchemas, concreteSchemas, references);
if (element.SchemaTypeName != null && !element.SchemaTypeName.IsEmpty)
{
XmlSchemaType type = (XmlSchemaType)allSchemas.Find(element.SchemaTypeName, typeof(XmlSchemaType));
if (type != null)
{
AddSchema(type.Parent as XmlSchema, isEncoded, isLiteral, abstractSchemas, concreteSchemas, references);
}
}
}
}
if (part.Type != null && !part.Type.IsEmpty)
{
XmlSchemaType type = (XmlSchemaType)allSchemas.Find(part.Type, typeof(XmlSchemaType));
if (type != null)
{
AddSchema(type.Parent as XmlSchema, isEncoded, isLiteral, abstractSchemas, concreteSchemas, references);
}
}
}
}
}
Hashtable imports;
foreach (XmlSchemas xmlschemas in new XmlSchemas[] { abstractSchemas, concreteSchemas })
{
// collect all imports
imports = new Hashtable();
foreach (XmlSchema schema in xmlschemas)
{
AddImport(schema, imports);
}
// make sure we add them to the corresponding schema collections
foreach (XmlSchema schema in imports.Keys)
{
if (references[schema] == null && !xmlschemas.Contains(schema))
{
xmlschemas.Add(schema);
}
}
}
// If a schema was not referenced by either a literal or an encoded message part,
// add it to both collections. There's no way to tell which it should be.
imports = new Hashtable();
foreach (XmlSchema schema in allSchemas)
{
if (!abstractSchemas.Contains(schema) && !concreteSchemas.Contains(schema))
{
AddImport(schema, imports);
}
}
// make sure we add them to the corresponding schema collections
foreach (XmlSchema schema in imports.Keys)
{
if (references[schema] != null)
{
continue;
}
if (!abstractSchemas.Contains(schema))
{
abstractSchemas.Add(schema);
}
if (!concreteSchemas.Contains(schema))
{
concreteSchemas.Add(schema);
}
}
if (abstractSchemas.Count > 0)
{
foreach (XmlSchema schema in references.Values)
{
abstractSchemas.AddReference(schema);
}
StringCollection schemaWarnings = SchemaCompiler.Compile(abstractSchemas);
foreach (string warning in schemaWarnings)
{
warnings.Add(warning);
}
}
if (concreteSchemas.Count > 0)
{
foreach (XmlSchema schema in references.Values)
{
concreteSchemas.AddReference(schema);
}
StringCollection schemaWarnings = SchemaCompiler.Compile(concreteSchemas);
foreach (string warning in schemaWarnings)
{
warnings.Add(warning);
}
}
if (ProtocolName.Length > 0)
{
// If a protocol was specified, only try that one
ProtocolImporter importer = FindImporterByName(ProtocolName);
if (importer.GenerateCode(codeNamespace, importContext, exportContext))
{
return(importer.Warnings);
}
}
else
{
// Otherwise, do "best" protocol (first one that generates something)
for (int i = 0; i < importers.Length; i++)
{
ProtocolImporter importer = importers[i];
if (importer.GenerateCode(codeNamespace, importContext, exportContext))
{
return(importer.Warnings);
}
}
}
return(ServiceDescriptionImportWarnings.NoCodeGenerated);
}
void StartParsing()
{
try
{
processHasExited = false;
object lookup = _schemas.Find(_qname, typeof(XmlSchemaElement));
if (lookup != null)
{
Create_RootElement(_node, _qname);
}
else
{
Create_CustomType(_node, _qname);
}
processHasExited = true;
}
catch (Exception e)
{
//MessageBox.Show(e.Message.ToString() ) ;
}
}