在运行时从类的实例创建xsd模式

Question

我需要验证一些常规的传感器输入。要求是，验证不能在我的代码中进行，而需要使用代码库外部的外部验证器（如xsd）来使用户能够交换验证逻辑，而无需编写或重新编译应用程序。我知道传感器输入仅对一种特定情况有效，因此希望从运行时存在的，经过用户验证的类的实例生成xsd，以获取有效限制。

我尝试过this中的想法，但是这仅适用于类型，不适用于类的实例。

因此，我的问题：是否有办法采用C＃类的运行时实例并将其转换为具有属性值作为唯一有效限制的xsd？

更新：

澄清一下：我所拥有的是这样的课程：

public sealed class Sensor
    {
        public int Data { get; set; }

        public int otherData { get; set; }

        public int MoreData { get; set; }
    }

该类在某处得到实例化（例如：）：

var se = new Sensor()
            {
                Data = 5,
                otherData = 10,
                MoreData = 15
            };

当我现在尝试使用类似以下功能的东西创建xsd时：

var schemas = new XmlSchemas();
var exporter = new XmlSchemaExporter(schemas);
var mapping = new XmlReflectionImporter().ImportTypeMapping(typeof(Person));
exporter.ExportTypeMapping(mapping);
var schemaWriter = new StringWriter();
foreach (XmlSchema schema in schemas)
{
    schema.Write(schemaWriter);
}
return schemaWriter.ToString();

我收到这样的xsd：

<?xml version="1.0" encoding="utf-8"?>
    <xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
      <xs:element name="sensor">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="Data" type="xs:integer" />
            <xs:element name="otherData" type="xs:integer" />
            <xs:element name="moreData" type="xs:integer" />
          </xs:sequence>
        </xs:complexType>
      </xs:element>
    </xs:schema>

但是这与我要归档的文件相去甚远。我想在其中建立适当的限制（它应该看起来像这样）：

<?xml version="1.0" encoding="utf-8"?>
        <xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
          <xs:element name="sensor">
            <xs:complexType>
              <xs:sequence>
                <xs:element name="Data">
                    <xs:simpleType>
                        <xs:restriction base="xs:integer">
                            <xs:enumeration value="5"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
                <xs:element name="otherData">
                    <xs:simpleType>
                        <xs:restriction base="xs:integer">
                            <xs:enumeration value="10"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
                <xs:element name="moreData">
                    <xs:simpleType>
                        <xs:restriction base="xs:integer">
                            <xs:enumeration value="15"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
              </xs:sequence>
            </xs:complexType>
          </xs:element>
        </xs:schema>

我显然可以继续将生成的文件加载到内存中，剥离一些属性并更改xsd的外观，但是由于以下原因，这感觉不对：

1. 由我定义规则，使xsd看起来像我带走一样我想拥有的灵活性。
2. 这种方法对我来说似乎很容易出错，因为它似乎比直接字符串操作要好一些。
3. 此额外的代码会使我本来就很大的代码变得更加复杂和难以理解。

总结：我需要一个库或一个非常聪明的函数，它可以基于我在类上拥有的runitme信息来创建像上面那样的xsd，而无需编写很多直接操作xml的东西。以避免对以后使用验证容易出错或错误的假设。

Answer 1

我采用了您的生成架构，并使用Xml Linq添加了详细信息。参见下面的代码

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Serialization;
using System.Xml.Schema;
using System.IO;

namespace ConsoleApplication131
{
    class Program
    {
        const string FILENAME = @"c:\temp\test.xml";
        static void Main(string[] args)
        {
            Sensor se = new Sensor()
            {
                Data = 5,
                otherData = 10,
                MoreData = 15
            };

            XmlSchemas schemas = new XmlSchemas();
            XmlSchemaExporter exporter = new XmlSchemaExporter(schemas);
            XmlTypeMapping mapping = new XmlReflectionImporter().ImportTypeMapping(typeof(Sensor));
            exporter.ExportTypeMapping(mapping);
            StringWriter schemaWriter = new StringWriter();
            foreach (XmlSchema schema in schemas)
            {
                schema.Write(schemaWriter);
            }
            XDocument doc = XDocument.Parse(schemaWriter.ToString());
            XElement root = doc.Root;
            XNamespace xs = root.GetNamespaceOfPrefix("xs");

            foreach (XElement _class in doc.Descendants(xs + "complexType"))
            {
                List<XElement> elements = _class.Descendants(xs + "element").ToList();
                if (elements.Count > 0)
                {
                    XElement complexType = new XElement(xs + "complexType");
                    _class.Add(complexType);
                    XElement sequence = new XElement(xs + "sequence");
                    complexType.Add(sequence);

                    foreach (var prop in se.GetType().GetProperties())
                    {
                        string name = prop.Name;
                        string value = prop.GetValue(se, null).ToString();
                        XElement element = elements.Where(x => (string)x.Attribute("name") == name).FirstOrDefault();
                        string strType = (string)element.Attribute("type");

                        XElement newElement = new XElement(xs + "simpleType", new object[] {
                        new XElement(xs + "restriction", new object[] {
                            new XAttribute("base", strType),
                            new XElement(xs + "enumeration", new XAttribute("value", value))
                        })
                    });
                        sequence.Add(newElement);

                    }
                }
            }
            doc.Save(FILENAME);

        }
    }
    public sealed class Sensor
    {
        public int Data { get; set; }
        public int otherData { get; set; }
        public int MoreData { get; set; }
    }

}