C#如何复用方法1填充的List至方法2且无需重复调用方法1

根据你的场景，有几种不同的实现方式，选最适合你项目的即可：

1. 类成员变量缓存（同一类内复用） #

把获取到的List作为类的私有字段，方法1初始化后，方法2直接访问这个字段，无需重复调用API。

public class DataProcessor
{
    // 存储缓存的List
    private List<YourDataType> _apiDataList;

    // 方法1：从API获取数据并缓存到成员变量
    public void FetchDataFromApi()
    {
        // 替换成你的API调用逻辑
        _apiDataList = YourApiClient.GetListData();
    }

    // 方法2：直接复用已缓存的List
    public void ProcessData()
    {
        // 可选：防止未初始化导致空引用，可在这里主动调用一次获取方法
        if (_apiDataList == null)
        {
            FetchDataFromApi();
        }

        // 处理逻辑示例
        foreach (var item in _apiDataList)
        {
            Console.WriteLine(item.ToString());
        }
    }
}

2. 返回值传递（临时复用） #

让方法1返回获取到的List，调用方先拿到这个List，再传给方法2使用，适合只需要一次性复用的场景。

public class DataProcessor
{
    // 方法1：返回从API获取的List
    public List<YourDataType> FetchDataFromApi()
    {
        return YourApiClient.GetListData();
    }

    // 方法2：接收外部传入的List进行处理
    public void ProcessData(List<YourDataType> dataList)
    {
        foreach (var item in dataList)
        {
            // 你的处理逻辑
        }
    }
}

// 调用方式
var processor = new DataProcessor();
var dataList = processor.FetchDataFromApi();
processor.ProcessData(dataList);
// 后续还能继续用dataList做其他操作

3. 静态全局缓存（跨类/全局复用） #

如果需要在整个应用中复用这份数据，可使用静态类存储缓存，配合双重检查锁保证线程安全。

public static class GlobalDataCache
{
    private static List<YourDataType> _cachedList;
    private static readonly object _lockObj = new object();

    // 获取缓存数据，仅在首次调用时请求API
    public static List<YourDataType> GetCachedData()
    {
        if (_cachedList == null)
        {
            lock (_lockObj)
            {
                if (_cachedList == null)
                {
                    _cachedList = YourApiClient.GetListData();
                }
            }
        }
        return _cachedList;
    }
}

// 方法1和方法2的使用示例
public class DataProcessor
{
    public void Method1()
    {
        var data = GlobalDataCache.GetCachedData();
        // Method1的处理逻辑
    }

    public void Method2()
    {
        var data = GlobalDataCache.GetCachedData(); // 直接用缓存，不会重复请求API
        // Method2的处理逻辑
    }
}

4. 带过期时间的缓存（数据需定期更新） #

如果数据会定期变化，可使用MemoryCache设置缓存过期时间，自动刷新数据。

using System.Runtime.Caching;

public class DataProcessor
{
    private readonly ObjectCache _cache = MemoryCache.Default;
    private const string CacheKey = "ApiDataListKey";

    public List<YourDataType> FetchDataFromApi()
    {
        var cachedData = _cache.Get(CacheKey) as List<YourDataType>;
        
        if (cachedData == null)
        {
            cachedData = YourApiClient.GetListData();
            // 设置1小时后过期，可根据需求调整
            var cachePolicy = new CacheItemPolicy 
            { 
                AbsoluteExpiration = DateTimeOffset.Now.AddHours(1) 
            };
            _cache.Set(CacheKey, cachedData, cachePolicy);
        }

        return cachedData;
    }

    public void Method2()
    {
        var data = FetchDataFromApi(); // 缓存有效期内不会重复请求API
        // Method2的处理逻辑
    }
}

选择建议 #

• 仅在同一个类的方法间复用：用类成员变量缓存
• 临时一次性复用：用返回值传递
• 跨多个类、整个应用复用：用静态全局缓存
• 数据需要定期更新：用带过期时间的MemoryCache

内容的提问来源于stack exchange，提问作者chewwalker