I was trying to create a second data model to combine with another model into a common Domain Data Model using the DF2010 method of specifying the same EntityManager name for each model in the edmx properties and in theory, the code gen will only create the constructors/default entity manager once and they'll be treated as a common model.

 

I had the first model already created and didn't edit or open it prior to adding the second model.

 

I created the second model, setting it's EntityManager name to the same one used by the first model and saved.  Code gen worked but when I built the solution, I get errors as the second model generated code tries to instantiate the same EM constructors and new-up the same default entity manager.

 

If, however, I edit both edmx files and change their EntityManager name to a different common name and save all together (can't save each change or you have the same problem), it works fine.   The first code gen file does the constructors/new-up EM and the second skips it.

 

So any time a new model is added (obviously not that often), I need to have all the models checked out and change all of them together (presumably to a new name and then back to the real EM name) before building the solution or is there something I'm missing?

 

Can someone from IdeaBlade weigh in on this, maybe with a better work-around or a fix?

 

 

It's a hack but until IB releases a fix, but this will get around the duplicate declarations.

 

Change the <modelname>.edmx.tt file that is auto-created for each *.edmx to (either plugging in your data model name where it says $edmxname$: 

 

<#@ template  language="C#" debug="true" hostSpecific="true" #>
<#@ output extension=".ReadMe" #>
<#@ Assembly Name="System.Core.dll" #>
<#@ Assembly Name="System.Data.Entity.dll" #>
<#@ Assembly Name="Microsoft.VisualStudio.TextTemplating.10.0" #>
<#@ Assembly Name="IdeaBlade.Core" #>
<#@ Assembly Name="IdeaBlade.VisualStudio.DTE.dll" #>
<#@ Assembly Name="IdeaBlade.VisualStudio.OM.CodeGenerator.dll" #>
<#@ Assembly Name="IdeaBlade.EntityModel.Edm.Metadata.dll" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Reflection" #>
<#@ import namespace="System.Data.Entity" #>
<#@ import namespace="IdeaBlade.VisualStudio.DTE" #>
<#@ import namespace="IdeaBlade.VisualStudio.OM.CodeGenerator" #>
<#@ import namespace="IdeaBlade.EntityModel.Edm.Metadata" #>
<#
 // Source for this file located at: $templateFullFileName$
 // $edmxname$  <--- This is needed so that "Transform Related Text Templates On Save" works correctly.
 var template = new MyTemplate(this);
 template.Generate();
#>
<#+
 public class MyTemplate : DomainModelTemplate {
  public MyTemplate(Microsoft.VisualStudio.TextTemplating.TextTransformation textTransformation)
   :base(textTransformation) {}
    
   // HACK: override to prevent DevForce from generating the EM in the designer files
   // since it seems to get confused by multiple EDMX files using the same EM.
   // This means we have to have a partial class for the default em declared that does
   // the constructor/new-up of the EM and link that class in the Silverlight project
   protected override void WriteEntityManagerCtors(CsdlWrapper csdl)
   {
    WriteToOutputWindow("Suppressing Entity Manager Constructor Generation for: " +
     csdl.EntityManagerName);
   }
   
   protected override void WriteEntityManagerDefaultManager(CsdlWrapper csdl)
   {
    WriteToOutputWindow("Suppressing Entity Manager Default Manager Generation: " +
     csdl.EntityManagerName);
   }
   
 }
#>

 

Adding a partial class for the Domain Model Entity Manager (the common EM shared across data models) and linking this class to the Silverlight project.  For example:

 

MyEntityManager.cs (just copied the stuff from the *.IB.Designer.cs file):

 

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.Serialization;
using IbEm   = IdeaBlade.EntityModel;
using IbCore = IdeaBlade.Core;
using IbVal  = IdeaBlade.Validation;

 

namespace <yournamespacehere>
{

    /// <summary>
    /// The domain-specific EntityManager for your domain model.
    /// </summary>
    public partial class MyEntityManager : IbEm.EntityManager
    {

        #region Constructors

        /// <summary>See <see cref="M:IbEm.EntityManager.#ctor()"/>. </summary>
        public MyEntityManager() : base() { }

        /// <summary>See <see cref="M:IbEm.EntityManager.#ctor(Boolean)"/>. </summary>
        public MyEntityManager(Boolean shouldConnect) : base(shouldConnect) { }

        /// <summary>See <see cref="M:IbEm.EntityManager.#ctor(Boolean, String)"/>. </summary>
        public MyEntityManager(Boolean shouldConnect, String dataSourceExtension) : base(shouldConnect, dataSourceExtension) { }

        /// <summary>See <see cref="M:IbEm.EntityManager.#ctor(Boolean, String, IbEm.EntityServiceOption)"/>. </summary>
        public MyEntityManager(Boolean shouldConnect, String dataSourceExtension, IbEm.EntityServiceOption entityServiceOption) : base(shouldConnect, dataSourceExtension, entityServiceOption) { }

        /// <summary>See <see cref="M:IbEm.EntityManager.#ctor(IbEm.EntityManager)"/>. </summary>
        public MyEntityManager(IbEm.EntityManager entityManager) : base(entityManager) { }

        /// <summary>See <see cref="M:IbEm.EntityManager.#ctor(IbEm.EntityManager, Boolean, String, IbEm.EntityServiceOption)"/>. </summary>
        public MyEntityManager(IbEm.EntityManager entityManager, Boolean shouldConnect, String dataSourceExtension, IbEm.EntityServiceOption entityServiceOption) : base(entityManager, shouldConnect, dataSourceExtension, entityServiceOption) { }

        static MyEntityManager()
        {
            IbEm.EntityRelation.InitializeEntityRelations(Assembly.GetExecutingAssembly());
        }
        #endregion Constructors

        #region DefaultManager

        /// <summary>Gets the default manager. </summary>
        public new static MyEntityManager DefaultManager
        {
            get { return GetDefaultEntityManager<MyEntityManager>(); }
        }
        #endregion DefaultManager

    }

 

 

 

I ended up just overriding this bool in 5 of the 6 models T4 (all of their T4 templates now just include a common T4 so the code isn't repeated) and in one of them, I force it to be the primary.  This way, I don't have to have a separate class for the Entity Manager ctors/creation and I can just let your code do it's stuff and I always know which one has the EM created.

 

Thanks for pointing this out.  We do have logic that manages the "primary" and "secondary" managers, but the eventing code path when a new model is added has a bug.  We will get this fixed.

 

Here are the simplest rules I've found when fixing an issue with multiple EDMXs:

This invokes the DevForce logic which will get the primary and seconday classes synchronized.

 

 

I also (just an FYI) had to override the WriteStandardHeader method since it was the other place that referenced this value (for including the IB license info in the primary model).

static GTDMEntityManager _GTDMEntityManager = new GTDMEntityManager(); 
static PTXARCEntityManager _PTXARCEntityManager = new PTXARCEntityManager() 

 

 

 

Actually, you're doing just fine.  However:

 

1)  You should be setting the "EntityManager Name" instead of the Entity Container Name.

 

2)  DevForce does not know how to generate the cross-datasource navigation automatically.  You have to write these properties manually.  If you're using WPF, this is fairly straightforward as it's just a LINQ query.  In Silverlight, it's a bit different because all non-cache queries have to be asynchronous, so we return pending collections or pending entities.  We don't have any examples of this yet, though.