C# EdmVersion类代码示例

        private void CsdlXElementComparer(IEnumerable<XElement> expectedCsdls, IEnumerable<XElement> actualCsdls, EdmVersion version)
        {
            var updatedExpectedCsdls = ModelBuilderHelpers.ReplaceCsdlNamespacesForEdmVersion(expectedCsdls.ToArray(), version);
            var updatedActualCsdls = ModelBuilderHelpers.ReplaceCsdlNamespacesForEdmVersion(actualCsdls.ToArray(), version);

            new ConstructiveApiCsdlXElementComparer().Compare(updatedExpectedCsdls.ToList(), updatedActualCsdls.ToList());
        }

        public static XElement[] InvalidEntitySetNameReference(EdmVersion edmVersion)
        {
            const string csdl =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""Bork"" Alias=""Self"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
  <EntityType Name=""Entity1"">
    <Key>
        <PropertyRef Name=""Id"" />
    </Key>
    <Property Name=""Id"" Type=""Int32"" Nullable=""false""/>
    <Property Name=""OtherId"" Type=""Int32"" />
    <NavigationProperty Name=""Navigation"" Type=""Bork.Entity2"" Nullable=""false"" Partner=""Navigation"" /> 
  </EntityType>
  <EntityType Name=""Entity2"">
    <Key>
        <PropertyRef Name=""Id"" />
    </Key>
    <Property Name=""Id"" Type=""Int32"" Nullable=""false""/>
    <Property Name=""OtherId"" Type=""Int32"" Nullable=""false""/> 
    <NavigationProperty Name=""Navigation"" Type=""Collection(Bork.Entity1)"" Partner=""Navigation"" /> 
  </EntityType>
  <EntityContainer Name=""Container"">
    <EntitySet Name=""Entity1_a"" EntityType=""Bork.Entity1"">
      <NavigationPropertyBinding Path=""Navigation"" Target=""Entity2_b"" />
    </EntitySet>
    <EntitySet Name=""Entity2_a"" EntityType=""Bork.Entity2"">
      <NavigationPropertyBinding Path=""Navigation"" Target=""Entity1_b"" />
    </EntitySet>
  </EntityContainer>
</Schema>";
            return FixUpWithEdmVersion(csdl, edmVersion);
        }

        /// <summary>
        /// Serializes the <paramref name="schema"/> in the specified <paramref name="csdlVersion"/> and returns it.
        /// </summary>
        /// <param name="csdlVersion">The CSDL version to use for serializing the entity model schema.</param>
        /// <param name="schema">The schema to serialize.</param>
        /// <returns>The serialized <paramref name="schema"/>.</returns>
        public IEnumerable<FileContents<XElement>> Serialize(EdmVersion csdlVersion, EntityModelSchema schema)
        {
            ExceptionUtilities.Assert(schema != null, "schema != null");

            // TODO: Can we inherit from the default implemenation of the CSDL content generator instead of doing this in a separate step?
            schema = this.ODataAnnotationConverter.ConvertToProductAnnotations(schema);
            return this.BaseEntityModelSchemaSerializer.Generate(csdlVersion, schema);
        }

 public void ParserSimpleIdentifierTypeReferenceCsdlSchemaCompliantTest()
 {
     var edmVersions = new EdmVersion[] { EdmVersion.V40 };
     foreach (var edmVersion in edmVersions)
     {
         this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ConcurrencyModeTypes(edmVersion), edmVersion);
         this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.CollectionTypeTypeRefSimpleTypeCanHaveFacets(edmVersion), edmVersion);
     }
 }

 public void ParserOpenTypeSupportCsdlSchemaCompliantTest()
 {
     var edmVersions = new EdmVersion[] { EdmVersion.V40 };
     foreach (var edmVersion in edmVersions)
     {
         this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.OpenTypeSupportInV40(edmVersion), edmVersion);
         this.BasicXsdValidationTestForParserInputCsdl(ODataTestModelBuilder.ODataTestModelWithOpenType, edmVersion);
     }
 }

        public static IEdmModel OperationsWithReturnTypeOfPrimitiveDataTypeSchemasEdm(EdmVersion edmVersion)
        {
            var model = new EdmModel();
            foreach (var function in OperationTestModelBuilder.EdmFunctionsWithReturnTypePrimitiveDataType(edmVersion))
            {
                model.AddElement(function);
            }

            return model;
        }

        public static IEnumerable<IEdmPrimitiveTypeReference> AllPrimitiveEdmTypes(EdmVersion edmVersion, bool isNullable)
        {
            IEnumerable<IEdmPrimitiveTypeReference> primitiveTypes = AllNonSpatialPrimitiveEdmTypes(isNullable);
            if (edmVersion >= EdmVersion.V40)
            {
                primitiveTypes = primitiveTypes.Concat(AllSpatialEdmTypes(isNullable));
            }

            return primitiveTypes;
        }

        public static IEdmModel OperationsWith2ParametersSchemasEdm(EdmVersion edmVersion)
        {
            var model = new EdmModel();
            foreach (var operation in OperationTestModelBuilder.EdmOperationsWith2Parameters(edmVersion))
            {
                model.AddElement(operation);
            }

            return model;
        }

 public void ParserComplexTypeWithBaseTypeAbstractCsdlSchemaCompliantTest()
 {
     var edmVersions = new EdmVersion[] { EdmVersion.V40 };
     foreach (var edmVersion in edmVersions)
     {
         this.BasicXsdValidationTestForParserInputCsdl(ModelBuilder.ComplexTypeWithBaseType(edmVersion), edmVersion);
         this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ComplexTypeBaseTypeSupportInV11(edmVersion), edmVersion);
         this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.EdmComplexTypeInvalidIsPolymorphic(edmVersion), edmVersion);
         this.BasicXsdValidationTestForParserInputCsdl(ValidationTestModelBuilder.ComplexTypeIsAbstractSupportInV40(edmVersion), edmVersion);
     }
 }

 public static XNamespace GetCsdlFullNamespace(EdmVersion csdlVersion)
 {
     if (csdlVersion == EdmVersion.V40)
     {
         return EdmConstants.EdmOasisNamespace;
     }
     else
     {
         throw new ArgumentOutOfRangeException("CSDL Schema Version is not supported: " + csdlVersion.ToString());
     }
 }

 public static IEnumerable<XElement> ReplaceCsdlNamespacesForEdmVersion(XElement[] csdls, EdmVersion edmVersion)
 {
     var edmNamespace = EdmLibCsdlContentGenerator.GetCsdlFullNamespace(edmVersion);
     for (int i = 0; i < csdls.Count(); ++i)
     {
         if (edmNamespace != csdls[i].Name.Namespace)
         {
             csdls[i] = XElement.Parse(csdls[i].ToString().Replace(csdls[i].Name.Namespace.NamespaceName, edmNamespace.NamespaceName));
         }
     }
     return csdls;
 }

 public static EdmVersion GetEdmVersion(XNamespace edmNamespace)
 {
     var edmVersions = new EdmVersion[] { EdmVersion.V40 };
     foreach (var edmVersion in edmVersions)
     {
         if (GetCsdlFullNamespace(edmVersion) == edmNamespace)
         {
             return edmVersion;
         }
     }
     throw new ArgumentOutOfRangeException("The namespace is not a EDM namespace " + edmNamespace.NamespaceName);
 }

        public static XElement[] SystemNamespace(EdmVersion edmVersion)
        {
            const string csdl =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<Schema Namespace=""Edm"" Alias=""Self"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
  <EntityType Name=""Clod"">
    <Key>
        <PropertyRef Name=""Id"" />
    </Key>
    <Property Name=""Id"" Type=""Int32"" Nullable=""false""/>
    <Property Name=""Bar"" Type=""Int32"" />
  </EntityType>
</Schema>";
            return FixUpWithEdmVersion(csdl, edmVersion);
        }

        private void GenerateContentsWithoutDefinition(EdmVersion edmVersion, IEdmModel definitionModel)
        {
            IEnumerable<EdmError> errors;
            var contentsWithoutDefinition = this.GetSerializerResult(definitionModel, edmVersion, out errors).Select(XElement.Parse);

            var stripTheseElements = new[] { "Term", "Annotations", "Annotation"};

            foreach (var contents in contentsWithoutDefinition)
            {
                contents.Descendants().Where(e => stripTheseElements.Contains(e.Name.LocalName)).Remove();

                string namespaceName = contents.Attribute("Namespace").Value;
                this.namespaceToContents.Add(namespaceName, contents);
            }
        }

 public static string ReplaceCsdlNamespaceForEdmVersion(string csdl, EdmVersion edmVersion)
 {
     var edmNamespace = EdmLibCsdlContentGenerator.GetCsdlFullNamespace(edmVersion);
     var xmlReader = XmlReader.Create(new StringReader(csdl));
     while (xmlReader.Read())
     {
         if (xmlReader.Name == "Schema")
         {
             break;
         }
     }
     if (xmlReader.EOF)
     {
         throw new ArgumentException("{0} is not a well formed CSDL.");
     }
     return csdl.Replace(xmlReader.NamespaceURI, edmNamespace.NamespaceName);
 }