public XmlSchemaElement GetSchema()
        {
            var type = new XmlSchemaComplexType();

            type.Attributes.Add(new XmlSchemaAttribute
                                    {
                                        Name = "refValue",
                                        Use = XmlSchemaUse.Required,
                                        SchemaTypeName =
                                            new XmlQualifiedName("positiveInteger", "http://www.w3.org/2001/XMLSchema")
                                    });

            type.Attributes.Add(new XmlSchemaAttribute
                                    {
                                        Name = "test",
                                        Use = XmlSchemaUse.Optional,
                                        SchemaTypeName =
                                            new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema")
                                    });

            
            var restriction = new XmlSchemaSimpleTypeRestriction
                                  {
                                      BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema")
                                  };

            restriction.Facets.Add(new XmlSchemaEnumerationFacet {Value = "years"});
            restriction.Facets.Add(new XmlSchemaEnumerationFacet {Value = "weeks"});
            restriction.Facets.Add(new XmlSchemaEnumerationFacet {Value = "days"});

            var simpleType = new XmlSchemaSimpleType {Content = restriction};


            type.Attributes.Add(new XmlSchemaAttribute
                                    {
                                        Name = "units",
                                        Use = XmlSchemaUse.Required,
                                        SchemaType = simpleType
                                    });


            type.Attributes.Add(new XmlSchemaAttribute
                                    {
                                        Name = "expressionLanguage",
                                        Use = XmlSchemaUse.Optional,
                                        SchemaTypeName =
                                            new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema")
                                    });

            var element = new XmlSchemaElement
                              {
                                  Name = "dicom-age-less-than",
                                  SchemaType = type
                              };

            return element;
        }

    private void CreateSimpletypeLength(string length, string minLength, string maxLength, bool expected) {
      passed = true;

      XmlSchema schema = new XmlSchema();

      XmlSchemaSimpleType testType = new XmlSchemaSimpleType();
      testType.Name = "TestType";

      XmlSchemaSimpleTypeRestriction testTypeRestriction = new XmlSchemaSimpleTypeRestriction();
      testTypeRestriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

      if (length != "-") {
        XmlSchemaLengthFacet _length = new XmlSchemaLengthFacet();
        _length.Value = length;
        testTypeRestriction.Facets.Add(_length);
      }
      if (minLength != "-") {
        XmlSchemaMinLengthFacet _minLength = new XmlSchemaMinLengthFacet();
        _minLength.Value = minLength;
        testTypeRestriction.Facets.Add(_minLength);
      }
      if (maxLength != "-") {
        XmlSchemaMaxLengthFacet _maxLength = new XmlSchemaMaxLengthFacet();
        _maxLength.Value = maxLength;
        testTypeRestriction.Facets.Add(_maxLength);
      }

      testType.Content = testTypeRestriction;
      schema.Items.Add(testType);
      schema.Compile(new ValidationEventHandler(ValidationCallbackOne));

      Assert.IsTrue (expected == passed, (passed ? "Test passed, should have failed" : "Test failed, should have passed") + ": " + length + " " + minLength + " " + maxLength);
      
    }

 protected override void Visit(XmlSchemaSimpleType type)
 {
     if (type.QualifiedName.IsEmpty)
         Traverse(type.Content);
     else
         AddLeaf(SimpleTypeStructureNodeType.NamedType, type);
 }

        /// <summary>
        /// Create an XmlQueryType from an Xsd simple type (where variety can be Atomic, List, or Union).
        /// </summary>
        /// <param name="schemaType">the simple Xsd schema type of the atomic value</param>
        /// <param name="isStrict">true if the dynamic type is guaranteed to match the static type exactly</param>
        /// <returns>the atomic value type</returns>
        public static XmlQueryType Type(XmlSchemaSimpleType schemaType, bool isStrict) {
            if (schemaType.Datatype.Variety == XmlSchemaDatatypeVariety.Atomic) {
                // We must special-case xs:anySimpleType because it is broken in Xsd and is sometimes treated as
                // an atomic value and sometimes as a list value.  In XQuery, it always maps to xdt:anyAtomicType*.
                if (schemaType == DatatypeImplementation.AnySimpleType)
                    return AnyAtomicTypeS;

                return ItemType.Create(schemaType, isStrict);
            }

            // Skip restrictions. It is safe to do that because this is a list or union, so it's not a build in type
            while (schemaType.DerivedBy == XmlSchemaDerivationMethod.Restriction)
                schemaType = (XmlSchemaSimpleType) schemaType.BaseXmlSchemaType;

            // Convert Xsd list
            if (schemaType.DerivedBy == XmlSchemaDerivationMethod.List)
                return PrimeProduct(Type(((XmlSchemaSimpleTypeList) schemaType.Content).BaseItemType, isStrict), XmlQueryCardinality.ZeroOrMore);

            // Convert Xsd union
            Debug.Assert(schemaType.DerivedBy == XmlSchemaDerivationMethod.Union);
            XmlSchemaSimpleType[] baseMemberTypes = ((XmlSchemaSimpleTypeUnion) schemaType.Content).BaseMemberTypes;
            XmlQueryType[] queryMemberTypes = new XmlQueryType[baseMemberTypes.Length];

            for (int i = 0; i < baseMemberTypes.Length; i++)
                queryMemberTypes[i] = Type(baseMemberTypes[i], isStrict);

            return Choice(queryMemberTypes);
        }

        private XmlSchemaSimpleType CreateGuidType()
        {
            var type = new XmlSchemaSimpleType { Name = "Guid" };

            var restriction = new XmlSchemaSimpleTypeRestriction { BaseType = XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String) };
            restriction.Facets.Add(new XmlSchemaPatternFacet
            {
                Value =
                    @"[{(]?[0-9A-Fa-f]{8}\-?[0-9A-Fa-f]{4}\-?[0-9A-Fa-f]{4}\-?[0-9A-Fa-f]{4}\-?[0-9A-Fa-f]{12}[})]?|([!$])(\(var|\(loc|\(wix)\.[_A-Za-z][0-9A-Za-z_.]*\)"
            });
            type.Content = restriction;
            return type;
        }

        public override void FixtureInit()
        {
            XmlSchemaCompletionCollection schemas = new XmlSchemaCompletionCollection();
            schemas.Add(SchemaCompletion);
            XmlSchemaCompletion xsdSchemaCompletionData = new XmlSchemaCompletion(ResourceManager.ReadXsdSchema());
            schemas.Add(xsdSchemaCompletionData);

            string xml = GetSchema();
            int index = xml.IndexOf("type=\"dir\"/>");
            index = xml.IndexOf("dir", index);
            XmlSchemaDefinition schemaDefinition = new XmlSchemaDefinition(schemas, SchemaCompletion);
            schemaSimpleType = (XmlSchemaSimpleType)schemaDefinition.GetSelectedSchemaObject(xml, index);
        }

        public override void FixtureInit()
        {
            XmlSchemaCompletionDataCollection schemas = new XmlSchemaCompletionDataCollection();
            schemas.Add(SchemaCompletionData);
            XmlSchemaCompletionData xsdSchemaCompletionData = new XmlSchemaCompletionData(ResourceManager.GetXsdSchema());
            schemas.Add(xsdSchemaCompletionData);
            XmlCompletionDataProvider provider = new XmlCompletionDataProvider(schemas, xsdSchemaCompletionData, String.Empty);

            string xml = GetSchema();
            int index = xml.IndexOf("type=\"dir\"/>");
            index = xml.IndexOf("dir", index);
            schemaSimpleType = (XmlSchemaSimpleType)XmlView.GetSchemaObjectSelected(xml, index, provider, SchemaCompletionData);
        }

        protected override void Visit(XmlSchemaSimpleType type)
        {
            if (type.QualifiedName.IsEmpty)
                base.Visit(type);
            else
            {
                if (!AddUsage(type))
                    return;

                PushNamedObject(type);
                base.Visit(type);
                PopNamedObject();
            }
        }

        public static XmlSchemaSimpleType ResolveType(this XmlSchemaSet schemaSet, XmlSchemaSimpleType type, XmlQualifiedName typeName)
        {
            if (type != null)
                return type;

            var resolvedType = schemaSet.GlobalTypes[typeName] as XmlSchemaSimpleType;
            if (resolvedType != null)
                return resolvedType;

            var builtInSimpleType = XmlSchemaType.GetBuiltInSimpleType(typeName);
            if (builtInSimpleType != null)
                return builtInSimpleType;

            return null;
        }

 private TypeDesc GetDataTypeSource(XmlSchemaSimpleType dataType)
 {
     if ((dataType.Name != null) && (dataType.Name.Length != 0))
     {
         TypeDesc typeDesc = base.Scope.GetTypeDesc(dataType);
         if (typeDesc != null)
         {
             return typeDesc;
         }
     }
     if (!dataType.DerivedFrom.IsEmpty)
     {
         return this.GetDataTypeSource(this.FindDataType(dataType.DerivedFrom));
     }
     return base.Scope.GetTypeDesc(typeof(string));
 }

 internal SimpleType(XmlSchemaSimpleType node)
 {
     this.name = "";
     this.length = -1;
     this.minLength = -1;
     this.maxLength = -1;
     this.pattern = "";
     this.ns = "";
     this.maxExclusive = "";
     this.maxInclusive = "";
     this.minExclusive = "";
     this.minInclusive = "";
     this.enumeration = "";
     this.name = node.Name;
     this.ns = (node.QualifiedName != null) ? node.QualifiedName.Namespace : "";
     this.LoadTypeValues(node);
 }

 private static void AddNonXsdPrimitive(Type type, string dataTypeName, string ns, string formatterName, XmlQualifiedName baseTypeName, XmlSchemaFacet[] facets, TypeFlags flags)
 {
     XmlSchemaSimpleType dataType = new XmlSchemaSimpleType {
         Name = dataTypeName
     };
     XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction {
         BaseTypeName = baseTypeName
     };
     foreach (XmlSchemaFacet facet in facets)
     {
         restriction.Facets.Add(facet);
     }
     dataType.Content = restriction;
     TypeDesc desc = new TypeDesc(type, false, dataType, formatterName, flags);
     if (primitiveTypes[type] == null)
     {
         primitiveTypes.Add(type, desc);
     }
     primitiveDataTypes.Add(dataType, desc);
     primitiveNames.Add(dataTypeName, ns, desc);
 }

 string CreateProtoSimpleType(XmlSchemaSimpleType simpleType) {
     if (simpleType.QualifiedName.Namespace == XmlSchema.Namespace) {
         return CreateProtoXsdType(simpleType.QualifiedName.Name);
     } else if ((simpleType.Content as XmlSchemaSimpleTypeRestriction) != null) {
         var facets = (simpleType.Content as XmlSchemaSimpleTypeRestriction).Facets.OfType<XmlSchemaFacet>();
         foreach (var facet in facets) {
             if ((facet as XmlSchemaEnumerationFacet) != null) {
                 return (facet as XmlSchemaEnumerationFacet).Value;
             } else if ((facet as XmlSchemaMinInclusiveFacet) != null) {
                 return (facet as XmlSchemaMinInclusiveFacet).Value;
             } else if ((facet as XmlSchemaMaxLengthFacet) != null) {
                 return (facet as XmlSchemaMaxLengthFacet).Value;
             }
         }
         throw new Exception("not implemented");
     } else if ((simpleType.Content as XmlSchemaSimpleTypeUnion) != null) {
         return CreateProtoSimpleType((simpleType.Content as XmlSchemaSimpleTypeUnion).BaseMemberTypes.First());
     } else {
         throw new Exception("not implemented");
     }
 }

        /// <summary>
        ///     Returns a SimpleType restricted by the datatype only
        /// </summary>
        public override XmlSchemaSimpleType GetSimpleType(string attributeDataType)
        {
            var retVal = new XmlSchemaSimpleType();

            // <xs:restriction base="<whatever xs:datatype is required>" />
            var dataTypeRestriction = new XmlSchemaSimpleTypeRestriction
            {
                BaseTypeName = new XmlQualifiedName(attributeDataType)
            };
            retVal.Content = dataTypeRestriction;

            //  if the property type is an enum then add an enumeration facet to the simple type
            if (Property.PropertyType.IsEnum)
            {
                // <xs:enumeration value="123" />
                foreach (var enumValue in Enum.GetNames(Property.PropertyType))
                {
                    var enumFacet = new XmlSchemaEnumerationFacet { Value = enumValue };
                    dataTypeRestriction.Facets.Add(enumFacet);
                }
            }

            return retVal;
        }

 internal void SetAttributeType(XmlSchemaSimpleType value) { 
     attributeType = value;
 }

 private static void CleanupSimpleType(XmlSchemaSimpleType simpleType)
 {
     simpleType.ElementDecl = null;
 }

 private void CheckUnionType(XmlSchemaSimpleType unionMember, ArrayList memberTypeDefinitions, XmlSchemaSimpleType parentType)
 {
     XmlSchemaDatatype datatype = unionMember.Datatype;
     if ((unionMember.DerivedBy == XmlSchemaDerivationMethod.Restriction) && (datatype.HasLexicalFacets || datatype.HasValueFacets))
     {
         base.SendValidationEvent("Sch_UnionFromUnion", parentType);
     }
     else
     {
         Datatype_union _union = unionMember.Datatype as Datatype_union;
         memberTypeDefinitions.AddRange(_union.BaseMemberTypes);
     }
 }

 private void CompileSimpleType(XmlSchemaSimpleType simpleType)
 {
     if (simpleType.IsProcessing)
     {
         throw new XmlSchemaException("Sch_TypeCircularRef", simpleType);
     }
     if (simpleType.ElementDecl == null)
     {
         simpleType.IsProcessing = true;
         try
         {
             if (simpleType.Content is XmlSchemaSimpleTypeList)
             {
                 XmlSchemaDatatype datatype;
                 XmlSchemaSimpleTypeList content = (XmlSchemaSimpleTypeList) simpleType.Content;
                 simpleType.SetBaseSchemaType(DatatypeImplementation.AnySimpleType);
                 if (content.ItemTypeName.IsEmpty)
                 {
                     this.CompileSimpleType(content.ItemType);
                     content.BaseItemType = content.ItemType;
                     datatype = content.ItemType.Datatype;
                 }
                 else
                 {
                     XmlSchemaSimpleType type = this.GetSimpleType(content.ItemTypeName);
                     if (type == null)
                     {
                         throw new XmlSchemaException("Sch_UndeclaredSimpleType", content.ItemTypeName.ToString(), simpleType);
                     }
                     if ((type.FinalResolved & XmlSchemaDerivationMethod.List) != XmlSchemaDerivationMethod.Empty)
                     {
                         base.SendValidationEvent("Sch_BaseFinalList", simpleType);
                     }
                     content.BaseItemType = type;
                     datatype = type.Datatype;
                 }
                 simpleType.SetDatatype(datatype.DeriveByList(simpleType));
                 simpleType.SetDerivedBy(XmlSchemaDerivationMethod.List);
             }
             else if (simpleType.Content is XmlSchemaSimpleTypeRestriction)
             {
                 XmlSchemaDatatype datatype2;
                 XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction) simpleType.Content;
                 if (restriction.BaseTypeName.IsEmpty)
                 {
                     this.CompileSimpleType(restriction.BaseType);
                     simpleType.SetBaseSchemaType(restriction.BaseType);
                     datatype2 = restriction.BaseType.Datatype;
                 }
                 else if ((simpleType.Redefined != null) && (restriction.BaseTypeName == simpleType.Redefined.QualifiedName))
                 {
                     this.CompileSimpleType((XmlSchemaSimpleType) simpleType.Redefined);
                     simpleType.SetBaseSchemaType(simpleType.Redefined.BaseXmlSchemaType);
                     datatype2 = simpleType.Redefined.Datatype;
                 }
                 else
                 {
                     if (restriction.BaseTypeName.Equals(DatatypeImplementation.QnAnySimpleType))
                     {
                         throw new XmlSchemaException("Sch_InvalidSimpleTypeRestriction", restriction.BaseTypeName.ToString(), simpleType);
                     }
                     XmlSchemaSimpleType type2 = this.GetSimpleType(restriction.BaseTypeName);
                     if (type2 == null)
                     {
                         throw new XmlSchemaException("Sch_UndeclaredSimpleType", restriction.BaseTypeName.ToString(), simpleType);
                     }
                     if ((type2.FinalResolved & XmlSchemaDerivationMethod.Restriction) != XmlSchemaDerivationMethod.Empty)
                     {
                         base.SendValidationEvent("Sch_BaseFinalRestriction", simpleType);
                     }
                     simpleType.SetBaseSchemaType(type2);
                     datatype2 = type2.Datatype;
                 }
                 simpleType.SetDatatype(datatype2.DeriveByRestriction(restriction.Facets, base.NameTable, simpleType));
                 simpleType.SetDerivedBy(XmlSchemaDerivationMethod.Restriction);
             }
             else
             {
                 XmlSchemaSimpleType[] types = this.CompileBaseMemberTypes(simpleType);
                 simpleType.SetBaseSchemaType(DatatypeImplementation.AnySimpleType);
                 simpleType.SetDatatype(XmlSchemaDatatype.DeriveByUnion(types, simpleType));
                 simpleType.SetDerivedBy(XmlSchemaDerivationMethod.Union);
             }
         }
         catch (XmlSchemaException exception)
         {
             if (exception.SourceSchemaObject == null)
             {
                 exception.SetSource(simpleType);
             }
             base.SendValidationEvent(exception);
             simpleType.SetDatatype(DatatypeImplementation.AnySimpleType.Datatype);
         }
         finally
         {
             SchemaElementDecl decl = new SchemaElementDecl {
                 ContentValidator = ContentValidator.TextOnly,
                 SchemaType = simpleType,
                 Datatype = simpleType.Datatype
             };
//.........这里部分代码省略.........

 private XmlSchemaSimpleType[] CompileBaseMemberTypes(XmlSchemaSimpleType simpleType)
 {
     ArrayList memberTypeDefinitions = new ArrayList();
     XmlSchemaSimpleTypeUnion content = (XmlSchemaSimpleTypeUnion) simpleType.Content;
     XmlQualifiedName[] memberTypes = content.MemberTypes;
     if (memberTypes != null)
     {
         for (int i = 0; i < memberTypes.Length; i++)
         {
             XmlSchemaSimpleType unionMember = this.GetSimpleType(memberTypes[i]);
             if (unionMember == null)
             {
                 throw new XmlSchemaException("Sch_UndeclaredSimpleType", memberTypes[i].ToString(), simpleType);
             }
             if (unionMember.Datatype.Variety == XmlSchemaDatatypeVariety.Union)
             {
                 this.CheckUnionType(unionMember, memberTypeDefinitions, simpleType);
             }
             else
             {
                 memberTypeDefinitions.Add(unionMember);
             }
             if ((unionMember.FinalResolved & XmlSchemaDerivationMethod.Union) != XmlSchemaDerivationMethod.Empty)
             {
                 base.SendValidationEvent("Sch_BaseFinalUnion", simpleType);
             }
         }
     }
     XmlSchemaObjectCollection baseTypes = content.BaseTypes;
     if (baseTypes != null)
     {
         for (int j = 0; j < baseTypes.Count; j++)
         {
             XmlSchemaSimpleType type2 = (XmlSchemaSimpleType) baseTypes[j];
             this.CompileSimpleType(type2);
             if (type2.Datatype.Variety == XmlSchemaDatatypeVariety.Union)
             {
                 this.CheckUnionType(type2, memberTypeDefinitions, simpleType);
             }
             else
             {
                 memberTypeDefinitions.Add(type2);
             }
         }
     }
     content.SetBaseMemberTypes(memberTypeDefinitions.ToArray(typeof(XmlSchemaSimpleType)) as XmlSchemaSimpleType[]);
     return content.BaseMemberTypes;
 }

 internal static XmlSchema GetBuildInSchema()
 {
     if (builtInSchemaForXmlNS == null)
     {
         XmlSchema schema = new XmlSchema {
             TargetNamespace = "http://www.w3.org/XML/1998/namespace"
         };
         schema.Namespaces.Add("xml", "http://www.w3.org/XML/1998/namespace");
         XmlSchemaAttribute item = new XmlSchemaAttribute {
             Name = "lang",
             SchemaTypeName = new XmlQualifiedName("language", "http://www.w3.org/2001/XMLSchema")
         };
         schema.Items.Add(item);
         XmlSchemaAttribute attribute2 = new XmlSchemaAttribute {
             Name = "base",
             SchemaTypeName = new XmlQualifiedName("anyURI", "http://www.w3.org/2001/XMLSchema")
         };
         schema.Items.Add(attribute2);
         XmlSchemaAttribute attribute3 = new XmlSchemaAttribute {
             Name = "space"
         };
         XmlSchemaSimpleType type = new XmlSchemaSimpleType();
         XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction {
             BaseTypeName = new XmlQualifiedName("NCName", "http://www.w3.org/2001/XMLSchema")
         };
         XmlSchemaEnumerationFacet facet = new XmlSchemaEnumerationFacet {
             Value = "default"
         };
         restriction.Facets.Add(facet);
         XmlSchemaEnumerationFacet facet2 = new XmlSchemaEnumerationFacet {
             Value = "preserve"
         };
         restriction.Facets.Add(facet2);
         type.Content = restriction;
         attribute3.SchemaType = type;
         attribute3.DefaultValue = "preserve";
         schema.Items.Add(attribute3);
         XmlSchemaAttributeGroup group = new XmlSchemaAttributeGroup {
             Name = "specialAttrs"
         };
         XmlSchemaAttribute attribute4 = new XmlSchemaAttribute {
             RefName = new XmlQualifiedName("lang", "http://www.w3.org/XML/1998/namespace")
         };
         group.Attributes.Add(attribute4);
         XmlSchemaAttribute attribute5 = new XmlSchemaAttribute {
             RefName = new XmlQualifiedName("space", "http://www.w3.org/XML/1998/namespace")
         };
         group.Attributes.Add(attribute5);
         XmlSchemaAttribute attribute6 = new XmlSchemaAttribute {
             RefName = new XmlQualifiedName("base", "http://www.w3.org/XML/1998/namespace")
         };
         group.Attributes.Add(attribute6);
         schema.Items.Add(group);
         schema.IsPreprocessed = true;
         schema.CompileSchemaInSet(new NameTable(), null, null);
         Interlocked.CompareExchange<XmlSchema>(ref builtInSchemaForXmlNS, schema, null);
     }
     return builtInSchemaForXmlNS;
 }