This article will present a solution to regenerate precompiled views in Entity Framework. Precompiled views can have a dramatic effect on the startup time of your DbContext / ObjectContext, especially the time to execute the first query against the database.
First off, the following class can generate these precompiled views:
using System;
using System.Collections.Generic;
using System.Data.Entity.Core.Mapping;
using System.Data.Entity.Core.Metadata.Edm;
using System.Data.Entity.Infrastructure;
namespace PrecompiledViewGenerator
{
/// <summary>
/// Capable of generating pre compiled views that EF can use for quicker startup time when application domains starts.
/// </summary>
/// <typeparam name="TDbContext"></typeparam>
/// <param name="dbContext"></param>
/// <remarks>See https://github.com/ErikEJ/EntityFramework6PowerTools/tree/community/src/PowerTools Github page for the source code of EF Power tools.</remarks>
/// <returns>A string containing the precompiled views that can be written to file or database for later use to gain optimized startup speeds of EF in application domains.</returns>
public class EntityFrameworkPrecompiledViewGenerator
{
/// <summary>
/// Generates pre compiled views from a db context. Uses EF Powertools runtime T4 template (.tt file) for precompiled view generation of views for EF 6 ObjectContext for C#.
/// </summary>
/// <typeparam name="TDbContext"></typeparam>
/// <param name="dbContext"></param>
/// <param name="viewContainerSuffix">The suffix to apply in the generated file containing the precompiled views</param>
/// <remarks>See https://github.com/ErikEJ/EntityFramework6PowerTools/tree/community/src/PowerTools Github page for the source code of EF Power tools.</remarks>
/// <returns>A string containing the precompiled views that can be written to file or database for later use to gain optimized startup speeds of EF in application domains.</returns>
public string GeneratePrecompiledViews<TDbContext>(TDbContext dbContext, string viewContainerSuffix) where TDbContext : IObjectContextAdapter
{
if (string.IsNullOrEmpty(viewContainerSuffix))
throw new ArgumentNullException(nameof(viewContainerSuffix));
var objectContext = (dbContext as IObjectContextAdapter)?.ObjectContext;
if (objectContext == null)
throw new ArgumentNullException(nameof(dbContext));
var viewGenerator = new CSharpViewGenerator();
var mappingCollection = (StorageMappingItemCollection) objectContext.MetadataWorkspace.GetItemCollection(DataSpace.CSSpace);
if (mappingCollection == null)
throw new ArgumentNullException(nameof(dbContext));
var listOfEdmSchemaErrors = new List<EdmSchemaError>();
var views = mappingCollection.GenerateViews(listOfEdmSchemaErrors);
listOfEdmSchemaErrors.ForEach(error =>
{
if (error.Severity == EdmSchemaErrorSeverity.Error)
throw new ArgumentOutOfRangeException($"An error occurred while trying to generate views for {dbContext.GetType().Name}. The error was: {error.ToString()}");
});
viewGenerator.ContextTypeName = dbContext.GetType().FullName;
viewGenerator.MappingHashValue = mappingCollection.ComputeMappingHashValue();
viewGenerator.ViewContainerSuffix = viewContainerSuffix;
viewGenerator.Views = views;
string precompiledViews = viewGenerator.TransformText();
return precompiledViews;
}
}
}
The following runtime text template (.T4) is used to generate the precompiled views:
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System.Data.Entity.Infrastructure.MappingViews;
[assembly: DbMappingViewCacheTypeAttribute(
typeof(<#= ContextTypeName #>),
typeof(Edm_EntityMappingGeneratedViews.ViewsForBaseEntitySets<#= ContextTypeName #>))]
namespace Edm_EntityMappingGeneratedViews
{
using System;
using System.CodeDom.Compiler;
using System.Data.Entity.Core.Metadata.Edm;
/// <summary>
/// Implements a mapping view cache.
/// </summary>
[GeneratedCode("Entity Framework 6 Power Tools", "0.9.2.0")]
internal sealed class ViewsForBaseEntitySets<#= ViewContainerSuffix #> : DbMappingViewCache
{
/// <summary>
/// Gets a hash value computed over the mapping closure.
/// </summary>
public override string MappingHashValue
{
get { return "<#= MappingHashValue #>"; }
}
/// <summary>
/// Gets a view corresponding to the specified extent.
/// </summary>
/// <param name="extent">The extent.</param>
/// <returns>The mapping view, or null if the extent is not associated with a mapping view.</returns>
public override DbMappingView GetView(EntitySetBase extent)
{
if (extent == null)
{
throw new ArgumentNullException("extent");
}
var extentName = extent.EntityContainer.Name + "." + extent.Name;
<#
var index = 0;
foreach (var view in Views)
{
#>
if (extentName == "<#= view.Key.EntityContainer.Name + "." + view.Key.Name #>")
{
return GetView<#= index #>();
}
<#
index++;
}
#>
return null;
}
<#
index = 0;
foreach (var view in Views)
{
#>
/// <summary>
/// Gets the view for <#= view.Key.EntityContainer.Name + "." + view.Key.Name #>.
/// </summary>
/// <returns>The mapping view.</returns>
private static DbMappingView GetView<#= index #>()
{
return new DbMappingView(@"<#= view.Value.EntitySql #>");
}
<#
index++;
}
#>
}
}
<#+
public string ContextTypeName { get; set; }
public string ViewContainerSuffix { get; set; }
public string MappingHashValue { get; set; }
public dynamic Views { get; set; }
#>
This T4 file is compiled into the class CSharpViewGenerator.
Our DbContext can now check the
mapping hash value of the loaded precompiled views file in your assembly and compute in again to quickly assert if the database is in sync with the precompiled views.
The following code can establish both a check that the precompiled views are in sync and run code that will regenerate the precompiled views file of which the developer can then copy from Notepad and into the
precompiled view file again. Not perhaps an elegant solution, but it lets the developer easily check and keep the precompiled views file updated and in sync. And you do not need to install the EF Powertools extension either, as I use the .tt file and much of the source code from there which is part of the "Generate views" command anywyays!
Sample DbContext is then:
using System;
using System.Data.Entity;
using System.Data.Entity.Core;
using System.Data.Entity.Core.Mapping;
using System.Data.Entity.Core.Metadata.Edm;
using System.Diagnostics;
using System.IO;
using System.Runtime.CompilerServices;
using Edm_EntityMappingGeneratedViews;
using PrecompiledViewGenerator;
namespace SomeAcme.SomeRegistry.Data
{
public class SomeDatabaseMigrationsFactory : DatabaseMigrationsFactory<SomeDatabase>
{
}
public class SomeDatabase : SomeDatabaseBaseClass
{
public DbSet<SomeEntity> SomeEntity { get; set; }
public SomeDatabase(ISomeDependency dep)
: base(dep)
{
var someEntityPrecompiledViewsMapping = new ViewsForBaseEntitySetsSomeEntityDatabase();
var mappingCollection = (StorageMappingItemCollection)ObjectContext.MetadataWorkspace.GetItemCollection(DataSpace.CSSpace);
string mappingHashValue = mappingCollection.ComputeMappingHashValue();
if (SomeEntityPrecompiledViewsMapping.MappingHashValue != mappingHashValue)
{
var precompiledViewGenerator = new EntityFrameworkPrecompiledViewGenerator();
string precompiledViewsContents = precompiledViewGenerator.GeneratePrecompiledViews(this, this.GetType().Name);
string viewFileForMainDb = "SomeEntityDatabase.Views.cs";
string temporaryPrecompiledViewFile = Path.Combine(Path.GetTempPath(), viewFileForMainDb);
try
{
File.WriteAllText(temporaryPrecompiledViewFile, precompiledViewsContents);
Process.Start("c:\\windows\\notepad.exe", temporaryPrecompiledViewFile);
}
catch (Exception err)
{
throw new Exception("An error occured while trying to regenerate precompiled views for EF since the database changed. Error is: " + err);
}
throw new EntityCommandCompilationException($"The precompiled views file is not in sync with the database any longer. Replace the file {viewFileForMainDb} with the generated new contents!");
}
}
}
}
The overall execution of code is the following:
- In the DbContext constructor - check that the computed mapping hash value matches to that of the of the CSSpace storagemapping collection that your precompiled views file contains (MappingHashValue)
- If the hash values do not agree, it is necessary to regenerate the pre compiled views file again. The contents are generated and written to a temporary file.
- Notepad or similar is launched telling the developer to replace the pre compiled views file contents with this new contents.
- An EntityCommandCompilationException is thrown as this is the same type of exception that is thrown if the precompiled views file does not agree
- Developer replaces the contents and rebuilds the solution
- The next time the startup time of EF should be reduced significantly again and work, since our DbContext and precomplied views are in sync again
Below is a sample of an exception thrown when my DbContext was not in sync with the precompiled views file:
System.Data.Entity.Core.EntityCommandCompilationException
System.Data.Entity.Core.EntityCommandCompilationException
HResult=0x8013193B
Message=An error occurred while preparing the command definition. See the inner exception for details.
Source=EntityFramework
StackTrace:
at System.Data.Entity.Core.EntityClient.Internal.EntityCommandDefinition..ctor(DbProviderFactory storeProviderFactory, DbCommandTree commandTree, DbInterceptionContext interceptionContext, IDbDependencyResolver resolver, BridgeDataReaderFactory bridgeDataReaderFactory, ColumnMapFactory columnMapFactory)
at System.Data.Entity.Core.EntityClient.Internal.EntityProviderServices.CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree, DbInterceptionContext interceptionContext)
at System.Data.Entity.Core.Objects.Internal.ObjectQueryExecutionPlanFactory.CreateCommandDefinition(ObjectContext context, DbQueryCommandTree tree)
at System.Data.Entity.Core.Objects.Internal.ObjectQueryExecutionPlanFactory.Prepare(ObjectContext context, DbQueryCommandTree tree, Type elementType, MergeOption mergeOption, Boolean streaming, Span span, IEnumerable`1 compiledQueryParameters, AliasGenerator aliasGenerator)
at System.Data.Entity.Core.Objects.ELinq.ELinqQueryState.GetExecutionPlan(Nullable`1 forMergeOption)
at System.Data.Entity.Core.Objects.ObjectQuery`1.<>c__DisplayClass7.<GetResults>b__6()
at System.Data.Entity.Core.Objects.ObjectContext.ExecuteInTransaction[T](Func`1 func, IDbExecutionStrategy executionStrategy, Boolean startLocalTransaction, Boolean releaseConnectionOnSuccess)
at System.Data.Entity.Core.Objects.ObjectQuery`1.<>c__DisplayClass7.<GetResults>b__5()
at System.Data.Entity.SqlServer.DefaultSqlExecutionStrategy.Execute[TResult](Func`1 operation)
at System.Data.Entity.Core.Objects.ObjectQuery`1.GetResults(Nullable`1 forMergeOption)
at System.Data.Entity.Core.Objects.ObjectQuery`1.<System.Collections.Generic.IEnumerable<T>.GetEnumerator>b__0()
at System.Data.Entity.Internal.LazyEnumerator`1.MoveNext()
at System.Linq.Enumerable.Single[TSource](IEnumerable`1 source)
atProgram.cs:line 164
Inner Exception 1:
MappingException: The current model no longer matches the model used to pre-generate the mapping views, as indicated by the ViewsForBaseEntitySetsabf8c33ac61e42fc601fe7446b41eaf48c7577efe6d6e17ccccc2b434793c28e.MappingHashValue property. Pre-generated mapping views must be either regenerated using the current model or removed if mapping views generated at runtime should be used instead. See http://go.microsoft.com/fwlink/?LinkId=318050 for more information on Entity Framework mapping views.
Share this article on LinkedIn.
No comments:
Post a Comment