private void BuildProperties(XmlSchemaElement parentElement, XmlSchemaType schemaType,
ClrContentTypeInfo typeInfo)
{
XmlSchemaComplexType ct = schemaType as XmlSchemaComplexType;
if (ct != null)
{
if (ct.TypeCode == XmlTypeCode.Item)
{
return;
}
XmlSchemaParticle particleToProperties = ct.ContentTypeParticle;
XmlSchemaComplexType baseType = ct.BaseXmlSchemaType as XmlSchemaComplexType;
if (schemaType.GetContentType() == XmlSchemaContentType.TextOnly)
{
//Try to create a text property for the simple content
ClrPropertyInfo property = BuildComplexTypeTextProperty(parentElement, ct);
if (property != null)
{
typeInfo.AddMember(property);
}
if (baseType == null)
{
//Derived from Simple type, first step simpleContent extension
TraverseAttributes(ct.AttributeUses, typeInfo);
}
else
{
//Derived from another complex type simple content, generate the content only if there are additional restrictions
if (!ct.IsDerivedByRestriction()) //process attributes only if not derived by restriction
{
TraverseAttributes(ct.AttributeUses, baseType.AttributeUses, typeInfo);
}
}
}
else
{
Debug.Assert(
baseType != null); //ComplexType with complexContent is always derived from another complexType
if (ct.IsDerivedByRestriction())
{
//Do not handle restrictions on complex content?
return;
}
if (particleToProperties.GetParticleType() != ParticleType.Empty)
{
TraverseParticle(particleToProperties, baseType, typeInfo, ct.DerivedBy);
}
TraverseAttributes(ct.AttributeUses, baseType.AttributeUses, typeInfo);
}
}
else
{
typeInfo.AddMember(BuildSimpleTypeTextProperty(parentElement, schemaType as XmlSchemaSimpleType));
}
}
private void BuildProperties(XmlSchemaElement parentElement, XmlSchemaType schemaType, ClrContentTypeInfo typeInfo)
{
XmlSchemaComplexType ct = schemaType as XmlSchemaComplexType;
if (ct == null)
{
typeInfo.AddMember(this.BuildSimpleTypeTextProperty(parentElement, schemaType as XmlSchemaSimpleType));
}
else if (ct.TypeCode != XmlTypeCode.Item)
{
XmlSchemaParticle particleToProperties = ct.ContentTypeParticle;
XmlSchemaComplexType baseType = ct.BaseXmlSchemaType as XmlSchemaComplexType;
if (schemaType.GetContentType() != XmlSchemaContentType.TextOnly)
{
Debug.Assert(baseType != null);
if (ct.IsDerivedByRestriction())
{
return;
}
if (particleToProperties.GetParticleType() != ParticleType.Empty)
{
this.TraverseParticle(particleToProperties, baseType, typeInfo, ct.DerivedBy);
}
this.TraverseAttributes(ct.AttributeUses, baseType.AttributeUses, typeInfo);
}
else
{
ClrPropertyInfo property = this.BuildComplexTypeTextProperty(parentElement, ct);
if (property != null)
{
typeInfo.AddMember(property);
}
if (baseType == null)
{
this.TraverseAttributes(ct.AttributeUses, typeInfo);
}
else if (!ct.IsDerivedByRestriction())
{
this.TraverseAttributes(ct.AttributeUses, baseType.AttributeUses, typeInfo);
}
}
}
}
public static bool IsDerivedByRestriction(this XmlSchemaType derivedType)
{
XmlSchemaComplexType ct = derivedType as XmlSchemaComplexType;
if (ct != null)
{
return(ct.IsDerivedByRestriction());
}
else
{
XmlSchemaSimpleType st = derivedType as XmlSchemaSimpleType;
return(st.IsDerivedByRestriction());
}
}
public static bool HasFacetRestrictions(this XmlSchemaComplexType ct)
{
if (ct.GetContentType() == XmlSchemaContentType.TextOnly)
{
XmlSchemaSimpleType baseType = ct.BaseXmlSchemaType as XmlSchemaSimpleType;
if (baseType != null) //Derived from Simple type, first step simpleContent extension
{
return(baseType.HasFacetRestrictions());
}
else if (ct.IsDerivedByRestriction()) //derived from another complex type, simple content restriction
{
return(true);
}
}
return(false);
}
public static bool HasFacetRestrictions(this XmlSchemaComplexType ct)
{
bool flag;
if (ct.GetContentType() == XmlSchemaContentType.TextOnly)
{
XmlSchemaSimpleType baseType = ct.BaseXmlSchemaType as XmlSchemaSimpleType;
if (baseType != null)
{
flag = baseType.HasFacetRestrictions();
return(flag);
}
else if (ct.IsDerivedByRestriction())
{
flag = true;
return(flag);
}
}
flag = false;
return(flag);
}
private void BuildNestedTypes(ClrContentTypeInfo typeInfo)
{
List <AnonymousType> anonymousTypes = localSymbolTable.GetAnonymousTypes();
foreach (AnonymousType at in anonymousTypes)
{
XmlQualifiedName qname = null;
XmlSchemaComplexType complexType = null;
XmlSchemaElement elem = at.parentElement;
if (elem == null)
{
//case 1: "dummy" type for text content in a complex type, with restrictions
complexType = at.wrappingType;
qname = complexType.QualifiedName;
}
else
{
//case 2: anonymous type can also be nested under an element
qname = elem.QualifiedName;
complexType = elem.ElementSchemaType as XmlSchemaComplexType;
}
if (complexType != null)
{
if (complexType.GetContentType() == XmlSchemaContentType.TextOnly &&
complexType.IsDerivedByRestriction())
{
//In this case, we take care of the content/text part only. No nesting types exist.
ClrSimpleTypeInfo
nestedTypeInfo =
ClrSimpleTypeInfo
.CreateSimpleTypeInfo(
complexType); //Generate its "simple type" version to save restrictions
nestedTypeInfo.clrtypeName = at.identifier;
nestedTypeInfo.clrtypeNs = configSettings.GetClrNamespace(qname.Namespace);
nestedTypeInfo.schemaName = qname.Name;
nestedTypeInfo.schemaNs = qname.Namespace;
nestedTypeInfo.typeOrigin = SchemaOrigin.Fragment;
nestedTypeInfo.IsNested = true;
BuildAnnotationInformation(nestedTypeInfo, complexType);
typeInfo.NestedTypes.Add(nestedTypeInfo);
}
else
{
ClrContentTypeInfo nestedTypeInfo = new ClrContentTypeInfo()
{
Parent = typeInfo
};
localSymbolTable.Init(at.identifier);
nestedTypeInfo.clrtypeName = at.identifier;
nestedTypeInfo.clrtypeNs = configSettings.GetClrNamespace(qname.Namespace);
nestedTypeInfo.schemaName = qname.Name;
nestedTypeInfo.schemaNs = qname.Namespace;
nestedTypeInfo.typeOrigin = SchemaOrigin.Fragment;
nestedTypeInfo.IsNested = true;
nestedTypeInfo.baseType = BaseType(complexType);
BuildProperties(elem, complexType, nestedTypeInfo);
BuildNestedTypes(nestedTypeInfo);
BuildAnnotationInformation(nestedTypeInfo, complexType);
typeInfo.NestedTypes.Add(nestedTypeInfo);
}
}
//Also handle simple types
XmlSchemaSimpleType simpleType = null;
if (elem != null)
{
simpleType = elem.ElementSchemaType as XmlSchemaSimpleType;
}
if (simpleType != null)
{
ClrSimpleTypeInfo nestedTypeInfo = ClrSimpleTypeInfo.CreateSimpleTypeInfo(simpleType);
nestedTypeInfo.clrtypeName = at.identifier;
nestedTypeInfo.clrtypeNs = configSettings.GetClrNamespace(qname.Namespace);
nestedTypeInfo.schemaName = qname.Name;
nestedTypeInfo.schemaNs = qname.Namespace;
nestedTypeInfo.typeOrigin = SchemaOrigin.Fragment;
nestedTypeInfo.IsNested = true;
BuildAnnotationInformation(nestedTypeInfo, simpleType);
typeInfo.NestedTypes.Add(nestedTypeInfo);
}
}
}
private void BuildNestedTypes(ClrContentTypeInfo typeInfo)
{
ClrSimpleTypeInfo clrSimpleTypeInfo;
foreach (AnonymousType at in this.localSymbolTable.GetAnonymousTypes())
{
XmlQualifiedName qname = null;
XmlSchemaComplexType complexType = null;
XmlSchemaElement elem = at.parentElement;
if (elem != null)
{
qname = elem.QualifiedName;
complexType = elem.ElementSchemaType as XmlSchemaComplexType;
}
else
{
complexType = at.wrappingType;
qname = complexType.QualifiedName;
}
if (complexType != null)
{
if ((complexType.GetContentType() != XmlSchemaContentType.TextOnly ? true : !complexType.IsDerivedByRestriction()))
{
ClrContentTypeInfo clrContentTypeInfo = new ClrContentTypeInfo();
this.localSymbolTable.Init(at.identifier);
clrContentTypeInfo.clrtypeName = at.identifier;
clrContentTypeInfo.clrtypeNs = this.configSettings.GetClrNamespace(qname.Namespace);
clrContentTypeInfo.schemaName = qname.Name;
clrContentTypeInfo.schemaNs = qname.Namespace;
clrContentTypeInfo.typeOrigin = SchemaOrigin.Fragment;
clrContentTypeInfo.IsNested = true;
clrContentTypeInfo.baseType = this.BaseType(complexType);
this.BuildProperties(elem, complexType, clrContentTypeInfo);
this.BuildNestedTypes(clrContentTypeInfo);
this.BuildAnnotationInformation(clrContentTypeInfo, complexType);
typeInfo.NestedTypes.Add(clrContentTypeInfo);
}
else
{
clrSimpleTypeInfo = ClrSimpleTypeInfo.CreateSimpleTypeInfo(complexType);
clrSimpleTypeInfo.clrtypeName = at.identifier;
clrSimpleTypeInfo.clrtypeNs = this.configSettings.GetClrNamespace(qname.Namespace);
clrSimpleTypeInfo.schemaName = qname.Name;
clrSimpleTypeInfo.schemaNs = qname.Namespace;
clrSimpleTypeInfo.typeOrigin = SchemaOrigin.Fragment;
clrSimpleTypeInfo.IsNested = true;
this.BuildAnnotationInformation(clrSimpleTypeInfo, complexType);
typeInfo.NestedTypes.Add(clrSimpleTypeInfo);
}
}
XmlSchemaSimpleType simpleType = null;
if (elem != null)
{
simpleType = elem.ElementSchemaType as XmlSchemaSimpleType;
}
if (simpleType != null)
{
clrSimpleTypeInfo = ClrSimpleTypeInfo.CreateSimpleTypeInfo(simpleType);
clrSimpleTypeInfo.clrtypeName = at.identifier;
clrSimpleTypeInfo.clrtypeNs = this.configSettings.GetClrNamespace(qname.Namespace);
clrSimpleTypeInfo.schemaName = qname.Name;
clrSimpleTypeInfo.schemaNs = qname.Namespace;
clrSimpleTypeInfo.typeOrigin = SchemaOrigin.Fragment;
clrSimpleTypeInfo.IsNested = true;
this.BuildAnnotationInformation(clrSimpleTypeInfo, simpleType);
typeInfo.NestedTypes.Add(clrSimpleTypeInfo);
}
}
}
public static bool IsDerivedByRestriction(this XmlSchemaType derivedType)
{
bool flag;
XmlSchemaComplexType ct = derivedType as XmlSchemaComplexType;
flag = (ct == null ? (derivedType as XmlSchemaSimpleType).IsDerivedByRestriction() : ct.IsDerivedByRestriction());
return(flag);
}
