如何在不导致循环引用的情况下将 LazyLoading 与 WCF 一起使用？

Question

我正在使用 Model 类上的 DataAnnotation 属性进行验证，并且 Model 类用于在应用程序的客户端和服务器端进行验证。

我的问题是，我不知道如何在不引起循环引用的情况下延迟加载模型的属性

涉及的库有：

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

因为模型库在客户端和服务器端都用于数据验证，所以我无法从模型库中引用 DataAccess 库。那么，如何设置延迟加载呢？

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

客户端 DAL：

using MyModels;

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

消费者模型：

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 进行验证。

编辑

如果有人感兴趣，这是我根据 Lawrence Wenham 的回答得出的最终解决方案。我最终使用了委托而不是事件。

达尔：

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。例如：

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 获取数据，然后将其存储在 LazyLoadEventArgs 的 .Data 属性中。例如：

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。