如何在不引起循环引用的情况下使用LazyLoading和WCF？

Question

我正在使用Model类上的DataAnnotation属性进行验证，并且Model类用于在应用程序的Client和Server端进行验证。

我的问题是，如何延迟加载我的模型的属性，而不会导致循环引用

所涉及的库我想不出有：

• WCF服务库
• 客户端数据访问图书馆
• 模型库

，因为这些模型天秤座ry在客户端和服务器端用于数据验证，我无法从模型库中引用DataAccess库。因此，我如何设置延迟加载？

例如，我有一个ConsumerModel，它具有PhoneNumbers属性，应该延迟加载。如何在不引用客户端DAL的情况下从ConsumerModel中加载PhoneNumberModels？

客户端DAL：

using MyModels; 

public class ConsumerDataAccess 
{ 
    public ConsumerModel GetConsumerById(int id) 
    { 
     ConsumerDTO dto = WCFService.GetConsumer(id); 
     return new ConsumerModel(dto); 
    } 
} 

ConsumerModel：

public class ConsumerModel 
{ 
    public ObservableCollection<PhoneNumberModel> _phoneNumbers; 

    public ObservableCollection<PhoneNumberModel> PhoneNumbers 
    { 
     get 
     { 
      if (_phoneNumbers == null) 
      { 
       // Can't reference DataAccess Library since that would cause a Circular Reference 
      } 
     } 
    } 
} 

什么是一些替代办法，我可以使这个架构的工作？

我倾向于使用模型进行验证，并使用客户端和服务器端的模型进行验证。我还希望继续使用DataAnnotation进行验证。

编辑

这是我根据劳伦斯·温汉姆的答案最终解决方案，如果有人有兴趣。我结束了使用委托而不是事件。

DAL：

public class ConsumerDataAccess 
{ 
    public ConsumerModel GetConsumerById(int id) 
    { 
     ConsumerDTO dto = WCFService.GetConsumer(id); 
     ConsumerModel rtnValue = new ConsumerModel(dto); 
     ConsumerModel.LazyLoadData = LazyLoadConsumerData; 
     return rtnValue; 
    } 
} 

private object LazyLoadConsumerData(string key, object args) 
{ 
    switch (key) 
    { 
     case "Phones": 
      return PhoneDataAccess.GetByConsumerId((int)args); 
     default: 
      return null; 
    } 
} 

模型库：

public class ConsumerModel 
{ 
    public delegate object LazyLoadDataDelegate(string id, object args); 
    public LazyLoadDataDelegate LazyLoadData { get; set; } 

    public ObservableCollection<PhoneNumberModel> _phoneNumbers; 

    public ObservableCollection<PhoneNumberModel> PhoneNumbers 
    { 
     get 
     { 
      if (_phoneNumbers == null && LazyLoadData != null) 
      { 
       _phoneNumbers = (ObservableCollection<PhoneNumberModel>) 
         LazyLoadData("Phones", ConsumerId); 
      } 
      return _phoneNumbers; 
     } 
    } 
} 

Answer 1

一种方式是提高模型中的类属性的get {}一个事件，然后实现在一个延迟加载经理客户端有一个参考您的DAL。 EG：

public class LazyLoadEventArgs: EventArgs 
{ 
    public object Data { get; set; } 

    public string PropertyName { get; set; } 

    public int Key { get; set; } 
} 

然后在您的模型类：

public event EventHandler<LazyLoadEventArgs> LazyLoadData; 

public ObservableCollection<PhoneNumberModel> PhoneNumbers 
{ 
    get 
    { 
     if (_phoneNumbers == null) 
     { 
      LazyLoadEventArgs args = new LazyLoadEventArgs { 
       PropertyName = "PhoneNumbers", 
       Key = this.Id 
      }; 
      LazyLoadData(this, args); 
      if (args.Data != null) 
       this._phoneNumbers = args.Data as ObservableCollection<PhoneNumberModel>; 
     } 
     return _phoneNumbers; 
    } 
} 

为LazyLoadData事件将有来自客户端的DAL获取数据，然后将其存储在的.Data财产的工作处理程序LazyLoadEventArgs。 EG：

private void Model_HandleLazyLoadData(object sender, LazyLoadEventArgs e) 
{ 
    switch (e.PropertyName) 
    { 
     case "PhoneNumbers": 
      e.Data = DAL.LoadPhoneNumbers(e.Key); 
      break; 
     ... 
    } 
} 

Answer 2

不要对WCF使用“延迟加载”。网络通信耗费时间。如果您打算使用PhoneNumbers，则您的服务应该公开将使用电话号码返回Customer的方法。其他方法是使用WCF Data Services，它提供了客户端linq查询，能够通过Expand方法定义急切加载。

您应该将服务呼叫降至最低。

再次阅读您的问题后，我不明白为什么你分享模型之间的服务和客户端。模型是严格的客户端功能。唯一的共享部分应该是DTO。