使用具體類型實現ICollection <ISomething>以滿足實體框架

Question

所以，這是一個很遲鈍的問題，但讓我看看我是否可以相對簡單地佈置它。可以說我有以下接口：

public interface IFoo 
{ 
    ICollection<IBar> Bars { get; set; } 
} 

然後我與落實：

public class Foo : IFoo 
{ 
    public virtual ICollection<IBar> Bars { get; set; } 
} 

只有實體框架不能與接口的工作，所以它幾乎完全忽略了這個導航屬性。爲了獲得EF承認它，我需要將其更改爲：

public virtual ICollection<Bar> Bars { get; set; } 

凡Bar將是我實現IBar。只是，這沒有實現接口，它要IBar而不是Bar。

現在，考慮一個稍微不同的情景，在那裏我剛剛拿到了一個基本的外鍵：

public interface IFoo 
{ 
    IBar Bar { get; set; } 
} 

public class Foo : IFoo 
{ 
    public virtual IBar Bar { get; set; } 
} 

同樣的問題，但在這裏，我可以通過添加解決它：

public class Foo : IFoo 
{ 
    public virtual Bar Bar { get; set; } 
    IBar IFoo.Bar 
    { 
     get { return Bar; } 
     set { Bar = (Bar)value; } 
    } 
} 

EF很高興，因爲它有一個具體的類型，並且界面很開心，因爲它具有IBar的實現。問題在於我無法弄清楚如何將應用於相同的邏輯，因爲(ICollection<Bar>)value引發了一個異常，說「無法將類型ICollection<Bar>隱式轉換爲ICollection<IBar>」。

我該如何正確地演員陣容？

UPDATE

所以，我並沒有給予足夠的重視正在產生錯誤的位置。它實際上是在抱怨get { return Bars; }位。我可以通過它改變擺脫錯誤的：

public class Foo : IFoo 
{ 
    public virtual ICollection<Bar> Bars { get; set; } 
    ICollection<IBar> IFoo.Bars 
    { 
     get { return (ICollection<IBar>)Enumeration.Cast<IBar>(Bars); } 
     set { Bars = (ICollection<Bar>)value; } 
    } 
} 

這似乎有點做作我雖然喜歡我只是掩蓋錯誤，併爲自己創建一個小的定時炸彈。我會很感激任何想法或替代解決方案。

Answer 1

爲了讓協方差/逆變工作中，我定義的導航屬性可枚舉在我的接口：

public interface IFoo 
{ 
    IEnumerable<IBar> Bars { get; } 
} 

public class Foo : IFoo 
{ 
    public virtual ICollection<Bar> Bars { get; set; } 
    IEnumerable<IBar> IFoo.Bars 
    { 
     return this.Bars; 
    } 
} 

這仍然是不夠建在接口類型EF LINQ查詢。

Answer 2

我使用這樣

public class InterfaceCollectionAdapter<TConcrete, TInterface> : ICollection<TInterface> where TConcrete : TInterface 
{ 
    private Func<ICollection<TConcrete>> _gettor; 
    private Action<ICollection<TConcrete>> _settor; 
    private Func<ICollection<TConcrete>> _factory; 

    private ICollection<TConcrete> Wrapped 
    { 
     get 
     { 
      var value = _gettor(); 

      if (value == null && _settor != null) 
      { 
       value = (_factory != null) 
        ? _factory() 
        : new List<TConcrete>(); 

       _settor(value); 
      } 

      return value; 
     } 
    } 

    public InterfaceCollectionAdapter(Func<ICollection<TConcrete>> gettor, Action<ICollection<TConcrete>> settor = null, Func<ICollection<TConcrete>> factory = null) 
    { 
     _gettor = gettor; 
     _settor = settor; 
     _factory = factory; 
    } 

    public void Add(TInterface item) 
    { 
     Wrapped.Add((TConcrete)item); 
    } 

    public void Clear() 
    { 
     Wrapped.Clear(); 
    } 

    public bool Contains(TInterface item) 
    { 
     return Wrapped.Contains((TConcrete)item); 
    } 

    public void CopyTo(TInterface[] array, int arrayIndex) 
    { 
     var wrapped = Wrapped; 
     foreach (var item in wrapped) 
     { 
      array[arrayIndex++] = (TInterface)item; 
     } 
    } 

    public int Count 
    { 
     get { return Wrapped.Count; } 
    } 

    public bool IsReadOnly 
    { 
     get { return Wrapped.IsReadOnly; } 
    } 

    public bool Remove(TInterface item) 
    { 
     return Wrapped.Remove((TConcrete)item); 
    } 

    public IEnumerator<TInterface> GetEnumerator() 
    { 
     var wrapped = Wrapped; 
     foreach (var item in wrapped) 
      yield return item; 
    } 

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
    { 
     return this.GetEnumerator(); 
    } 
} 

一個通用的接口適配器然後在POCO你只需做到這一點

public Foo() 
{ 
    public Foo() 
    { 
     _bars = new InterfaceCollectionAdapter<Bar, IBar>(() => this.Bars, (value) => { this.Bars = value; }); 
    } 

    private InterfaceCollectionAdapter<Bar, IBar> _bars; 

    [NotMapped] 
    ICollection<IBar> IFoo.Bars 
    { 
     get 
     { 
      return _bars; 
     } 
    }