12

複数の複雑なタイプと単純なタイプのXSDがあります(以下に示すファイルの一部)。このドキュメントを解析して、複合型で参照されている各単純型からmaxLengthを取得する必要があります。誰かがこれを実装する方法についてアドバイスを投げてもらえますか?これを一般的な方法で実装する必要があるため、「Setup_Type」でクエリを実行すると、次の出力が得られます。ありがとうございました!

NewSetup / Amount = 12( "/"で区切られた要素タグの名前属性とネストされたsimpleTypeのmaxLength)

NewSetup / Name = 50

<xsd:complexType name="Setup_Type">
  <xsd:sequence>
    <xsd:element name="NewSetup" type="NewSetup_Type" minOccurs="1" maxOccurs="1" />
  </xsd:sequence>
</xsd:complexType>

<xsd:complexType name="NewSetup_Type">
  <xsd:sequence>
    <xsd:element name="Amount" type="Amount_Type"  minOccurs="1" maxOccurs="1" />
    <xsd:element name="Name" type="Name_Type"  minOccurs="1" maxOccurs="1" />
  </xsd:sequence>
</xsd:complexType>

<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>

<xsd:simpleType name="Name_Type">
  <xsd:annotation>
    <xsd:documentation>Name</xsd:documentation>
  </xsd:annotation>
  <xsd:restriction base="xsd:string">
    <xsd:maxLength value="50" />
  </xsd:restriction>
</xsd:simpleType>
4

3 に答える 3

23

私は過去に同様の質問をしたことがあります(完全な開示、私自身も同様の質問をしました)。XSDの解析は、気の弱い人向けではありません。

基本的に2つのオプションがあります。最初のオプションは実装が簡単ですが、XSDに小さな変更を加えることで簡単に壊すことができます。2つ目は、より堅牢ですが、実装が困難です。

オプション1:

XSDをLINQ(または必要に応じて他のC#XMLパーサー)で解析します。XSDは単なるXMLであるため、XSDをにロードして、XDocumentLINQを介して読み取ることができます。

独自の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>

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();

これは、特に拡張型の場合、型名で解析するための非常に簡単な方法を提供しません。これを使用するには、探している各要素の正確なパスを知る必要があります。

オプション2:

これは非常に複雑すぎて簡単に答えることができません(注:以下の編集を参照してください-しばらく時間があり、実用的な解決策をまとめました)。そのため、上記でリンクした自分の質問を参照することをお勧めします。その中で、 XSDを真剣に細かく分割する方法を示し、必要な種類の検索を実行できる可能性のあるすばらしいブログをリンクしました。開発する価値があるかどうかを判断する必要があります(ブログには、XmlReader問題のXSDに対して検証されたXMLを含む実装が示されていますが、XSDを直接ロードして解析することで、これを簡単に実現できます。

ブログで見つける2つの重要なアイデアは次のとおりです。

// 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));

昨年、複雑なデータ検証方法の一部としてXSDを解析するために同じことを実際に試しました。ブログのメソッドを自分の目的に合わせて調整するために何が起こっているのかを実際に理解するのに、1週間の大部分を要しました。それは間違いなくあなたが望むものを正確に実装するための最良の方法です。

スタンドアロンスキーマでこれを試してみたい場合は、XSDをXmlSchemaSetオブジェクトにロードしてから、GlobalTypesプロパティを使用して、探している特定のタイプを見つけることができます。


編集: 私は古いコードを取り出して、あなたを助けるためにコードをまとめ始めました。

最初にスキーマをロードします。

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();
}

次の方法では、提供したXSDに基づいて必要なものに近づけることができます。より複雑な構造を処理するのにかなり適応できるはずです。

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;
}

次に、使用法は非常に簡単です。メソッドを呼び出すだけGetElementMaxLength(String)で、最大長として値を指定した形式で名前の辞書が返されます。

var results = GetElementMaxLength("Setup_Type");

foreach (var item in results)
{
    Console.WriteLine("{0} | {1}", item.Key, item.Value);                
}
于 2012-07-19T23:51:32.473 に答える
1
public class result_tree
{
    public string nodevalue = "";

    public bool IsTerminal { get { return ChildCount == 0; } }

    public List<result_tree> children = new List<result_tree>();

    public int ChildCount { get { return children.Count; } }

    public result_tree(string v) { nodevalue = v; }

    private void print_children(bool skip, string prefix)
    {
        if (IsTerminal)
            Console.WriteLine(prefix + (prefix.Length==0?"":"/") + nodevalue);
        else
            foreach (result_tree rt in children)
                rt.print_children(false,prefix + (prefix.Length == 0 ? "" : "/") + (skip?"":nodevalue));
    }

    public void print_children()
    {
        print_children(true,"");
    }
}

static class Program
{
    private static void ValidationCallBack(object sender, ValidationEventArgs args)
    {
        Console.WriteLine(args.Message);
    }

    public static result_tree results;



    static string deref_simple(XmlSchemaSimpleType simp)
    {
        XmlSchemaSimpleTypeRestriction xsstr = (XmlSchemaSimpleTypeRestriction)simp.Content;
        foreach (object o in xsstr.Facets)
        {
            if (o.GetType() == typeof(XmlSchemaMaxLengthFacet))
            {
                XmlSchemaMaxLengthFacet fac = (XmlSchemaMaxLengthFacet)o;
                return fac.Value;
            }
        }
        return "";
    }

    static result_tree deref_complex(XmlSchema xs, XmlSchemaComplexType cplx)
    {
        result_tree rt = new result_tree(cplx.Name);

        if (cplx.Particle.GetType() == typeof(XmlSchemaSequence))
        {
            XmlSchemaSequence seq = (XmlSchemaSequence)cplx.Particle;
            foreach (object o in seq.Items)
            {
                if (o.GetType() == typeof(XmlSchemaElement))
                {
                    XmlSchemaElement elem = (XmlSchemaElement)o;

                    XmlQualifiedName name = elem.SchemaTypeName;

                    result_tree branch;

                    object referto = xs.SchemaTypes[name];
                    if (referto.GetType() == typeof(XmlSchemaComplexType))
                    {
                        branch = deref_complex(xs,(XmlSchemaComplexType)referto);
                        branch.nodevalue = elem.Name;
                    }
                    else if (referto.GetType() == typeof(XmlSchemaSimpleType))
                    {
                        XmlSchemaSimpleType st = (XmlSchemaSimpleType)referto;

                        branch = new result_tree(elem.Name + " = " + deref_simple(st).ToString());
                    }
                    else
                    {
                        branch = null;
                    }
                    if( branch != null )
                        rt.children.Add(branch);

                }
            }
        }

        return rt;
    }

    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main()
    {

        StreamReader sr = new StreamReader("aschema.xml");
        XmlSchema xs = XmlSchema.Read(sr, ValidationCallBack);
        XmlSchemaSet xss = new XmlSchemaSet();
        xss.Add(xs);
        xss.Compile();

        Console.WriteLine("Query: ");
        string q = Console.ReadLine();

        XmlQualifiedName xqn = new XmlQualifiedName(q);

        if (xs.SchemaTypes.Contains(xqn))
        {
            object o = xs.SchemaTypes[xqn];
            if (o.GetType() == typeof(XmlSchemaComplexType))
            {
                results = deref_complex(xs, (XmlSchemaComplexType)o);
                results.print_children();
            }   
        }
        else
        {
            Console.WriteLine("Not found!");
        }

    }
}
于 2012-07-20T00:16:04.953 に答える
0

私の解決策はあなたが探しているものと正確に一致しないかもしれません。おそらく、System.Xmlクラスを使用してそのような情報を処理することをお勧めします。このパーサーをどれだけ一般的にしたいかはわかりませんが、とにかくこれらは私の2セントです。私のコードは、99%の可能性に正しく直面するように設計された正規表現を使用しています(私は推測します)。誰かがこれを銃でハエを撃つように呼ぶでしょう。とにかくそれだけです:

using System.Text.RegularExpressions;
using System.IO;

static class Program
{
    static void main()
    {
        XsdFile file = new XsdFile(@"c:\temp\test.xsd");
        Console.WriteLine(file.Query("Setup_Type"));
    }
}

public class XsdFile
{

    Dictionary<string, XsdType> types;

    public XsdFile(string path)
    {
        string xsdBody = File.ReadAllText(path);
        types = XsdType.CreateTypes(xsdBody);
    }

    public string Query(string typename) {
        return Query(typename, "");
    }

    private string Query(string typename, string parent)
    {
        XsdType type;
        if (types.TryGetValue(typename, out type))
        {
            if (type.GetType() == typeof(ComplexType))
            {
                StringBuilder sb = new StringBuilder();
                ComplexType complexType = (ComplexType)type;
                foreach (string elementName in complexType.elements.Keys)
                {
                    string elementType = complexType.elements[elementName];
                    sb.AppendLine(Query(elementType, parent + "/" + elementName));
                }
                return sb.ToString();
            }
            else if (type.GetType() == typeof(SimpleType))
            {
                SimpleType simpleType = (SimpleType)type;
                return string.Format("{0} = {1}", parent, simpleType.maxLength);
            }
            else {
                return "";
            }
        }
        else
        {
            return "";
        }
    }
}

public abstract class XsdType
{

    string name;

    public XsdType(string name)
    {
        this.name = name;
    }

    public static Dictionary<string, XsdType> CreateTypes(string xsdBody)
    {

        Dictionary<string, XsdType> types = new Dictionary<string, XsdType>();

        MatchCollection mc_types = Regex.Matches(xsdBody, @"<xsd:(?<kind>complex|simple)Type[\s\t]+(?<attributes>[^>]+)>(?<body>.+?)</xsd:\1Type>", RegexOptions.Singleline);
        foreach (Match m_type in mc_types)
        {
            string typeKind = m_type.Groups["kind"].Value;
            string typeAttributes = m_type.Groups["attributes"].Value;
            string typeBody = m_type.Groups["body"].Value;
            string typeName;
            Match m_nameattribute = Regex.Match(typeAttributes, @"name[\s\t]*=[\s\t]*""(?<name>[^""]+)""", RegexOptions.Singleline);
            if (m_nameattribute.Success)
            {
                typeName = m_nameattribute.Groups["name"].Value;
                if (typeKind == "complex")
                {
                    ComplexType current_type = new ComplexType(typeName);
                    MatchCollection mc_elements = Regex.Matches(typeBody, @"<xsd:element(?<attributes>.+?)/>", RegexOptions.Singleline);
                    foreach (Match m_element in mc_elements)
                    {
                        Dictionary<string, string> elementAttributes = ParseAttributes(m_element.Groups["attributes"].Value);
                        string elementName;
                        string elementType;
                        if (!elementAttributes.TryGetValue("name", out elementName))
                            continue;
                        if (!elementAttributes.TryGetValue("type", out elementType))
                            continue;
                        current_type.elements.Add(elementName, elementType);
                    }
                    types.Add(current_type.name, current_type);
                }
                else if (typeKind == "simple")
                {
                    Match m_maxLength = Regex.Match(typeBody, @"<xsd:restriction[^>]+>.+?<xsd:maxLength.+?value=""(?<maxLength>[^""]+)""", RegexOptions.Singleline);
                    if (m_maxLength.Success)
                    {
                        string maxLength = m_maxLength.Groups["maxLength"].Value;
                        SimpleType current_type = new SimpleType(typeName);
                        current_type.maxLength = maxLength;
                        types.Add(current_type.name, current_type);
                    }
                }
            }
            else
            {
                continue;
            }
        }
        return types;
    }

    private static Dictionary<string, string> ParseAttributes(string value)
    {
        Dictionary<string, string> attributes = new Dictionary<string, string>();
        MatchCollection mc_attributes = Regex.Matches(value, @"(?<name>[^=\s\t]+)[\s\t]*=[\s\t]*""(?<value>[^""]+)""", RegexOptions.Singleline);
        foreach (Match m_attribute in mc_attributes)
        {
            attributes.Add(m_attribute.Groups["name"].Value, m_attribute.Groups["value"].Value);
        }
        return attributes;
    }

}

public class SimpleType : XsdType
{

    public string maxLength;

    public SimpleType(string name)
        : base(name)
    {
    }

}

public class ComplexType : XsdType
{

    //(name-type)
    public Dictionary<string, string> elements = new Dictionary<string,string>();

    public ComplexType(string name)
        : base(name)
    {
    }

}
于 2012-07-19T23:01:08.563 に答える