private IEdmModel LoadModel()
{
var xmlTextReader = new XmlTextReader(GetMetadataUri().ToString());
IEdmModel model = EdmxReader.Parse(xmlTextReader);
return(model);
}
public static void Register(HttpConfiguration config)
{
var model2 = EdmxReader.Parse(XmlReader.Create("http://localhost:9091/odata/$metadata"));
var model = new EdmModel();
model.AddReferencedModel(model2);
var reference = new EdmReference("http://localhost:9091/odata/$metadata");
reference.AddInclude(new EdmInclude("Model2", "SampleService2.Models"));
model.SetEdmReferences(new List <IEdmReference> {
reference
});
var container = new EdmEntityContainer("NS1", "Default");
var order = model2.FindDeclaredType("SampleService2.Models.Order") as IEdmEntityType;
model2.SetAnnotationValue <ClrTypeAnnotation>(order, new ClrTypeAnnotation(typeof(Order)));
container.AddEntitySet("Orders", order);
model.AddElement(container);
var product = new EdmEntityType("NS1", "Product");
product.AddKeys(product.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
product.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
model.AddElement(product);
config.MapODataServiceRoute("odata", "odata", model);
}
public void FindVocabularyAnnotationInParallel()
{
int annotationCount = 30;
var edmModel = new EdmParModel().Model as EdmModel;
var container = edmModel.EntityContainer;
for (int i = 0; i < annotationCount; i++)
{
EdmTerm term = new EdmTerm("NS", "Test" + i, EdmPrimitiveTypeKind.String);
EdmVocabularyAnnotation annotation = new EdmAnnotation(
container,
term,
new EdmStringConstant("desc" + i));
edmModel.AddVocabularyAnnotation(annotation);
}
IEdmModel loadedEdmModel = null;
using (var ms = new MemoryStream())
{
var xw = XmlWriter.Create(ms, new XmlWriterSettings {
Indent = true
});
IEnumerable <EdmError> errors;
var res = EdmxWriter.TryWriteEdmx(edmModel, xw, EdmxTarget.OData, out errors);
xw.Flush();
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
using (var sr = new StreamReader(ms))
{
var metadata = sr.ReadToEnd();
loadedEdmModel = EdmxReader.Parse(XmlReader.Create(new MemoryStream(Encoding.UTF8.GetBytes(metadata))));
}
}
container = loadedEdmModel.EntityContainer;
int errorCount = 0;
int totalAnnotationCount = 0;
int taskCount = 100;
Parallel.ForEach(
Enumerable.Range(0, taskCount),
index =>
{
try
{
var count = loadedEdmModel.FindVocabularyAnnotations(container).ToList().Count();
Interlocked.Add(ref totalAnnotationCount, count);
}
catch (Exception ew)
{
Console.WriteLine(ew);
Interlocked.Increment(ref errorCount);
}
});
Assert.AreEqual(0, errorCount);
Assert.AreEqual(taskCount * annotationCount, totalAnnotationCount);
}
public void CanRenamePropertiesInRegularModelBuilder()
{
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, BaseAddress + "/explicit/$metadata");
HttpResponseMessage response = Client.SendAsync(request).Result;
IEdmModel model = EdmxReader.Parse(XmlReader.Create(response.Content.ReadAsStreamAsync().Result));
// Can change the name of regular, complex and navigation properties.
IEdmEntityType customer = model.FindDeclaredType("ModelAliasing.Customer") as IEdmEntityType;
Assert.NotNull(customer);
Assert.NotNull(customer.FindProperty("FinancialAddress"));
Assert.NotNull(customer.FindProperty("ClientName"));
Assert.NotNull(customer.FindProperty("Purchases"));
// Can change the name of properties on complex objects
IEdmComplexType address = model.FindDeclaredType("Location.Direction") as IEdmComplexType;
Assert.NotNull(address);
Assert.NotNull(address.FindProperty("Reign"));
//Can change the name of properties on derived entities.
IEdmEntityType expressOrder = model.FindDeclaredType("Purchasing.ExpressOrder") as IEdmEntityType;
Assert.NotNull(expressOrder);
//Can change the name of properties on derived entities when added explicitly.
Assert.NotNull(expressOrder.FindProperty("Fee"));
//Data contract attribute doesn't change the name of the property.
Assert.Null(expressOrder.FindProperty("DeliveryDate"));
Assert.Null(expressOrder.FindProperty("GuanteedDeliveryDate"));
// Data contract attribute doesn't change the names of the properties
IEdmEntityType ordersLines = model.FindDeclaredType("WebStack.QA.Test.OData.ModelAliasing.ModelAliasingMetadataOrderLine") as IEdmEntityType;
Assert.NotNull(ordersLines);
Assert.Null(ordersLines.FindProperty("Product"));
Assert.NotNull(ordersLines.FindProperty("Item"));
// Data contract attribute doesn't override any explicit configuration on the model builder
Assert.NotNull(ordersLines.FindProperty("Cost"));
}
private static IEdmModel GetEndpointModel(string modelUrl)
{
using (WebResponse response = ReaderUtils.CreateRequest(modelUrl).GetResponse())
{
return(EdmxReader.Parse(XmlReader.Create(response.GetResponseStream())));
}
}
public void CanRenameTypesAndNamespacesInRegularModelBuilder()
{
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, BaseAddress + "/explicit/$metadata");
HttpResponseMessage response = Client.SendAsync(request).Result;
IEdmModel model = EdmxReader.Parse(XmlReader.Create(response.Content.ReadAsStreamAsync().Result));
//Can rename an entity + namespace
IEdmEntityType customer = model.FindDeclaredType("ModelAliasing.Customer") as IEdmEntityType;
Assert.NotNull(customer);
//Explicit configuration on the model builder overrides any configuration on the DataContract attribute.
IEdmEntityType orders = model.FindDeclaredType("AliasedNamespace.Order") as IEdmEntityType;
Assert.NotNull(orders);
//Can rename a derived entity name + namespace
IEdmEntityType expressOrder = model.FindDeclaredType("Purchasing.ExpressOrder") as IEdmEntityType;
Assert.NotNull(expressOrder);
//DataContract doesn't rename the entity or the namespace
IEdmEntityType freeDeliveryOrder = model.FindDeclaredType("Purchasing.FreeOrder") as IEdmEntityType;
Assert.NotNull(freeDeliveryOrder);
//DataContract doesn't rename the entity or the namespace
IEdmEntityType ordersLines = model.FindDeclaredType("Billing.OrderLine") as IEdmEntityType;
Assert.Null(ordersLines);
//Can change the name and the namespaces for complex types
IEdmComplexType region = model.FindDeclaredType("Location.PoliticalRegion") as IEdmComplexType;
Assert.NotNull(region);
IEdmComplexType address = model.FindDeclaredType("Location.Direction") as IEdmComplexType;
Assert.NotNull(address);
}
static void Main(string[] args)
{
Console.WriteLine("Reading from EDMX file...");
// reading from edmx file
var edmxPath = "./Sample_v3.edmx";
using (var reader = XmlReader.Create(edmxPath))
{
const string basePath = "bin/Output/Models";
Directory.CreateDirectory(basePath);
// select from all entity sets
var model = EdmxReader.Parse(reader);
var entityTypes = model.EntityContainers().First().EntitySets().Select(set => set.ElementType);
foreach (var entityType in entityTypes)
{
var entity = EntityDefinition.From(entityType);
File.WriteAllText(Path.Combine(basePath, $"{entityType.Name}.cs"), entity.NormalizeWhitespace().ToFullString());
Console.WriteLine($"{entityType.Name}");
}
}
Console.WriteLine("All done.");
}
private IEdmModel LoadModelFromString(string xmlString)
{
var tr = new StringReader(MetaDataAsString);
var model2 = EdmxReader.Parse(XmlReader.Create(tr));
return(model2);
}
public DefaultTestModel()
{
this.RepresentativeModel = EdmxReader.Parse(XElement.Parse(RepresentativeEdmxDocument).CreateReader());
this.EntityContainer = this.RepresentativeModel.EntityContainer;
this.EntityContainer.Should().NotBeNull();
this.EntityContainer.Name.Should().Be("Container");
this.AddAction = (IEdmAction)this.RepresentativeModel.FindDeclaredOperations("Test.Add").Single();
this.OtherAction = (IEdmAction)this.RepresentativeModel.FindDeclaredOperations("Test.Other").Single();
this.RemoveBadCarAction = (IEdmAction)this.RepresentativeModel.FindDeclaredOperations("Test.RemoveBadCar").Single();
this.Get1Function = (IEdmFunction)this.RepresentativeModel.FindDeclaredOperations("Test.Get1").Single();
this.Get2Function = (IEdmFunction)this.RepresentativeModel.FindDeclaredOperations("Test.Get2").Single();
var operations = this.RepresentativeModel.FindDeclaredOperations("Test.Get3").ToList();
this.Get3FunctionOneParam = (IEdmFunction)operations[0];
this.Get3FunctionNoParams = (IEdmFunction)operations[1];
this.Get1FunctionImport = (IEdmFunctionImport)this.EntityContainer.FindOperationImports("Get1").Single();
this.Get2FunctionImport = (IEdmFunctionImport)this.EntityContainer.FindOperationImports("Get2").Single();
var get3Imports = this.EntityContainer.FindOperationImports("Get3").ToList();
this.Get3FunctionImportWithOneParam = (IEdmFunctionImport)get3Imports[0];
this.Get3FunctionImportWithNoParams = (IEdmFunctionImport)get3Imports[1];
this.PersonType = this.RepresentativeModel.FindDeclaredType("Test.Person") as IEdmEntityType;
this.PersonType.Should().NotBeNull();
this.CarType = this.RepresentativeModel.FindDeclaredType("Test.Car") as IEdmEntityType;
this.CarType.Should().NotBeNull();
}
public OasisRelationshipChangesAcceptanceTests()
{
this.representativeModel = EdmxReader.Parse(XElement.Parse(RepresentativeEdmxDocument).CreateReader());
var container = this.representativeModel.EntityContainer;
this.entitySet1 = container.FindEntitySet("EntitySet1");
this.entitySet2 = container.FindEntitySet("EntitySet2");
this.entityType = this.representativeModel.FindType("Test.EntityType") as IEdmEntityType;
this.entitySet1.Should().NotBeNull();
this.entitySet2.Should().NotBeNull();
this.entityType.Should().NotBeNull();
this.navigation1 = this.entityType.FindProperty("navigation") as IEdmNavigationProperty;
this.navigation2 = this.entityType.FindProperty("NAVIGATION") as IEdmNavigationProperty;
nonKeyPrincipalNavigation = this.entityType.FindProperty("NonKeyPrincipalNavigation") as IEdmNavigationProperty;
var derivedType = this.representativeModel.FindType("Test.DerivedEntityType") as IEdmEntityType;
derivedType.Should().NotBeNull();
this.derivedNavigation = derivedType.FindProperty("DerivedNavigation") as IEdmNavigationProperty;
this.navigation1.Should().NotBeNull();
this.navigation2.Should().NotBeNull();
this.derivedNavigation.Should().NotBeNull();
}
internal static object GetAnnotation(this IODataServiceContext context, params object[] customs)
{
if (false == (null != customs && customs.Count() <= 3))
{
return(null);
}
var serviceUri = customs[0] as Uri;
var requestUri = customs[1] as Uri;
var metadata = customs[2] as IODataServiceMetadata;
IEdmModel edmModel = EdmxReader.Parse(XmlReader.Create(serviceUri + "/$metadata"));
IEdmEntitySet edmEntitySet = edmModel.EntityContainers()
.First()
.EntitySets()
.FirstOrDefault(es =>
es.Name.ToLower() == requestUri.Segments.Last().ToLower() ||
requestUri.Segments.Last().ToLower().StartsWith(es.Name.ToLower() + "(")
);
IEdmEntityType edmEntityType = edmEntitySet.ElementType;
ODataUriParser internalParser = new ODataUriParser(edmModel, serviceUri);
var odataParser = new ODataParser()
{
EdmModel = edmModel,
EdmEntitySet = edmEntitySet,
EdmEntityType = edmEntityType,
InternalParser = internalParser,
Metadata = metadata,
};
return(odataParser);
}
public static IEdmModel GetModel(this ConnectionProperties properties)
{
var uri = properties.Uri;
uri += uri.EndsWith("/") ? "$metadata" : "/$metadata";
IEdmModel model;
var settings = new XmlReaderSettings
{
XmlResolver = new XmlUrlResolver
{
Credentials = properties.GetCredentials(),
Proxy = properties.GetWebProxy()
},
DtdProcessing = DtdProcessing.Parse
};
using (var reader = XmlReader.Create(uri, settings))
{
model = EdmxReader.Parse(reader);
}
return(model);
}
public void ProvideOverloadToSupplyEntitySetConfiguration()
{
IEdmModel model = null;
Stream stream = Client.GetStreamAsync(BaseAddress + "/odata/$metadata").Result;
using (XmlReader reader = XmlReader.Create(stream))
{
model = EdmxReader.Parse(reader);
}
IEdmFunctionImport collection = model.FindDeclaredEntityContainer("Container").FindFunctionImports("GetProductsByCategory").SingleOrDefault();
IEdmEntityType expectedReturnType = model.FindDeclaredType(typeof(ActionProduct).FullName) as IEdmEntityType;
Assert.NotNull(expectedReturnType);
Assert.NotNull(collection);
Assert.True(collection.IsBindable);
Assert.NotNull(collection.ReturnType.AsCollection());
Assert.NotNull(collection.ReturnType.AsCollection().ElementType().AsEntity());
Assert.Equal(expectedReturnType, collection.ReturnType.AsCollection().ElementType().AsEntity().EntityDefinition());
IEdmFunctionImport single = model.FindDeclaredEntityContainer("Container").FindFunctionImports("GetSpecialProduct").SingleOrDefault();
Assert.NotNull(single);
Assert.True(single.IsBindable);
Assert.NotNull(single.ReturnType.AsEntity());
Assert.Equal(expectedReturnType, single.ReturnType.AsEntity().EntityDefinition());
}
internal virtual IEdmModel LoadModelFromString()
{
var tr = new StringReader(MetaDataAsString);
Model = EdmxReader.Parse(XmlReader.Create(tr));
EntitySets = GetEntitySets(Model);
return(Model);
}
private IEdmModel LoadModel()
{
using (var reader = new XmlTextReader(GetMetadataUri().ToString()))
{
IEdmModel model = EdmxReader.Parse(reader);
return(model);
}
}
public ODataAdapter(ISession session, string protocolVersion, string metadataString)
: this(session, protocolVersion)
{
var reader = XmlReader.Create(new StringReader(metadataString));
reader.MoveToContent();
Model = EdmxReader.Parse(reader);
}
public ODataModelAdapter(string protocolVersion, string metadataString)
: this(protocolVersion)
{
using (var reader = XmlReader.Create(new StringReader(metadataString)))
{
reader.MoveToContent();
Model = EdmxReader.Parse(reader);
}
}
public UserDefinedServiceContainer(Uri serviceRoot)
: base(serviceRoot)
{
XmlReader reader = XmlReader.Create(new StringReader(edmModelString));
edmModel = EdmxReader.Parse(reader);
this.Format.LoadServiceModel = () => edmModel;
this.Format.UseJson();
}
public void KeyAsSegmentEndToEndSmokeTestInJsonLight()
{
RunEndToEndSmokeTestWithClient(ctx =>
{
ctx.ResolveName = t => t.FullName;
ctx.ResolveType = n => n.Contains("Customer") ? typeof(Customer) : null;
ctx.Format.UseJson(EdmxReader.Parse(XmlReader.Create(ctx.GetMetadataUri().AbsoluteUri)));
});
}
public void ReadSchema(string content)
{
//Microsoft.Data.Edm.Csdl.CsdlReader.TryParse()
//System.Xml.XmlDocument xmlDocument = new System.Xml.XmlDocument();
using (var reader = System.Xml.XmlReader.Create(new System.IO.StringReader(content))) {
var edmModel = EdmxReader.Parse(reader);
//edmModel.EntityContainers();
}
}
public ModelSchema ReadSchema(System.IO.StreamReader streamReader)
{
//Microsoft.Data.Edm.Csdl.CsdlReader.TryParse()
//System.Xml.XmlDocument xmlDocument = new System.Xml.XmlDocument();
using (var reader = System.Xml.XmlReader.Create(streamReader)) {
var edmModel = EdmxReader.Parse(reader);
return(this.ConvertSchema(edmModel));
//edmModel.EntityContainers();
}
}
public CsdlParModel()
{
#region parse Model
StringBuilder builder = new StringBuilder();
TextWriter tw = null;
try
{
tw = new StringWriter(builder);
using (var xw = XmlWriter.Create(tw))
{
IEnumerable <EdmError> errors;
EdmxWriter.TryWriteEdmx(BaseModel, xw, EdmxTarget.OData, out errors);
}
}
catch (Exception)
{
if (tw != null)
{
tw.Dispose();
}
}
TextReader tr = null;
try
{
tr = new StringReader(builder.ToString());
using (var xr = XmlReader.Create(tr))
{
Model = EdmxReader.Parse(xr);
}
}
catch (Exception)
{
if (tr != null)
{
tr.Dispose();
}
}
Debug.Assert(Model != null);
#endregion
Person = Model.FindEntityType("NS.Person");
Debug.Assert(Person != null);
PersonSet = Model.FindDeclaredEntitySet("PersonSet");
Debug.Assert(PersonSet != null);
PersonNavPetCon = Person.GetNavigationProperty("NavPetCon");
Debug.Assert(PersonNavPetCon != null);
PersonNavPetUnknown = Person.GetNavigationProperty("NavPetUnknown");
Debug.Assert(PersonNavPetUnknown != null);
}
/// <summary>
/// Builds an Entity Data Model (EDM) from an
/// existing <see cref="DbContext"/> created using Code-First.
/// Use <see cref="GetModelFirstEdm"/> for a Model-First DbContext.
/// </summary>
/// <typeparam name="T">Type of the source <see cref="DbContext"/></typeparam>
/// <param name="dbContext">Concrete <see cref="DbContext"/> to use for EDM generation.</param>
/// <returns>An XML <see cref="IEdmModel"/>.</returns>
static IEdmModel GetCodeFirstEdm <T>(this T dbContext) where T : DbContext
{
using (var stream = new MemoryStream()) {
using (var writer = XmlWriter.Create(stream)) {
System.Data.Entity.Infrastructure.EdmxWriter.WriteEdmx(dbContext, writer);
}
stream.Position = 0;
using (var reader = XmlReader.Create(stream)) {
return(EdmxReader.Parse(reader));
}
}
}
/// <summary>
/// Checks whether the specified document contains valid metadata and
/// returns a loaded <see cref="IEdmModel"/>.
/// </summary>
/// <param name="document">Document to validate.</param>
/// <returns>The loaded <see cref="IEdmModel"/>.</returns>
public static IEdmModel IsValidMetadata(XPathDocument document)
{
var reader = document.CreateNavigator().ReadSubtree();
var model = EdmxReader.Parse(reader);
IEnumerable <EdmError> errors;
if (!model.Validate(out errors))
{
throw new TestFailedException(string.Join(Environment.NewLine, errors.Select(e => e.ToString())));
}
return(model);
}
public void ValidateActionImportMissingActionAttributeShouldReturnError()
{
const string errorDocument = @"<edmx:Edmx Version=""4.0"" xmlns:edmx=""http://docs.oasis-open.org/odata/ns/edmx"">
<edmx:DataServices>
<Schema Namespace=""Test"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityContainer Name=""Container"">
<ActionImport Name=""Add"" />
</EntityContainer>
</Schema>
</edmx:DataServices>
</edmx:Edmx>";
Action test = () => EdmxReader.Parse(XElement.Parse(errorDocument).CreateReader());
test.ShouldThrow <EdmParseException>().WithMessage(Strings.XmlParser_MissingAttribute("Action", "ActionImport"), ComparisonMode.Substring);
}
public void ParsingInvalidXmlWithMultipleEntityContainersShouldThrow()
{
string EdmxwithMultipleEntityContainers = @"<edmx:Edmx Version=""4.0"" xmlns:edmx=""http://docs.oasis-open.org/odata/ns/edmx"">
<edmx:DataServices>
<Schema Namespace=""Test"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityContainer Name=""Container1"" />
<EntityContainer Name=""Container2"" />
</Schema>
</edmx:DataServices>
</edmx:Edmx>";
Action parseAction = () => EdmxReader.Parse(XElement.Parse(EdmxwithMultipleEntityContainers).CreateReader());
parseAction.ShouldThrow <EdmParseException>().WithMessage(
Strings.CsdlParser_MetadataDocumentCannotHaveMoreThanOneEntityContainer, ComparisonMode.Substring).And.Errors.Should().HaveCount(1);
}
private IEdmModel CodeFistModel(DbContext context)
{
using (var stream = new MemoryStream())
{
using (var writer = XmlWriter.Create(stream))
{
System.Data.Entity.Infrastructure.EdmxWriter.WriteEdmx(context, writer);
writer.Close();
stream.Seek(0, SeekOrigin.Begin);
using (var reader = XmlReader.Create(stream))
{
return(EdmxReader.Parse(reader));
}
}
}
}
public IEdmModel GetEdmModel()
{
using (MemoryStream stream = new MemoryStream())
{
using (XmlWriter writer = XmlWriter.Create(stream))
{
System.Data.Entity.Infrastructure.EdmxWriter.WriteEdmx(this, writer);
}
stream.Position = 0;
using (XmlReader reader = XmlReader.Create(stream))
{
return(EdmxReader.Parse(reader));
}
}
}
public IEdmModel LoadModel(Uri realm)
{
using (HttpClient client = new HttpClient())
{
var header = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", GetRawToken());
client.DefaultRequestHeaders.Authorization = header;
Console.WriteLine("\t{0} {1}", "GET", realm.ToString() + "$metadata");
HttpResponseMessage response = client.GetAsync(realm.ToString() + "$metadata").Result;
var stream = response.Content.ReadAsStreamAsync().Result;
using (var reader = XmlReader.Create(stream))
{
IEdmModel model = EdmxReader.Parse(reader);
_modelLoadCompleteEvent.Set();
return(model);
}
}
}
/// <summary>
/// Builds an Entity Data Model (EDM) from an
/// existing <see cref="DbContext"/> created using Code-First.
/// Use <see cref="GetModelFirstEdm"/> for a Model-First DbContext.
/// </summary>
/// <typeparam name="T">Type of the source <see cref="DbContext"/></typeparam>
/// <param name="dbContext">Concrete <see cref="DbContext"/> to use for EDM generation.</param>
/// <returns>An XML <see cref="IEdmModel"/>.</returns>
static IEdmModel GetCodeFirstEdm <T>(this T dbContext) where T : DbContext
{
using (var stream = new MemoryStream())
{
using (var writer = XmlWriter.Create(stream))
{
System.Data.Entity.Infrastructure.EdmxWriter.WriteEdmx(dbContext, writer);
}
stream.Position = 0;
// Add readonly properties
// This way of adding new properties actually work, but these properties are not necessary anymore
// So keep them as a sample
var edmx = System.Xml.Linq.XDocument.Load(stream);
RemoveProperty(edmx, "User", "SecurityStamp");
RemoveProperty(edmx, "User", "PasswordHash");
//AddReadonlyProperty(edmx, "ResourcePool", "OtherUsersResourcePoolRateTotal", "Decimal", true);
//AddReadonlyProperty(edmx, "ResourcePool", "OtherUsersResourcePoolRateCount", "Int32", false);
//AddReadonlyProperty(edmx, "ElementField", "OtherUsersIndexRatingTotal", "Decimal", true);
//AddReadonlyProperty(edmx, "ElementField", "OtherUsersIndexRatingCount", "Int32", false);
//AddReadonlyProperty(edmx, "ElementCell", "OtherUsersNumericValueTotal", "Decimal", true);
//AddReadonlyProperty(edmx, "ElementCell", "OtherUsersNumericValueCount", "Int32", false);
/* UNCOMMENT THIS IN CASE YOU WANT TO SAVE AND INSPECT THE EDMX FILE */
//stream.Position = 0;
//var edmxDocument = new System.Xml.XmlDocument();
//edmxDocument.Load(stream);
//edmxDocument.Save(@"D:\test.xml");
using (var reader = edmx.CreateReader())
{
return(EdmxReader.Parse(reader));
}
// Old part
//using (var reader = XmlReader.Create(stream))
//{
// return EdmxReader.Parse(reader);
//}
}
}
