Разделение объекта, когда ключевой столбец имеет разные имена?

Question

Я использую Entity Framework 4.3.1 Code-First, и мне нужно разделить сущность между двумя таблицами. В таблицах используется общий первичный ключ, и он равен 1 к 1, но столбцы не называются одинаковыми для каждой таблицы.

Я не контролирую расположение данных и не могу запросить никаких изменений.

Так, например, таблицы SQL может быть

И это было бы мое лицо ...

public class MyEntity 
{ 
    public int Id {get; set;} 
    public string Name {get;set} 
    public string FromAnotherTable {get;set;} 
} 

А вот отображение у меня есть.

public class MyEntityMapping : EntityTypeConfiguration<MyEntity> 
{ 
    public MyEntityMapping() 
    { 
     this.Property(e => e.Id).HasColumnName("ThePrimaryKeyId"); 
     this.Property(e => e.Name).HasColumnName("MyDatabaseName"); 
     this.Property(e => e.FromAnothertable).HasColumnName("AnotherTableColumn"); 
     this.Map(m => 
      { 
       m.Properties(e => 
        { 
         e.Id, 
         e.Name 
        }); 
       m.ToTable("MainTable"); 
      }); 
     this.Map(m => 
      { 
       m.Properties(e => 
        { 
         e.Id, 
         e.FromAnotherTable 
        }); 
       m.ToTable("ExtendedTable"); 
      }); 
} 

Поскольку ключ, используемый между ними, имеет другое название столбца, я не уверен, как его сопоставить. Это сопоставление будет компилироваться, но не выполняется во время выполнения, потому что EF испускает SQL, который ищет столбец «ThePrimaryKeyId» в таблице «ExtendedTable», которого нет.

РЕДАКТИРОВАТЬ Чтобы уточнить, что я определено выше может (и делает) работать, если ПК на «ExtendedTable» последовали соглашения об именах. Но это не так, и я не могу изменить схему.

В принципе, то, что мне нужно EF испускать это SQL заявление, как

SELECT 
    [e1].*, /*yes, wildcards are bad. doing it here for brevity*/ 
    [e2].* 
FROM [MainTable] AS [e1] 
INNER JOIN [ExtendedTable] AS [e2] /*Could be left join, don't care. */ 
    ON [e1].[ThePrimaryKeyId] = [e2].[NotTheSameName] 

Но единственное, что он, кажется, хочет, чтобы излучать в

SELECT 
     [e1].*, 
     [e2].* 
    FROM [MainTable] AS [e1] 
    INNER JOIN [ExtendedTable] AS [e2] 
     ON [e1].[ThePrimaryKeyId] = [e2].[ThePrimaryKeyId] /* this column doesn't exist */ 

Редактировать Я попробовал 1 -to-1 снова подходит к предложению NSGaga. Это не сработало, но вот результаты. Сущность

public class MyEntity 
{ 
    public int Id { get; set; } 
    public int Name { get; set; } 
    public virtual ExtEntity ExtendedProperties { get; set; } 
} 
public class ExtEntity 
{ 
    public int Id { get; set; } 
    public string AnotherTableColumn { get; set; } 
    public virtual MyEntity MainEntry { get; set; } 
} 

Вот классы отображения

public class MyEntityMapping : EntityTypeConfiguration<MyEntity> 
{ 
    public MyEntityMapping() 
    { 
     this.Property(e => e.Id).HasColumnName("ThePrimaryKeyId"); 
     this.Property(e => e.Name).HasColumnName("MyDatabaseName"); 
     this.ToTable("MainTable"); 
     this.HasKey(e => e.Id); 
     this.HasRequired(e => e.ExtendedProperties).WithRequiredPrincipal(f => f.MainEntry); 
    } 
} 

public class ExtEntityMapping : EntityTypeConfiguration<ExtEntity> 
{ 
    public ExtEntityMapping() 
    { 
     this.Property(e => e.Id).HasColumnName("NotTheSameName"); 
     this.Property(e => e.AnotherTableColumn).HasColumnName("AnotherTableColumn"); 
     this.ToTable("ExtendedTable"); 
     this.HasKey(e => e.Id); 
     this.HasRequired(e => e.MainEntry).WithRequiredDependent(f => f.ExtendedProperties); 
    } 
} 

Эта установка получает сообщение

"Column or attribute 'MyEntity_ThePrimaryKeyId' is not defined in 'ExtendedTable'" 

Изменения последней строки карты для

this.HasRequired(e => e.MainEntry).WithRequiredDependent(f => f.ExtendedProperties).Map(m => M.MapKey("NotTheSameName")); 

Вернуться s это сообщение

"Each property name in a type must be unique. property name 'NotTheSameName' was already defined." 

Изменение переведенный ключ использовать столбец из родительской таблицы, MapKey("ThePrimaryKeyId"). возвращает это сообщение

"Column or attribute 'ThePrimaryKeyId' is not defined in 'ExtendedTable'" 

Id Удаление свойства из ExtEntity класса выдает ошибку, потому что тогда объект не имеет определенного ключа.

Answer 1

Я не могу найти ничего, что конкретно говорится, что имя столбца должны быть одинаковыми в обеих таблицах; но я не могу найти ничего, что говорит, что это не так, или объясняет, как вы могли бы сопоставить этот сценарий. Каждый пример, который я могу найти, имеет ключ с тем же именем в обеих таблицах. Мне кажется, что это дыра в дизайне DbContext.

Answer 2

Нет Visual Studio здесь, но попробовать это с 1-на-1 подход:

this.HasRequired (е => е.ExtendedProperties) .HasConstraint ((e, m) => e.Id == m.Id);

Update:
Вот некоторые ссылки, которые могут помочь (не мог найти реальную ссылку ссылка)

How to declare one to one relationship using Entity Framework 4 Code First (POCO)
Entity Framework 4 CTP 4 Code First: how to work with unconventional primary and foreign key names

Answer 3

И просто предоставить (как я обещал) сопоставление 1 к 1 (два сущности, два стола), для чего это стоит.
Вот то, что работает для меня, и должно быть в вашем случае ...

public class MainTable 
{ 
    public int ThePrimaryKeyId { get; set; } 
    public string Name { get; set; } 
} 
public class ExtendedTable 
{ 
    public int NotTheSameNameID { get; set; } 
    public string AnotherTableColumn { get; set; } 
    public MainTable MainEntry { get; set; } 
} 
public class MainDbContext : DbContext 
{ 
    public DbSet<MainTable> MainEntries { get; set; } 
    public DbSet<ExtendedTable> ExtendedEntries { get; set; } 
    protected override void OnModelCreating(DbModelBuilder modelBuilder) 
    { 
     modelBuilder.Entity<MainTable>() 
      .HasKey(x => new { x.ThePrimaryKeyId }); 

     modelBuilder.Entity<ExtendedTable>() 
      .HasKey(x => new { x.NotTheSameNameID }); 

     // Extended To Main 1 on 1 
     modelBuilder.Entity<ExtendedTable>() 
      .HasRequired(i => i.MainEntry) 
      .WithRequiredDependent(); 
    } 
} 

... и тестовый код что-то вроде ...

using (var db = new UserDbContext()) 
{ 
    foreach (var userid in Enumerable.Range(1, 100)) 
    { 
     var main = new MainTable { Name = "Main" + userid }; 
     db.MainEntries.Add(main); 

     var extended = new ExtendedTable { AnotherTableColumn = "Extended" + userid, MainEntry = main }; 
     db.ExtendedEntries.Add(extended); 
    } 
    int recordsAffected = db.SaveChanges(); 
    foreach (var main in db.MainEntries) 
     Console.WriteLine("{0}, {1}", main.Name, main.ThePrimaryKeyId); 
    foreach (var extended in db.ExtendedEntries) 
     Console.WriteLine("{0}, {1}, {2}, {3}", extended.AnotherTableColumn, extended.NotTheSameNameID, extended.MainEntry.Name, extended.MainEntry.ThePrimaryKeyId); 
} 

Это создает следующий SQL скрипт, таблицы ...

CREATE TABLE [MainTables] (
    [ThePrimaryKeyId] [int] NOT NULL IDENTITY, 
    [Name] [nvarchar](4000), 
    CONSTRAINT [PK_MainTables] PRIMARY KEY ([ThePrimaryKeyId]) 
) 
CREATE TABLE [ExtendedTables] (
    [NotTheSameNameID] [int] NOT NULL, 
    [AnotherTableColumn] [nvarchar](4000), 
    CONSTRAINT [PK_ExtendedTables] PRIMARY KEY ([NotTheSameNameID]) 
) 
CREATE INDEX [IX_NotTheSameNameID] ON [ExtendedTables]([NotTheSameNameID]) 
ALTER TABLE [ExtendedTables] ADD CONSTRAINT [FK_ExtendedTables_MainTables_NotTheSameNameID] FOREIGN KEY ([NotTheSameNameID]) REFERENCES [MainTables] ([ThePrimaryKeyId]) 

И примечание, согласно нашей дискуссии выше ...
Это не «расщепления» - но
(а) первый код ИМО не допускает ничего подобного (я пробовал это сначала, а также вручную изменял миграцию, но он «внутренне» все на основе ожидаемых имен столбцов, являющихся одним и тем же, и, похоже, , по крайней мере для этой версии EF.
(b) структура таблицы мудрая - таблицы могут быть сделаны так, чтобы они выглядели точно, что вам нужно (как я уже говорил, прежде чем использовать его для связи существующих таблиц членства aspnet (которые я не мог изменить) в своей таблице пользователя, которая имеет собственный идентификатор пользователя, указывающий на внешнюю/aspnet-таблицу и идентификатор.
Правда, вы не можете сделать это с использованием одного класса модели C#, но сторона C# намного более гибкая, и если вы можете контролировать C#, который должен дать тот же эффект, мое мнение по крайней мере (как и в тесте, вы можете получить доступ к нему всегда через расширенный объект, как расширенные, так и основные столбцы, и они всегда совпадают с 1 по 1 и остаются «синхронными».
Надеюсь, это поможет некоторым
ПРИМЕЧАНИЕ. Вам не нужно беспокоиться о fk id и т. Д. - просто всегда обращайтесь и добавляйте главную запись через MainEntry, а id-s будет хорошо.

EDIT:
Вы могли бы также сделать следующее, чтобы получить внешний вид, чтобы иметь дело только с одним классом (т.е. рода раскола)

public class ExtendedTable 
{ 
    public int NotTheSameNameID { get; set; } 
    public string AnotherTableColumn { get; set; } 

    public string Name { get { return MainEntry.Name; } set { MainEntry.Name = value; } } 
    // public int MainID { get { return MainEntry.ThePrimaryKeyId; } set { MainEntry.ThePrimaryKeyId = value; } } 
    internal MainTable MainEntry { get; set; } 

    public ExtendedTable() 
    { 
     this.MainEntry = new MainTable(); 
    } 
} 

... и использовать его как это ...

var extended = new ExtendedTable { AnotherTableColumn = "Extended" + userid, Name = "Main" + userid }; 

... также вы можете вернуть направление Ф.К., делая WithRequiredPrincipal вместо зависимой.
(также необходимо, чтобы все ссылки должны были быть «виртуальными»), если вам требуется один-к-одному)
(и MainTable можно сделать «внутренним», как он есть здесь, поэтому он не виден снаружи - он не может быть вложенной, поскольку EF не позволяет - обрабатывается как NotMapped)
...ну, это лучшее, что я мог сделать :)

Answer 4

Я хотел бы предложить использовать некоторые аннотации данных, как это:

MainTable 
--------- 
MainTableId 
DatabaseName 

ExtendedTable 
---------- 
NotTheSameName 
AnotherColumn 

public class MainTable 
{ 
[Key] 
public int MainTableId { get; set; } 
public string DatabaseName { get; set; } 

[InverseProperty("MainTable")] 
public virtual ExtendedTable ExtendedTable { get; set; } 
} 

public class ExtendedTable 
{ 
[Key] 
public int NotTheSameName { get; set; } 

public string AnotherColumn { get; set; } 

[ForeignKey("NotTheSameName")] 
public virtual MainTable MainTable { get; set; } 
} 

Answer 5

Похоже, это было исправлено в Entity Framework 6. См Эта проблема http://entityframework.codeplex.com/workitem/388

Answer 6

Перемещение HasColumnName в пределах отображения:

this.Property(e => e.FromAnothertable).HasColumnName("AnotherTableColumn"); 
this.Map(m => 
    { 
     m.Properties(e => new 
      { 
       e.Id, 
       e.Name 
      }); 
      m.Property(e => e.Id).HasColumnName("ThePrimaryKeyId"); 
      m.Property(e => e.Name).HasColumnName("MyDatabaseName"); 

      m.Property(e => e.Id).HasColumnName("ThePrimaryKeyId"); 
     m.ToTable("MainTable"); 
    }); 
this.Map(m => 
    { 
     m.Properties(e => new 
      { 
       e.Id, 
       e.FromAnotherTable 
      }); 
     m.ToTable("ExtendedTable"); 
    }); 
} 

Answer 7

я работал на этой самой проблеме в течение нескольких дней, что я наконец-то сделал, чтобы установить столбец па меня поле Id в пределах контекст фрагмента отображения. Таким образом вы можете присвоить идентификатору (или внешнему ключу, зависящему от идентификатора) другое имя от идентификатора основной таблицы.

this.Map(m => 
    { 
     m.Property(p => p.Id).HasColumnName("NotTheSameName"); 
     m.Properties(e => 
      { 
       e.Id, 
       e.FromAnotherTable 
      }); 
     m.ToTable("ExtendedTable"); 
    }); 

Если запускать и отлаживать это, вы обнаружите, что это даст вам что-то вроде того, что вы хотите:

[e1].[ThePrimaryKeyId] = [e2].[NotTheSameName] 

Answer 8

я столкнулся этот вопрос, и решается добавить столбец атрибутов, чтобы соответствовать обоим имена столбцов. [Key] [Column("Id")] public int GroupId { get; set; }