public void Should_be_able_to_roundtrip_model_through_gzip()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity <MigrationsCustomer>();
var model = modelBuilder.Build(new DbProviderInfo(DbProviders.Sql, "2008"));
var edmxString = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(
edmxString, new XmlWriterSettings
{
Indent = true
}))
{
EdmxWriter.WriteEdmx(model, xmlWriter);
}
var modelCompressor = new ModelCompressor();
var bytes = modelCompressor.Compress(model.GetModel());
Assert.True(bytes.Length > 2000);
var edmxXDocument = modelCompressor.Decompress(bytes);
using (var stringWriter = new StringWriter())
{
edmxXDocument.Save(stringWriter);
Assert.Equal(edmxString.ToString(), stringWriter.ToString());
}
}
/// <summary>
/// Writes the metadata document as the message body.
/// </summary>
/// <remarks>It is the responsibility of this method to flush the output before the method returns.</remarks>
internal override void WriteMetadataDocument()
{
DebugUtils.CheckNoExternalCallers();
this.AssertSynchronous();
// Save the in-memory OData annotations to the model (i.e., turn them into serializable ones)
this.Model.SaveODataAnnotations();
IEnumerable <EdmError> errors;
if (!EdmxWriter.TryWriteEdmx(this.Model, this.xmlWriter, EdmxTarget.OData, out errors))
{
Debug.Assert(errors != null, "errors != null");
StringBuilder builder = new StringBuilder();
foreach (EdmError error in errors)
{
builder.AppendLine(error.ToString());
}
throw new ODataException(Strings.ODataMetadataOutputContext_ErrorWritingMetadata(builder.ToString()));
}
this.Flush();
}
private static MetadataWorkspace CreateEdmxBasedWorkspace(DbContext context)
{
var edmxBuilder = new StringBuilder();
EdmxWriter.WriteEdmx(context, XmlWriter.Create(edmxBuilder));
var edmx = XDocument.Parse(edmxBuilder.ToString());
var edmItemCollection = new EdmItemCollection(
new[]
{
edmx.Descendants(XName.Get("Schema", "http://schemas.microsoft.com/ado/2009/11/edm")).Single().CreateReader()
});
var storeItemCollection = new StoreItemCollection(
new[]
{
edmx.Descendants(XName.Get("Schema", "http://schemas.microsoft.com/ado/2009/11/edm/ssdl")).Single().CreateReader()
});
var mapping = new StorageMappingItemCollection(
edmItemCollection,
storeItemCollection,
new[]
{
new XElement(edmx.Descendants(XName.Get("Mapping", "http://schemas.microsoft.com/ado/2009/11/mapping/cs")).Single())
.CreateReader()
});
return(new MetadataWorkspace(() => edmItemCollection, () => storeItemCollection, () => mapping));
}
public static void WriteEdmx(this DbContext context, string outputFilePath)
{
EdmxWriter.WriteEdmx(context, XmlWriter.Create(outputFilePath, new XmlWriterSettings()
{
Indent = true
}));
}
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);
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
if (targetModel != null)
{
foreach (EntityModel item in targetModel.Entities)
{
Type dynamicEntityType = DynamicEntityTypeManager.CreateTypeFromEntityDefinition(targetModel, item, DateTime.UtcNow);
MethodInfo registerMethod = modelBuilder.GetType().GetMethod("Entity").MakeGenericMethod(dynamicEntityType);
dynamic configuration = registerMethod.Invoke(modelBuilder, null);
// configuration.MapInheritedProperties();
var action = new Action <dynamic>(m =>
{
m.MapInheritedProperties();
m.ToTable(item.Name);
});
configuration.Map(action);
//DataStructures.Attribute primaryKey = item.Attributes.First(a => a.AttributeInfo.IsPrimaryKey == true);
//configuration.HasKey(primaryKey
/*modelBuilder.Entity<BaseEntity>().Map(m =>
* {
* m.MapInheritedProperties();
* m.ToTable(item.Name);
* });*/
///.HasKey<string>(ent => ent.Name);
}
}
DbModel model = null;
if (targetModel.Databases.Count > 0 && !string.IsNullOrEmpty(this.cnnString))
{
if (targetModel.Databases[0].Connector.Contains("MSSQL"))
{
var providerFactory = System.Data.Common.DbProviderFactories.GetFactory("System.Data.SqlClient");
System.Data.Common.DbConnection connection = providerFactory.CreateConnection();
connection.ConnectionString = this.cnnString;
model = modelBuilder.Build(connection);
}
}
else
{
var provider = new DbProviderInfo("System.Data.SqlClient", "2008");
model = modelBuilder.Build(provider);
}
string edmxpath = System.IO.Path.Combine(targetModel.ParentProject.Path, System.IO.Path.ChangeExtension(targetModel.Path, "edmx"));
if (System.IO.File.Exists(edmxpath))
{
System.IO.File.Delete(edmxpath);
}
var writer = new XmlTextWriter(edmxpath, Encoding.ASCII);
EdmxWriter.WriteEdmx(model, writer);
writer.Flush();
writer.Close();
//base.OnModelCreating(modelBuilder);
}
private static String GetMetadataFromDbContext(Object context)
{
var dbContext = (DbContext)context;
XElement xele;
try {
using (var swriter = new StringWriter()) {
using (var xwriter = new XmlTextWriter(swriter)) {
EdmxWriter.WriteEdmx(dbContext, xwriter);
xele = XElement.Parse(swriter.ToString());
}
}
} catch (Exception e) {
if (e is NotSupportedException)
{
// DbContext that fails on WriteEdmx is likely a DataBase first DbContext.
return(GetMetadataFromObjectContext(dbContext));
}
else
{
throw;
}
}
var ns = xele.Name.Namespace;
var conceptualEle = xele.Descendants(ns + "ConceptualModels").First();
var schemaEle = conceptualEle.Elements().First(ele => ele.Name.LocalName == "Schema");
var xDoc = XDocument.Load(schemaEle.CreateReader());
var objectContext = ((IObjectContextAdapter)dbContext).ObjectContext;
// This is needed because the raw edmx has a different namespace than the CLR types that it references.
xDoc = UpdateCSpaceOSpaceMapping(xDoc, objectContext);
return(XDocToJson(xDoc));
}
public void Model_based_WriteEdmx_throws_when_given_null_writer()
{
Assert.Equal(
"writer",
Assert.Throws <ArgumentNullException>(
() => EdmxWriter.WriteEdmx(new DbModel(new DbDatabaseMapping(), new DbModelBuilder()), null)).ParamName);
}
public static MetadataWorkspace GetMetadataWorkspace(Func <string, TContext> createFromConnectionString, bool hardCache)
{
if (_cachedWorkspace != null)
{
return(_cachedWorkspace);
}
var cacheName = GetCacheName();
if (hardCache && File.Exists(cacheName))
{
var xDoc = XDocument.Load(cacheName);
return(_cachedWorkspace = GetMetadataWorkspace(xDoc));
}
using (var ctx = createFromConnectionString("App=EntityFramework"))
using (var ms = new MemoryStream())
using (var writer = new XmlTextWriter(ms, Encoding.UTF8))
{
EdmxWriter.WriteEdmx(ctx, writer);
if (hardCache)
{
ms.Seek(0, SeekOrigin.Begin);
using (var file = File.Create(cacheName))
ms.WriteTo(file);
}
ms.Seek(0, SeekOrigin.Begin);
var xDoc = XDocument.Load(ms);
return(_cachedWorkspace = GetMetadataWorkspace(xDoc));
}
}
private static void ShowModel(IEdmModel model)
{
IEnumerable <EdmError> errors;
var writer = XmlWriter.Create(Console.Out, new XmlWriterSettings {
Indent = true
});
EdmxWriter.TryWriteEdmx(model, writer, EdmxTarget.OData, out errors);
writer.Flush();
Console.WriteLine();
foreach (var edmError in errors)
{
Console.WriteLine(edmError);
}
/*
* model.Validate(out errors);
* foreach (var edmError in errors)
* {
* Console.WriteLine(edmError);
* }
*/
}
public static string GetModelXDocument(DbModel model)
{
if (model == null)
{
return(string.Empty);
}
XDocument doc;
using (var memoryStream = new MemoryStream())
{
using (XmlWriter xmlWriter = XmlWriter.Create(memoryStream, new XmlWriterSettings {
Indent = true
}))
{
EdmxWriter.WriteEdmx(model, xmlWriter);
}
memoryStream.Position = 0;
doc = XDocument.Load(memoryStream);
}
return(doc.ToString());
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
#if DEBUG
// Drop, recreate and reseed the database
Database.SetInitializer(new DbInitializer());
using (var db = new ListAssistContext())
{
db.Database.Initialize(true);
}
// Recreate a edmx diagram from the latest model
using (var ctx = new ListAssistContext())
{
using (var writer = new XmlTextWriter(HttpRuntime.AppDomainAppPath.TrimEnd('\\') + @".Data\EntityModelDiagram.edmx", Encoding.Default))
{
EdmxWriter.WriteEdmx(ctx, writer);
}
}
#endif
}
void VerifyResult(string[] inputText, string expectedResult, EdmxTarget target, Action <IEdmModel> visitModel)
{
IEdmModel model;
IEnumerable <EdmError> errors;
List <XmlReader> readers = new List <XmlReader>();
foreach (string s in inputText)
{
readers.Add(XmlReader.Create(new StringReader(s)));
}
bool parsed = CsdlReader.TryParse(readers, out model, out errors);
Assert.IsTrue(parsed, "Model Parsed");
Assert.IsTrue(errors.Count() == 0, "No Errors");
if (visitModel != null)
{
visitModel(model);
}
StringWriter sw = new StringWriter();
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.Encoding = System.Text.Encoding.UTF8;
XmlWriter xw = XmlWriter.Create(sw, settings);
EdmxWriter.TryWriteEdmx(model, xw, target, out errors);
xw.Flush();
xw.Close();
string outputText = sw.ToString();
Assert.AreEqual(expectedResult, outputText, "Expected Result = Output");
}
/// <summary>
/// Returns the payload to be used for this test case and the specified test configuration.
/// </summary>
/// <param name="testConfiguration">The test configuration to use.</param>
/// <returns>The payload to use for testing.</returns>
private byte[] GetPayload(ReaderTestConfiguration testConfiguration)
{
if (testConfiguration.Format != null && testConfiguration.Format != ODataFormat.Metadata)
{
// NOTE: metadata reading is not supported in other formats; return an empty payload for error tests
return(new byte[0]);
}
TestStream testStream = new TestStream(new MemoryStream(), ignoreDispose: true);
if (this.PayloadEdmModel != null)
{
using (XmlWriter xmlWriter = XmlWriter.Create(testStream))
{
IEnumerable <EdmError> errors;
if (!EdmxWriter.TryWriteEdmx(this.PayloadEdmModel, xmlWriter, EdmxTarget.OData, out errors))
{
var errorBuilder = new StringBuilder();
foreach (var error in errors)
{
errorBuilder.AppendLine(error.ToString());
}
throw new Exception("TryWriteEdmx Error:" + errorBuilder);
}
}
}
byte[] payload = new byte[testStream.Length];
testStream.Seek(0, SeekOrigin.Begin);
testStream.Read(payload, 0, (int)testStream.Length);
return(payload);
}
public void CreateInsertOperation_should_return_valid_history_operation()
{
var modelBuilder = new DbModelBuilder();
var model = modelBuilder.Build(ProviderInfo);
var edmxString = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(
edmxString, new XmlWriterSettings
{
Indent = true
}))
{
EdmxWriter.WriteEdmx(model, xmlWriter);
}
var modelDocument = model.GetModel();
var historyRepository = new HistoryRepository(ConnectionString, ProviderFactory, "MyKey");
var historyOperation
= (HistoryOperation)historyRepository.CreateInsertOperation("Migration1", modelDocument);
Assert.NotEmpty(historyOperation.Commands);
Assert.Equal(4, historyOperation.Commands.Single().Parameters.Count());
}
public void CreateInsertOperation_should_return_valid_history_operation()
{
var modelBuilder = new DbModelBuilder();
var model = modelBuilder.Build(ProviderInfo);
var edmxString = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(
edmxString, new XmlWriterSettings
{
Indent = true
}))
{
EdmxWriter.WriteEdmx(model, xmlWriter);
}
var modelDocument = model.GetModel();
var historyRepository = new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory);
var historyOperation
= (HistoryOperation)historyRepository.CreateInsertOperation("Migration1", new VersionedModel(modelDocument));
Assert.NotEmpty(historyOperation.CommandTrees);
Assert.Equal(DbCommandTreeKind.Insert, historyOperation.CommandTrees.Single().CommandTreeKind);
}
private void WriteMetadata(TextWriter writer, IEdmModel model)
{
using (var xmlWriter = XmlWriter.Create(writer))
{
IEnumerable <EdmError> errors;
EdmxWriter.TryWriteEdmx(model, xmlWriter, EdmxTarget.OData, out errors);
}
}
public static string GetEdmx(this DbContext context)
{
StringBuilder sb = new StringBuilder();
XmlWriter xmlWriter = XmlWriter.Create(sb);
EdmxWriter.WriteEdmx(context, xmlWriter);
return(sb.ToString());
}
public void WriteEdmx_throws_when_using_bad_mapping_that_is_not_caught_by_first_pass_CSDL_validation()
{
using (var context = new InvalidMappingContext())
{
Assert.Throws <ModelValidationException>(
() => EdmxWriter.WriteEdmx(context, XmlWriter.Create(Stream.Null)));
}
}
public void Generate()
{
var sw = Stopwatch.StartNew();
byte[] sourceHash = GetOrmHash();
string sampleEdmFile = Path.Combine(Paths.GeneratedFolder, EntityFrameworkMetadata.SegmentsFromCode.First().FileName);
var edmExtensions = EntityFrameworkMetadata.SegmentsFromCode.Select(s => Path.GetExtension(s.FileName));
if (_cache.RestoreCachedFiles(sampleEdmFile, sourceHash, Paths.GeneratedFolder, edmExtensions) != null)
{
_performanceLogger.Write(sw, "EntityFrameworkMetadata: Restore cached EDM files.");
}
else
{
var connection = new SqlConnection(_connectionString);
var dbConfiguration = (DbConfiguration)_dom.GetType("Common.EntityFrameworkConfiguration")
.GetConstructor(new Type[] { })
.Invoke(new object[] { });
var dbContext = (DbContext)_dom.GetType("Common.EntityFrameworkContext")
.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(DbConnection), dbConfiguration.GetType(), typeof(IConfiguration) }, null)
.Invoke(new object[] { connection, dbConfiguration, _configuration });
string edmx;
using (var stringWriter = new StringWriter())
using (var xmlWriter = new XmlTextWriter(stringWriter))
{
xmlWriter.Formatting = System.Xml.Formatting.Indented;
EdmxWriter.WriteEdmx(dbContext, xmlWriter);
edmx = stringWriter.ToString();
}
_performanceLogger.Write(sw, "EntityFrameworkMetadata: Extract EDMX.");
foreach (var segment in EntityFrameworkMetadata.SegmentsFromCode)
{
string startTag = "\r\n <" + segment.TagName + ">\r\n";
string endTag = "\r\n </" + segment.TagName + ">\r\n";
int start = edmx.IndexOf(startTag, StringComparison.Ordinal);
int end = edmx.IndexOf(endTag, StringComparison.Ordinal);
int alternativeStart = edmx.IndexOf(startTag, start + 1, StringComparison.Ordinal);
int alternativeEnd = edmx.IndexOf(endTag, end + 1, StringComparison.Ordinal);
if (start == -1 || alternativeStart != -1 || end == -1 || alternativeEnd != -1)
{
throw new Exception("Unexpected EDMX format. " + segment.TagName + " tag locations: start=" + start + " alternativeStart=" + alternativeStart + " end=" + end + " alternativeEnd=" + alternativeEnd + ".");
}
string segmentXml = edmx.Substring(start + startTag.Length, end - start - startTag.Length);
File.WriteAllText(Path.Combine(Paths.GeneratedFolder, segment.FileName), segmentXml, Encoding.UTF8);
}
_performanceLogger.Write(sw, "EntityFrameworkMetadata: Save EDM files.");
}
_cache.SaveHash(sampleEdmFile, sourceHash);
}
private static XDocument GetModel(this DbContext context)
{
var document = GetModel(delegate(XmlWriter w)
{
EdmxWriter.WriteEdmx(context, w);
});
return(document);
}
public void EDMX_can_be_written_from_DbModel()
{
var edm = SimpleModelContext.CreateBuilder().Build(ProviderRegistry.Sql2008_ProviderInfo);
var edmxBuilder = new StringBuilder();
EdmxWriter.WriteEdmx(edm, XmlWriter.Create(edmxBuilder));
SanityCheckEdmx(edmxBuilder);
}
public void GenerateEdmxForCodeFirstDBContext()
{
var path = HttpContext.Current.Server.MapPath("~/Models/store.edmx");
using (var writer = new XmlTextWriter(path, Encoding.Default))
{
EdmxWriter.WriteEdmx(db as StoreAppContext, writer);
}
}
private static void ReferentialConstraintDemo()
{
EdmModel model = new EdmModel();
var customer = new EdmEntityType("ns", "Customer");
model.AddElement(customer);
var customerId = customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false);
customer.AddKeys(customerId);
var address = new EdmComplexType("ns", "Address");
model.AddElement(address);
var code = address.AddStructuralProperty("gid", EdmPrimitiveTypeKind.Guid);
customer.AddStructuralProperty("addr", new EdmComplexTypeReference(address, true));
var order = new EdmEntityType("ns", "Order");
model.AddElement(order);
var oId = order.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false);
order.AddKeys(oId);
var orderCustomerId = order.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32, false);
var nav = new EdmNavigationPropertyInfo()
{
Name = "NavCustomer",
Target = customer,
TargetMultiplicity = EdmMultiplicity.One,
DependentProperties = new[] { orderCustomerId },
PrincipalProperties = new[] { customerId }
};
order.AddUnidirectionalNavigation(nav);
IEnumerable <EdmError> errors;
var writer = XmlWriter.Create(Console.Out, new XmlWriterSettings {
Indent = true
});
EdmxWriter.TryWriteEdmx(model, writer, EdmxTarget.OData, out errors);
writer.Flush();
foreach (var edmError in errors)
{
Console.WriteLine(edmError);
}
model.Validate(out errors);
foreach (var edmError in errors)
{
Console.WriteLine(edmError);
}
}
static void Main(string[] args)
{
using (var ctx = new MyContext())
{
EdmxWriter.WriteEdmx(ctx, XmlWriter.Create(Console.Out, new XmlWriterSettings {
Indent = true
}));
}
}
/// <summary>
/// Writes csdl, msdl, and ssdl files into the current directory for the model generated from
/// the given model builder.
/// </summary>
/// <param name="builder"> The builder. </param>
/// <param name="filename"> The base filename to use for csdl, msdl, and sssl files. </param>
public static void WriteMetadataFiles(DbModelBuilder builder, string filename)
{
var xml = new StringBuilder();
EdmxWriter.WriteEdmx(
builder.Build(new DbProviderInfo("System.Data.SqlClient", "2008")),
XmlWriter.Create(xml));
WriteMetadataFiles(xml.ToString(), filename);
}
public static void GerarDiagrama()
{
using (var ctx = new ContextoEF())
{
using (var writer = new XmlTextWriter(@"C:\Users\wande\Source\Repos\WandelFeics\Clinica\DiagramadeClasses\Model.edmx", Encoding.Default))
{
EdmxWriter.WriteEdmx(ctx, writer);
}
}
}
public static void WriteEdmx(string filePath)
{
var context = new MyDbContext();
var settings = new XmlWriterSettings();
settings.Indent = true;
var writer = XmlWriter.Create(filePath, settings);
EdmxWriter.WriteEdmx(context, writer);
}
private void GenerateERDiagram()
{
using (var context = new ApplicationDbContext())
{
using (var writer = new XmlTextWriter(@"C:\My Files\Model.edmx", Encoding.Default))
{
EdmxWriter.WriteEdmx(context, writer);
}
}
}
static void Main(string[] args)
{
using (var ctx = new KatSystemDbContext())
{
using (var writer = new XmlTextWriter(@"c:\Model.edmx", Encoding.Default))
{
EdmxWriter.WriteEdmx(ctx, writer);
}
}
}
