开发者

C#使用Lazy实现延迟加载的方法示例

开发者 https://www.devze.com 2024-08-12 15:08 出处：网络 作者： 白话Learning
目录前言1、Lazy 的工作原理2、创建 Lazy 实例3、 使用 Lazy4、示例5、Lazy< T> 实现延迟加载实现方式示例：延迟加载图片示例：延迟加载视频示例：延迟加载音频6、如何在多线程环境中测试 Lazy<T>&
相关专题：C# LazyC# Lazy实现延迟加载C# Lazy延迟加载C#延迟加载
目录
  • 前言
  • 1、Lazy 的工作原理
  • 2、创建 Lazy 实例
  • 3、 使用 Lazy
  • 4、示例
  • 5、Lazy< T> 实现延迟加载
    • 实现方式
    • 示例：延迟加载图片
    • 示例：延迟加载视频
    • 示例：延迟加载音频
  • 6、如何在多线程环境中测试 Lazy<T> 的线程安全性？
    • 7、Lazy 加载在性能和用户体验方面的作用
      • 8、安全性和效率考虑
        • 总结

          前言

          在C#中，Lazy< T> 类是一个非常有用的工具，它可以用于延迟加载值，尤其是在创建对象时可能很昂贵，或者你想要延迟初始化直到真正需要该值的情况下。在本文中，我们将详细介绍 Lazy< T> 的实现机制和用法，并提供一些示例来展示它的优势。

          1、Lazy 的工作原理

          Lazy< T> 类是.NET框架中的一个并发类，它允许你延迟初始化一个对象，直到这个对象被第一次使用时才进行。这意味着，如果多个线程需要访问同一个延迟初始化的对象，Lazy< T> 能够保证只有一个线程会执行初始化代码，从而避免不必要的资源消耗。

          Lazy< T> 采用懒汉式初始化模式，在.NET Framework 4.0及之前的版本中，它是线程安全的，采用内部互斥锁（Mutex）来确保线程安全。但在.NET 4.0之后，Lazy< T> 采用了新的LazyInitializationMode.None模式，允许非线程安全且更高效的初始化，这时需要开发者自己确保初始化的线程安全。

          2、创建 Lazy 实例

          要创建一个 Lazy< T> 实例，你可以使用以下构造函数：

          Lazy<T>() : this(LazyThreadSafetyMode.ExecutionAndPublication)
Lazy<T>(Func<T> valueFactory) : this(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication)
Lazy<T>(LazyThreadSafetyMode mode)
Lazy<T>(Func<T> valueFactory, LazyThreadSafetyMode mode)

          LazyThreadSafetyMode 是一个枚举，用于指定初始化时的线程安全模式。有四种模式：

          • LazyThreadSafetyMode.None：允许非线程安全初始化。
          • LazyThreadSafetyMode.ExecutionAndPublication：执行初始化时是线程安全的，且Publish方法也是线程安全的。
          • LazyThreadSafetyMode.PublicationOnly：仅Publish方法是线程安全的。
          • LazyThreadSafetyMode.UnprotectedPublication：既不是执行时也不是发布时线程安全。

          3、 使用 Lazy

          一旦你创建了一个 Lazy< T> 实例，你可以通过其 Value 属性来获取其内部值的引用，该属性是android只读的，并会在第一次访问时触发值的初始化。

          4、示例

          下面我们通过一个示例来演示如何使用 Lazy 进行延迟加载。

          using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static void Main(string[] args)
    {
        // 使用 Lazy<T> 创建一个延迟加载的对象
        Lazy<ExpensiveObject> lazyExpensiveObject = new Lazy<ExpensiveObject>(() => new ExpensiveObject(), LazyThreadSafetyMode.ExecutionAndPublication);

        // 获取对象值，这将触发延迟加载
        ExpensiveObject expensiveObject = lazyExpensiveObject.Value;

        // 使用 expensiveObject 做些事情
        Console.WriteLine(expensiveObject.SomeProperty);

        Console.ReadKey();
    }
}

class ExpensiveObject
{
    public ExpensiveObject()
    {
        // 模拟一个初始化代价很昂贵的操作
        Console.WriteLine("Expensive object initialized.");
  编程客栈  }

    public string SomeProperty { get; set; }
}

          在这个示例中，我们创建了一个 ExpensiveObject 的 Lazy 实例。这个 ExpensiveObject 的构造函数是一个耗时的操作。当我们第一次访问 lazyExpensiveObject.Value 时，构造函数会被调用，并且 ExpensiveObject 实例会被创建。注意，之后对这个属性的所有访问都会直接返回已经创建的实例，而不会再次调用构造函数。

          注意事项

          1. 如果你需要在多个线程中共享延迟加载的对象，请确保你正确同步对这个对象的访问。
          2. 如果你的初始化操作是线程安全的，你可以使用 LazyThreadSafetyMode.ExecutionAndPublication，这样可以保证初始化过程和发布过程都是线程安全的。
          3. 如果你的初始化操作不依赖于外部状态，并且你确信它可以在多个线程中安全地并行执行，你可以使用 LazyThreadSafetyMode.None，这将避免线程锁定，并可能提高性能。

          5、Lazy< T> 实现延迟加载

          Lazy< T> 利用了 C# 的属性器和反射机制来实现延迟加载。当访问 Lazy< T> 的 Value 属性时，如果内部值尚未初始化，则初始化它。这个过程称为“lazy initialization”。Lazy< T> 提供了几种不同的线程安全模式，以适应不同的场景。

          实现方式

          下面是使用 Lazy 进行延迟加载资源的基本步骤：

          • 创建一个 Lazy 实例，并通过提供一个函数来指定要延迟加载的资源。
          • 在需要的时候，通过访问 Lazy 的 Value 属性来触发资源的加载。

          示例：延迟加载图片

          假设我们有以下一个类，它使用 Lazy 来延迟加载图片：

          using System;
using System.Drawing;
using System.Threading.Tasks;

public class ImageLoader
{
    private Lazy<Bitmap> _lazyImage = new Lazy<Bitmap>(() => LoadImageAsync("path/to/image.jpg"), LazyThreadSafetyMode.ExecutionAndPublication);

    public Bitmap GetImage()
    {
        return _lazyImage.Value;
    }

 Pquup   private async Task<Bitmap> LoadImageAsync(string imagePath)
    {
        using (var stream = new FileStream(imagePath, FileMode.Open))
        {
            return (Bitmap)Image.FromStream(stream);
        }
    }
}

          在这个例子中，ImageLoader 类有一个 Lazy 实例，它通过异步方法 LoadImageAsync 加载图片。当调用 GetImage 方法时，Lazy 会触发 LoadImageAsync 的执行，并返回图片。

          示例：延迟加载视频

          视频加载通常涉及到更复杂的操作，下面是一个简化的例子：

          using System;
using System.IO;
using System.Threading.Tasks;

public class VideoLoader
{
    private Lazy<FileStream> _lazyVideoStream = new Lazy<FileStream>(() => LoadVideoAsync("path/to/video.mp4"), LazyThreadSafetyMode.ExecutionAndPublication);

    public FileStream GetVideoStream()
    {
        return _lazyVideoStream.Value;
    }

    private async Task<FileStream> LoadVideoAsync(string videoPath)
    {
        return new FileStream(videoPath, FileMode.Open);
    }
}

          在这个例子中，VideoLoader 类使用 Lazy 来延迟加载视频文件流。当 GetVideoStream 被调用时，视频文件流会被创建并返回。

          示例：延迟加载音频

          音频文件的加载可以类似于视频文件的加载：

          using System;
using System.IO;
using System.Threading.Tasks;

public class AudioLoader
{
    private Lazy<FileStream> _lazyAudIOStream = new Lazy<FileStream>(() => LoadAudioAsync("path/to/audio.wav"), LazyThreadSafetyMode.ExecutionAndPublication);

    public FileStream GetAudioStream()
    {
        return _lazyAudioStream.Value;
    }

    private async Task<FileStream> LoadAudioAsync(string audioPath)
    {
        return new FileStream(audioPath, FileMode.Open);
    }
}

          在这个例子中，AudioLoader 类使用 Lazy 来延迟加载音频文件流。当 GetAudioStream 被调用时，音频文件流会被创建并返回。

          6、如何在多线程环境中测试 Lazy<T> 的线程安全性？

          在多线程环境中测试 Lazy< T> 的线程安全性通常涉及到模拟 concurrent Access（并发访问）来确保 Lazy< T> 在不同线程之间正确地处理初始化和访问。这里有几种方法可以用来测试 Lazy< T> 的线程安全性：

          1. 使用 Lazy< T> 的同步模式： 在 Lazy 的构造函数中指定 LazyThreadSafetyMode.ExecutionAndPublication 或 LazyThreadSafetyMode.PublicationOnly，这样 Lazy< T> 会确保在多个线程中的执行和发布都是线程安全的。
          2. 手动同步： 如果你使用的是 LazyThreadSafetyMode.None，你需要手动同步对 Lazy< T> 属性的访问。这可以通过 lock 语句或 Monitor 类来实现。
          3. 使用 Task 和 Parallel 类： 使用 Task 并行库来创建多个任务，每个任务访问 Lazy 的 Value 属性。确保在所有任务都完成时，Lazy< T> 的初始化只执行一次。
          4. 使用 Mutex 或 Semaphore： 使用 Mutex 或 Semaphore 来控制对 Lazy< T> 初始化代码的访问，确保初始化是独占进行的。
          5. 单元测试： 编写单元测试来模拟并发访问。可以使用测试框架（如 NUnit 或 xUnit）来创建多个测试线程，并确保它们正确地访问 Lazy< T>。
          6. 代码分析工具： 使用像 NDepend 或 SonarQube 这样的代码分析工具来检测可能的线程安全问题。

            下面是一个简单的示例，展示了如何在单元测试中使用 Lazy< T> 和 Task 来测试线程安全性：

          using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

public class LazyTestClass
{
    private Lazy<List<int>> _lazyList = new Lazy<List<int>>(() => new List<int>(), LazyThreadSafetyMode.ExecutionAndPublication);

    public List<int> GetList()
    {
        return _lazyList.Value;
    }
}

public class Program
{
    public static void Main()
    {
        LazyTestClass testClass = new LazyTestClass();

        // 创建多个任务来并发访问 Lazy<T>
        var tasks = Enumerable.Range(1, 10).Select(i => Task.Run(() => testClass.GetList()));

        // 等待所有任务完成
        Task.WaitAll(tasks.ToArray());
    }
}

// 单元测试
public class LazyTestClassTests
{
    [Fact]
    public void TestLazyThreadSafety()
    {
        LazyTestClass testClass = new LazyTestClass();

        // 创建多个测试线程
        var tasks = Enumerable.Range(1, 10).Select(i => Task.Run(() => testClass.GetList()));

        // 等待所有任务完成
        Task.WaitAll(tasks.ToArray());

        // 断言列表的实例只有一个
        Assert.Single(tasks.Select(t => t.Result));
    }
}

          在这个示例中，我们创建了一个 LazyTestClass，它有一个 Lazy<List> 成员。我们在主函数中创建了多个 Task 来并发地访问 GetList 方法，该方法返回 Lazy<List> 的值。在单元测试中，我们使用 Fact 属性来标记一个测试方法，并使用 Assert.Single 来断言只有一个 List 实例被创建。

          7、Lazy 加载在性能和用户体验方面的作用

          Lazy 加载技术可以显著提高程序的性能和用户体验。以下是它在不同方面的一些潜在作用：

          • 性能提升：通过延迟加载昂贵的资源，程序可以在不需要这些资源时避免不必要的开销。这意味着资源只有在真正需要时才会被加载，从而减少内存和CPU的使用。
          • 响应性增强：在用户界面（UI）中使用 Lazy 加载可以避免在初始加载时延迟UI的响应。这对于创建快速启动的应用程序至关重要。
          • 资源优化：对于大型资源，如图片、视频和音频文件，Lazy 加载确保只有在用户请求时才加载它们，这样可以减少应用程序的整体大小和加载时间。
          • 多线程支持：Lazy 加载在多线程环境中自动同步，这意味着不必担心在多个线程中共享和初始化资源的问题。

          8、安全性和效率考虑

          尽管 Lazy 加载提供了许多好处，但在使用时也需要考虑安全和效率：

          • 线程安全：Lazy 加载默认是线程安全的，但在自定义 Lazy 实现或使用 LazyThreadSafetyMode.None 时，需要确保线程安全。
          • 资源泄漏：如果异步加载的资源没有正确管理（例如，没有释放或关闭流），可能会导致资源泄漏。
          • 性能开销：即使是 Lazy 加载，如果初始化过程很昂贵，或者在短时间内多次调用 Value 属性，这可能会导致性能问题。
          • 过度依赖：过度使用 Lazy 加载可能会导致代码难以理解和维护，特别是当依赖关系变得复杂时。

          总结

          Lazy< T> 是C#中一个非常有用的并发特编程客栈性，它允许开发者延迟初始化对象，直到这些对象真正被需要。通过正确使用 Lazy< T>，你可以优化应用程序的性能，减少资源消耗，并提高应用程序的响应性。

          在使用 Lazy< T> 时，你需要仔细考虑线程安全问题，并选择合适的 LazyThreadSafetyMode。此外，你还需要确保在多个线程中共享延迟加载的对象时，你的初始化代码和发布代码都是线程安全的。

          以上就是C#使用Lazy实现延迟加载的方法示例的详细内容，更多关于C# Lhttp://www.devze.comazy延迟加载的资料请关注编程客栈(www.devze.com)其它相关文章！

          0

          上一篇:

          :下一篇

          更多 开发 相关资讯：

          精彩评论

          暂无评论...
          登录 注册
          Qedev.com
          验证码 换一张
          取 消

            关注公众号

            热门标签

            图文推荐

            mysql字符集引起的java.sql.SQLException:Incorrect string value:问题

            mysql字符集引起的java.sql.SQLException:Incorrect string value:问题
            解决Feign异步调用丢失上下文问题

            解决Feign异步调用丢失上下文问题
            一文教会你使用Python来下一场雪

            一文教会你使用Python来下一场雪
            利用python调整Excel行高和列宽的操作示例

            利用python调整Excel行高和列宽的操作示例
            Python字符串检索方式

            Python字符串检索方式
            Android中常见内存泄漏的场景和解决方案详解

            Android中常见内存泄漏的场景和解决方案详解
            python解析网页上的json数据并保存到EXCEL

            python解析网页上的json数据并保存到EXCEL
            使用wxPython创建一个文件夹结构生成器

            使用wxPython创建一个文件夹结构生成器

            开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

            法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

            Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9