我正在考虑与Linq进行某种类型的左外连接,但我对如何设置它有点困惑.我也愿意接受更好的解决方案.

更新：我应该注意到这些是我的“EmailAddress”对象的自定义数据类型列表.

假设Address是EmailAddress的字符串属性,这里是左连接解决方​​案.

IEnumerable<EmailAddress> query = 
  from a1 in list1
  join a2 in list2 on a1.Address equals a2.Address into g
  from x in g.DefaultIfEmpty()
  where x == null
  select a1;

简单：从TEntity派生的运行时类型的对象的多态删除添加到ObjectSet< TEntity>不会在ObjectSet< TEntity> .IListSource.GetList()方法返回的IBindingList对象上引发IBindingList.ListChanged事件.

但是,在ListChanged事件上有效地通知删除运行时类型与TEntity匹配的实例.

为了澄清,在任何时候,对象都被有效地从底层集合或数据视图/存储中移除,但是当这些对象是严格从所使用的实际TEntity派生的类型的实例时,不会引发ListChanged事件以通知它们的移除.

对于集合的运行时多态性的适当数据绑定支持,这只是一个惊人的BUG.

REPLICATION

型号设置

>每种类型策略表.
>在Server 2012 Express上针对已着色的sql数据库映射和验证实体模型.

这是实体层次结构(伪UML)：

FiascoEntityContext : ObjectContext
  + Foos : ObjectSet<Foo>

Foo : EntityObject
  + Id: Int32
  + Name: String

SpecialFoo : Foo
  + SpecialProperty: String

示范代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Data.Objects;

namespace FiascoEF {
    class Program {
        static void Main(string[] args) {
            using (FiascoEntityContext context = new FiascoEntityContext()) {
                //
                // add some foos
                //
                context.Foos.Addobject(new Foo { Name = "Foo1" });
                context.Foos.Addobject(new BetterFoo { Name = "BetterFoo1",SpecialProperty = "Something Special" });
                context.SaveChanges();
                //
                // show the contents
                //
                Console.WriteLine("Listing all foos:");
                foreach (var foo in context.Foos) {
                    Console.WriteLine("     Got {0}: Id={1} Name={2} (State={3})",foo,foo.Id,foo.Name,foo.EntityState);
                }
                //
                // attach handler for the ListChanged event of the IBindingList returned by context.Foos as IListSource
                // NOTE: have to do this here bacause SaveChanges() above will reset the internal IBindingList
                //
                var bindingList = (context.Foos as IListSource).GetList() as IBindingList;
                bindingList.ListChanged += new ListChangedEventHandler(bindingList_ListChanged);
                //
                // delete all foos and show state. expect the event handler above to be invoked.
                //
                Console.WriteLine("Deleting all foos:");
                foreach (var foo in context.Foos) {
                    context.Foos.DeleteObject(foo);
                    Console.WriteLine("     Deleted {0}: Id={1} Name={2} (State={3})",foo.EntityState);
                }
                context.SaveChanges();
            }
        }

        static void bindingList_ListChanged(object sender,ListChangedEventArgs e) {
            Console.WriteLine("     Event on {0}: {1}",sender,e.ListChangedType);
        }
    }
}

预期成绩

Listing all foos:
     Got FiascoEF.Foo: Id=257 Name=Foo1 (State=Unchanged)
     Got FiascoEF.BetterFoo: Id=258 Name=BetterFoo1 (State=Unchanged)
Deleting all foos:
     Event on System.Data.Objects.ObjectView`1[FiascoEF.Foo]: ItemDeleted
     Deleted FiascoEF.Foo: Id=257 Name=Foo1 (State=Deleted)
     Event on System.Data.Objects.ObjectView`1[FiascoEF.Foo]: ItemDeleted
     Deleted FiascoEF.BetterFoo: Id=258 Name=BetterFoo1 (State=Deleted)

实际结果

Listing all foos:
     Got FiascoEF.Foo: Id=257 Name=Foo1 (State=Unchanged)
     Got FiascoEF.BetterFoo: Id=258 Name=BetterFoo1 (State=Unchanged)
Deleting all foos:
     Event on System.Data.Objects.ObjectView`1[FiascoEF.Foo]: ItemDeleted
     Deleted FiascoEF.Foo: Id=257 Name=Foo1 (State=Deleted)
     Deleted FiascoEF.BetterFoo: Id=258 Name=BetterFoo1 (State=Deleted)

研究

通过反射器发现返回的实际IBindingList是ObjectView< TElement>类型,并且此类型将删除操作委托给内部IObjectViewData< TElement>.为该接口找到的实现是ObjectViewQueryResultData< TElement>它定义：

public ListChangedEventArgs OnCollectionChanged(object sender,CollectionChangeEventArgs e,ObjectViewListener listener) {

    ListChangedEventArgs changeArgs = null;

    if (e.Element.GetType().IsAssignableFrom(typeof(TElement)) && _bindingList.Contains((TElement) (e.Element))) {
        ...
        changeArgs = new ListChangedEventArgs(ListChangedType.ItemDeleted,...);
        ...
    }

    return changeArgs;
}

支票：

if (e.Element.GetType().IsAssignableFrom(typeof(TElement)) && ...) { ... }

似乎是假的…可能以下是有意的吗？

if (typeof(TElement).IsAssignableFrom(e.Element.GetType()) && ...) { ... }

记住,我们正在谈论由ObjectSet< T>检索的IBindingList实现.当出于数据绑定的目的被视为IListSource时,预期事件将被触发,就像它对同类列表的情况一样.

我通过定义一个继承自ObservableCollection< T>的类来解决这个问题.并且包装ObjectSet< T>,然后在DbExtensions.ToBindingList< T>(此ObservableCollection< T>)扩展方法的帮助下实现IListSource.

或者,我可以继续完全开始使用DbContext API,但是定义我自己的ObservableCollection< T>允许我现在继续使用ObjectContext,这就是我想要的.

compiler error message: “[dcc32 Error] : can’t access to private symbol {System.Generics.Collections}TList.GetItem”

这是我的代码：

unit Unit2;
interface
uses
  Classes,System.SysUtils,System.Types,REST.Types,System.JSON,Data.Bind.Components,System.RegularExpressions,System.Variants,Generics.Collections;

  type
  TTruc = class
  public
    libelle : string;
    constructor Create(pLibelle : string);
  end;

  TListeDeTrucs = class(TObjectList<TTruc>)
  private
    function GetItem(Index: Integer): TTruc;
    procedure SetItem(Index: Integer; const Value: TTruc);
  public
    function Add(AObject: TTruc): Integer;
    procedure Insert(Index: Integer; AObject: TTruc);
    procedure Delete(Index: Integer);
    property Items[Index: Integer]: TTruc read GetItem write SetItem; default;
  end;

implementation

{ TTruc }

constructor TTruc.Create(pLibelle: string);
begin
  libelle := pLibelle;
end;

{ TListeDeTrucs }

function TListeDeTrucs.Add(AObject: TTruc): Integer;
begin
  result := inherited Add(AObject);
end;

procedure TListeDeTrucs.Insert(Index: Integer; AObject: TTruc);
begin
  inherited Insert(index,AObject);
end;

procedure TListeDeTrucs.Delete(Index: Integer);
begin
  inherited delete(index);
end;

function TListeDeTrucs.GetItem(Index: Integer): TTruc;
begin
  result := inherited GetItem(index);
end;

procedure TListeDeTrucs.SetItem(Index: Integer; const Value: TTruc);
begin
  inherited setItem(index,value);
end;
end.

测试代码是：

procedure TForm1.Button1Click(Sender: TObject);
var
  l : TListeDeTrucs;
  i : integer;
  Obj : TTruc;
begin
  l := TListeDeTrucs.Create(true);
  l.Add(TTruc.Create('one'));
  l.Add(TTruc.Create('two'));
  Obj := TTruc.Create('three');
  l.Add(Obj);
  for i := 0 to l.count - 1 do
  begin
    showMessage(l[i].libelle);
  end;
  L.Delete(0);
  l.extract(Obj);
  l.Free;
end;

我怎样才能使它工作？

这编译：

function TListeDeTrucs.GetItem(Index: Integer): TTruc;
begin
  Result := inherited Items[Index];
end;

procedure TListeDeTrucs.SetItem(Index: Integer; const Value: TTruc);
begin
  inherited Items[Index] := Value;
end;

在这种情况下,您的类有点无意义,因为您的类中的所有方法都不会改变基类的行为.但是,你真正的班级做得更多.