Widziałem podobne pytania zadawane w przeszłości (pełne ujawnienie, mam poprosić podobny question siebie). Parsowanie XSD nie jest dla osób o słabym sercu.
Zasadniczo masz dwie opcje, łatwiejsze do wdrożenia, ale łatwiejsze do złamania poprzez niewielkie zmiany w XSD. druga jest bardziej rozbudowana, ale trudna do wdrożenia.
Wariant 1:
Przetwarzanie XSD z LINQ (C# lub innego parsera XML, jeśli wolisz). Ponieważ XSD to tylko XML, możesz załadować go do XDocument i po prostu odczytać go przez LINQ.
uzyskać tylko próbka własnego xsd:
<xsd:simpleType name="Amount_Type">
<xsd:annotation>
<xsd:documentation>Amount</xsd:documentation>
</xsd:annotation>
<xsd:restriction base="xsd:string">
<xsd:maxLength value="12" />
</xsd:restriction>
</xsd:simpleType>
można uzyskać dostęp do MaxLength:
var xDoc = XDocument.Load("your XSD path");
var ns = XNamespace.Get(@"http://www.w3.org/2001/XMLSchema");
var length = (from sType in xDoc.Element(ns + "schema").Elements(ns + "simpleType")
where sType.Attribute("name").Value == "Amount_Type"
from r in sType.Elements(ns + "restriction")
select r.Element(ns + "maxLength").Attribute("value")
.Value).FirstOrDefault();
nie oferują bardzo łatwy sposób analizowania wg nazwy typu, zwłaszcza przez dłuższy typy. Aby tego użyć, musisz znać dokładną ścieżkę dla każdego poszukiwanego elementu.
Opcja 2:
To jest zbyt skomplikowane dla szybkiej odpowiedzi (uwaga: patrz Edycja - Miałem trochę czasu i ułożyła roztwór roboczy), więc mam zamiar zachęcić możesz spojrzeć na moje własne pytanie, które podałem powyżej. W nim podłączyłem great blog, który pokazuje, jak poważnie zepsuć XSD na kawałki i może pozwolić ci na wykonanie pożądanego rodzaju wyszukiwania. Musisz zdecydować, czy warto ją rozwijać (blog przedstawia implementację z XmlReader, która zawiera XML, który jest sprawdzany względem XSD, ale możesz to łatwo osiągnąć, bezpośrednio ładując XSD i parsując go.
2 klucz pomysł, aby znaleźć na blogu to:
// in the getRestriction method (reader in this context is an `XmlReader` that
// contains a XML that is being validated against the specific XSD
if (reader.SchemaInfo.SchemaElement == null) return null;
simpleType = reader.SchemaInfo.SchemaElement.ElementSchemaType as XmlSchemaSimpleType;
if (simpleType == null) return null;
restriction = simpleType.Content as XmlSchemaSimpleTypeRestriction;
// then in the getMaxLength method
if (restriction == null) return null;
List<int> result = new List<int>();
foreach (XmlSchemaObject facet in restriction.Facets) {
if (facet is XmlSchemaMaxLengthFacet) result.Add(int.Parse(((XmlSchemaFacet) facet).Value));
I rzeczywiście próbowała to samo w ubiegłym roku do analizowania XSD jako część skomplikowanej metody sprawdzania poprawności danych. Przez większą część tygodnia zrozumiałem, co się dzieje, i dostosowałem metody na blogu, by pasowały do moich celów. Jest to zdecydowanie najlepszy sposób na wdrożenie dokładnie tego, co chcesz.
Jeśli chcesz wypróbować to w samodzielnym schemacie, możesz załadować XSD do obiektu XmlSchemaSet, a następnie użyć właściwości GlobalTypes, aby pomóc Ci znaleźć konkretny typ, którego szukasz.
EDIT: Wyciągnąłem mój stary kod i zaczął łącząc kod pomóc.
Najpierw załadować schematu:
XmlSchemaSet set; // this needs to be accessible to the methods below,
// so should be a class level field or property
using (var fs = new FileStream(@"your path here", FileMode.Open)
{
var schema = XmlSchema.Read(fs, null);
set = new XmlSchemaSet();
set.Add(schema);
set.Compile();
}
następujące metody powinno dać blisko tego, co chcesz na podstawie XSD, który podałeś. Powinien on nadawać się do adaptacji do bardziej złożonych struktur.
public Dictionary<string, int> GetElementMaxLength(String xsdElementName)
{
if (xsdElementName == null) throw new ArgumentException();
// if your XSD has a target namespace, you need to replace null with the namespace name
var qname = new XmlQualifiedName(xsdElementName, null);
// find the type you want in the XmlSchemaSet
var parentType = set.GlobalTypes[qname];
// call GetAllMaxLength with the parentType as parameter
var results = GetAllMaxLength(parentType);
return results;
}
private Dictionary<string, int> GetAllMaxLength(XmlSchemaObject obj)
{
Dictionary<string, int> dict = new Dictionary<string, int>();
// do some type checking on the XmlSchemaObject
if (obj is XmlSchemaSimpleType)
{
// if it is a simple type, then call GetMaxLength to get the MaxLength restriction
var st = obj as XmlSchemaSimpleType;
dict[st.QualifiedName.Name] = GetMaxLength(st);
}
else if (obj is XmlSchemaComplexType)
{
// if obj is a complexType, cast the particle type to a sequence
// and iterate the sequence
// warning - this will fail if it is not a sequence, so you might need
// to make some adjustments if you have something other than a xs:sequence
var ct = obj as XmlSchemaComplexType;
var seq = ct.ContentTypeParticle as XmlSchemaSequence;
foreach (var item in seq.Items)
{
// item will be an XmlSchemaObject, so just call this same method
// with item as the parameter to parse it out
var rng = GetAllMaxLength(item);
// add the results to the dictionary
foreach (var kvp in rng)
{
dict[kvp.Key] = kvp.Value;
}
}
}
else if (obj is XmlSchemaElement)
{
// if obj is an XmlSchemaElement, the you need to find the type
// based on the SchemaTypeName property. This is why your
// XmlSchemaSet needs to have class-level scope
var ele = obj as XmlSchemaElement;
var type = set.GlobalTypes[ele.SchemaTypeName];
// once you have the type, call this method again and get the dictionary result
var rng = GetAllMaxLength(type);
// put the results in this dictionary. The difference here is the dictionary
// key is put in the format you specified
foreach (var kvp in rng)
{
dict[String.Format("{0}/{1}", ele.QualifiedName.Name, kvp.Key)] = kvp.Value;
}
}
return dict;
}
private Int32 GetMaxLength(XmlSchemaSimpleType xsdSimpleType)
{
// get the content of the simple type
var restriction = xsdSimpleType.Content as XmlSchemaSimpleTypeRestriction;
// if it is null, then there are no restrictions and return -1 as a marker value
if (restriction == null) return -1;
Int32 result = -1;
// iterate the facets in the restrictions, look for a MaxLengthFacet and parse the value
foreach (XmlSchemaObject facet in restriction.Facets)
{
if (facet is XmlSchemaMaxLengthFacet)
{
result = int.Parse(((XmlSchemaFacet)facet).Value);
break;
}
}
return result;
}
Następnie użycie jest bardzo proste, wystarczy wywołać metodę GetElementMaxLength(String) i powróci do Słownika nazwisk w formacie dostarczonych z wartości jako długość maksymalna:
var results = GetElementMaxLength("Setup_Type");
foreach (var item in results)
{
Console.WriteLine("{0} | {1}", item.Key, item.Value);
}
Dziękuję wszystkim za wspaniałe rozwiązania. Bardzo pomocne było spojrzenie na kod. Do tej pory próbowałem rozwiązania @ psubsee2003 i działa to doskonale dla mnie. – Jyina