Using INotifyPropertyChanged with Entity Framework 6 DbContext Generator
This can be achieved by replacing the default T4 template (the .tt file automatically added by Entity Framework) with the following, then right clicking the .tt file and selecting "Run Custom Tool".
Important: This will regenerate your models which will cause any customizations to be discarded. I recommend you implement your customizations via the template rather than modifying the model class directly to prevent this from being a problem in the future.
Note: Replace string inputFile = @"MessageLog.edmx";
with the name of your edmx file.
<#@ template language="C#" debug="false" hostspecific="true"#>
<#@ include file="EF.Utility.CS.ttinclude"#><#@
output extension=".cs"#><#
CodeGenerationTools code = new CodeGenerationTools(this);
MetadataLoader loader = new MetadataLoader(this);
CodeRegion region = new CodeRegion(this, 1);
MetadataTools ef = new MetadataTools(this);
string inputFile = @"MessageLog.edmx";
EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(inputFile);
string namespaceName = code.VsNamespaceSuggestion();
EntityFrameworkTemplateFileManager fileManager = EntityFrameworkTemplateFileManager.Create(this);
WriteHeader(fileManager);
foreach (var entity in ItemCollection.GetItems<EntityType>().OrderBy(e => e.Name))
{
fileManager.StartNewFile(entity.Name + ".cs");
BeginNamespace(namespaceName, code);
#>
using System;
using System.Collections.Generic;
using System.ComponentModel;
<#=Accessibility.ForType(entity)#> <#=code.SpaceAfter(code.AbstractOption(entity))#>partial class <#=code.Escape(entity)#> : INotifyPropertyChanged<#=code.StringBefore(", ", code.Escape(entity.BaseType))#>
{
<#
var propertiesWithDefaultValues = entity.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == entity && p.DefaultValue != null);
var collectionNavigationProperties = entity.NavigationProperties.Where(np => np.DeclaringType == entity && np.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many);
var complexProperties = entity.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == entity);
if (propertiesWithDefaultValues.Any() || collectionNavigationProperties.Any() || complexProperties.Any())
{
#>
public <#=code.Escape(entity)#>()
{
<#
foreach (var edmProperty in propertiesWithDefaultValues)
{
#>
this.<#=code.Escape(edmProperty)#> = <#=code.CreateLiteral(edmProperty.DefaultValue)#>;
<#
}
foreach (var navigationProperty in collectionNavigationProperties)
{
#>
this.<#=code.Escape(navigationProperty)#> = new ObservableListSource<<#=code.Escape(navigationProperty.ToEndMember.GetEntityType())#>>();
<#
}
foreach (var complexProperty in complexProperties)
{
#>
this.<#=code.Escape(complexProperty)#> = new <#=code.Escape(complexProperty.TypeUsage)#>();
<#
}
#>
}
<#
}
var primitiveProperties = entity.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == entity);
if (primitiveProperties.Any())
{
foreach (var edmProperty in primitiveProperties)
{
WriteProperty(code, edmProperty);
}
}
if (complexProperties.Any())
{
#>
<#
foreach(var complexProperty in complexProperties)
{
WriteProperty(code, complexProperty);
}
}
var navigationProperties = entity.NavigationProperties.Where(np => np.DeclaringType == entity);
if (navigationProperties.Any())
{
#>
<#
foreach (var navigationProperty in navigationProperties)
{
WriteNavigationProperty(code, navigationProperty);
}
}
#>
#region INotifyPropertyChanged Members
public event PropertyChangedEventHandler PropertyChanged;
protected void OnPropertyChanged(string propertyName)
{
OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
}
protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
{
if (PropertyChanged != null)
PropertyChanged(this, e);
}
#endregion
}
<#
EndNamespace(namespaceName);
}
foreach (var complex in ItemCollection.GetItems<ComplexType>().OrderBy(e => e.Name))
{
fileManager.StartNewFile(complex.Name + ".cs");
BeginNamespace(namespaceName, code);
#>
using System;
<#=Accessibility.ForType(complex)#> partial class <#=code.Escape(complex)#>
{
<#
var complexProperties = complex.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == complex);
var propertiesWithDefaultValues = complex.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == complex && p.DefaultValue != null);
if (propertiesWithDefaultValues.Any() || complexProperties.Any())
{
#>
public <#=code.Escape(complex)#>()
{
<#
foreach (var edmProperty in propertiesWithDefaultValues)
{
#>
this.<#=code.Escape(edmProperty)#> = <#=code.CreateLiteral(edmProperty.DefaultValue)#>;
<#
}
foreach (var complexProperty in complexProperties)
{
#>
this.<#=code.Escape(complexProperty)#> = new <#=code.Escape(complexProperty.TypeUsage)#>();
<#
}
#>
}
<#
}
var primitiveProperties = complex.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == complex);
if (primitiveProperties.Any())
{
foreach(var edmProperty in primitiveProperties)
{
WriteProperty(code, edmProperty);
}
}
if (complexProperties.Any())
{
#>
<#
foreach(var edmProperty in complexProperties)
{
WriteProperty(code, edmProperty);
}
}
#>
}
<#
EndNamespace(namespaceName);
}
if (!VerifyTypesAreCaseInsensitiveUnique(ItemCollection))
{
return "";
}
fileManager.Process();
#>
<#+
string GetResourceString(string resourceName)
{
if(_resourceManager == null)
{
_resourceManager = new System.Resources.ResourceManager("System.Data.Entity.Design", typeof(System.Data.Entity.Design.MetadataItemCollectionFactory).Assembly);
}
return _resourceManager.GetString(resourceName, null);
}
System.Resources.ResourceManager _resourceManager;
void WriteHeader(EntityFrameworkTemplateFileManager fileManager)
{
fileManager.StartHeader();
#>
//------------------------------------------------------------------------------
// <auto-generated>
// <#=GetResourceString("Template_GeneratedCodeCommentLine1")#>
//
// <#=GetResourceString("Template_GeneratedCodeCommentLine2")#>
// <#=GetResourceString("Template_GeneratedCodeCommentLine3")#>
// </auto-generated>
//------------------------------------------------------------------------------
<#+
fileManager.EndBlock();
}
void BeginNamespace(string namespaceName, CodeGenerationTools code)
{
CodeRegion region = new CodeRegion(this);
if (!String.IsNullOrEmpty(namespaceName))
{
#>
namespace <#=code.EscapeNamespace(namespaceName)#>
{
<#+
PushIndent(CodeRegion.GetIndent(1));
}
}
void EndNamespace(string namespaceName)
{
if (!String.IsNullOrEmpty(namespaceName))
{
PopIndent();
#>
}
<#+
}
}
void WriteProperty(CodeGenerationTools code, EdmProperty edmProperty)
{
WriteProperty(Accessibility.ForProperty(edmProperty),
code.Escape(edmProperty.TypeUsage),
code.Escape(edmProperty),
code.SpaceAfter(Accessibility.ForGetter(edmProperty)),
code.SpaceAfter(Accessibility.ForSetter(edmProperty)));
}
void WriteNavigationProperty(CodeGenerationTools code, NavigationProperty navigationProperty)
{
var endType = code.Escape(navigationProperty.ToEndMember.GetEntityType());
WriteProperty(PropertyVirtualModifier(Accessibility.ForProperty(navigationProperty)),
navigationProperty.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many ? ("ObservableListSource<" + endType + ">") : endType,
code.Escape(navigationProperty),
code.SpaceAfter(Accessibility.ForGetter(navigationProperty)),
code.SpaceAfter(Accessibility.ForSetter(navigationProperty)));
}
void WriteProperty(string accessibility, string type, string name, string getterAccessibility, string setterAccessibility)
{
#>
private <#=type#> _<#=name#>;
public <#=type#> <#=name#>
{
<#=getterAccessibility#>get { return _<#=name#>; }
<#=setterAccessibility#>set
{
if (_<#=name#> != value)
{
_<#=name#> = value;
OnPropertyChanged("<#=name#>");
}
}
}
<#+
}
string PropertyVirtualModifier(string accessibility)
{
return accessibility + (accessibility != "private" ? " virtual" : "");
}
bool VerifyTypesAreCaseInsensitiveUnique(EdmItemCollection itemCollection)
{
var alreadySeen = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
foreach(var type in itemCollection.GetItems<StructuralType>())
{
if (!(type is EntityType || type is ComplexType))
{
continue;
}
if (alreadySeen.ContainsKey(type.FullName))
{
Error(String.Format(CultureInfo.CurrentCulture, "This template does not support types that differ only by case, the types {0} are not supported", type.FullName));
return false;
}
else
{
alreadySeen.Add(type.FullName, true);
}
}
return true;
}
#>
How to generate navigation properties with EntityFramework Reverse POCO Generator?
The error says it all:
System.Data.Entity.IDbSet' does not contain a definition for 'Include' and no extension method...
The interface just doesn't have the method. I'm not sure why these method are not part of the interface. Maybe because IDbSet
was introduced to facilitate mocking, and Include
is a method that's very hard to mock.
Instead, you can use one of the the Include
extension methods in the namespace System.Data.Entity
. These method are defined on IQueryable(<T>)
, which is an interface that IDbSet
implements.
The same is true for another important method that's not in the IDbSet
interface: AsNoTracking. (Also hard to mock - in a sense - because tracking is hard to mock).
Files created by DbContext Generator
In case of old POCO T4 template this file was used for some shared code like FixupCollection
. In DbContext T4 template it probably doesn't have real meaning but the default custom tool used to generate file from T4 template somehow expects that this file will be created (all other files our hacked in).
Implement INotifyPropertyChanged on generated Entity Framework classes
If you follow the recommended MVVM pattern for WPF, you can treat your generated classes as the Model, and then write ViewModel wrappers that implement INotifyPropertyChanged. The ViewModel classes would access your DB classes and expose properties that you can bind to your UI in XAML.
As noted in your comment, this can result in a lot of work writing boilerplate code, but there are some ways to deal with that. See this question for some ideas.
While more work at first, the MVVM pattern can definitely pay off in the long run if you ever need to do any intermediate formatting or processing, or if you need to change your database classes without affecting the UI.
Related Topics
How to Change Another Program's Window's Size
Is There a C# Generic Constraint for "Real Number" Types
How to Decode String to Xml String in C#
How to Create a Button That Can Send Keys to a Conrol Without Losing Focus - Virtual Keyboard
Entity Framework - Add Navigation Property Manually
Viewmodel Validation for a List
Itemscontrol with Horizontal Orientation
Parsing a JSON Array Using JSON.Net
Winforms Issue - Error Creating Window Handle
Generate C# Project Using Cmake
How to Set a Conditional Compile Variable
Rotate a Point by Another Point in 2D
Bring Another Processes Window to Foreground When It Has Showintaskbar = False
Enumerating Through an Object's Properties (String) in C#
How to Create Custom Propertygrid Editor Item Which Opens a Form
How to Use More Than One Processor Group for My Threads in a C# App