延迟加载 - 最好的方法是什么？

发布于 2024-07-12 21:45:10 字数 682 浏览 6 评论 0原文

我见过很多延迟加载的例子 - 你的选择是什么？

例如，给定一个模型类：

public class Person
{
    private IList<Child> _children;
    public IList<Child> Children
    {
        get {
            if (_children == null)
                LoadChildren();
            return _children;
        }
    }
}

Person 类不应该知道它的子级是如何加载的……或者应该知道吗？它当然应该控制何时填充属性，或者不？

您是否有一个将 Person 及其子集合耦合在一起的存储库，或者您是否会使用不同的方法，例如使用 lazyload 类 - 即使如此，我也不希望在我的模型架构中出现一个模糊的延迟加载类。

如果首先请求一个 Person，然后请求它的 Children（即在本例中不是延迟加载）或以某种方式延迟加载，您将如何处理性能。

这一切都归结为个人选择吗？

原文

I have seen numerous examples of lazy loading - what's your choice?

Given a model class for example:

public class Person
{
    private IList<Child> _children;
    public IList<Child> Children
    {
        get {
            if (_children == null)
                LoadChildren();
            return _children;
        }
    }
}

The Person class should not know anything about how it's children are loaded .... or should it? Surely it should control when properties are populated, or not?

Would you have a repository that couples a Person together with its children collection or would you use a different approach, such as using a lazyload class - even then, I don't want a lazyload class blurring in my model architecture.

How would you handle performance if first requesting a Person and then its Children (i.e. not lazy loading in this instance) or somehow lazy loading.

Does all this boil down to personal choice?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

橙幽之幻 2024-07-19 21:45:21

下面是一个使用代理模式实现延迟加载的示例

Person 类将与模型的其余部分一起使用。 Children 被标记为虚拟，因此可以在 PersonProxy 类中覆盖它。

public class Person {
    public int Id;
    public virtual IList<Child> Children { get; set; }
}

PersonRepository 类将与您的其余存储库一起使用。我在此类中包含了获取子级的方法，但如果您愿意，也可以将其放在 ChildRepository 类中。

public class PersonRepository {
    public Person FindById(int id) {
        // Notice we are creating PersonProxy and not Person
        Person person = new PersonProxy();

        // Set person properties based on data from the database

        return person;
    }

    public IList<Child> GetChildrenForPerson(int personId) {
        // Return your list of children from the database
    }
}

与您的存储库一起存在的 PersonProxy 类。它继承自 Person 并将执行延迟加载。您还可以使用布尔值来检查它是否已经加载，而不是检查 Children == null 。

public class PersonProxy : Person {
    private PersonRepository _personRepository = new PersonRepository();

    public override IList<Child> Children {
        get {
            if (base.Children == null)
                base.Children = _personRepository.GetChildrenForPerson(this.Id);

            return base.Children;
        }
        set { base.Children = value; }
    }
}

。

Person person = new PersonRepository().FindById(1);
Console.WriteLine(person.Children.Count);

当然，如果您不想直接调用 PersonRepository，您可以让 PersonProxy 接受 PersonRepository 的接口并通过服务访问它

Here is an example implementing lazy loading using the Proxy pattern

The Person class that would live with the rest of your models. Children is marked as virtual so it can be overridden inside the PersonProxy class.

public class Person {
    public int Id;
    public virtual IList<Child> Children { get; set; }
}

The PersonRepository class that would live with the rest of your repositories. I included the method to get the children in this class but you could have it in a ChildRepository class if you wanted.

public class PersonRepository {
    public Person FindById(int id) {
        // Notice we are creating PersonProxy and not Person
        Person person = new PersonProxy();

        // Set person properties based on data from the database

        return person;
    }

    public IList<Child> GetChildrenForPerson(int personId) {
        // Return your list of children from the database
    }
}

The PersonProxy class that lives with your repositories. This inherits from Person and will do the lazy loading. You could also use a boolean to check if it has already been loaded instead of checking to see if Children == null.

public class PersonProxy : Person {
    private PersonRepository _personRepository = new PersonRepository();

    public override IList<Child> Children {
        get {
            if (base.Children == null)
                base.Children = _personRepository.GetChildrenForPerson(this.Id);

            return base.Children;
        }
        set { base.Children = value; }
    }
}

You could use it like so

Person person = new PersonRepository().FindById(1);
Console.WriteLine(person.Children.Count);

Of course you could have PersonProxy take in an interface to the PersonRepository and access it all through a service if you don't want to call the PersonRepository directly.

回复收藏 0 原文