如何禁止方法缓存传入参数？对象池场景下的安全诉求

在使用对象池技术时，会遇到一个棘手的问题：如何避免外部方法缓存传入的池化对象引用，从而引发后续的状态冲突？

以下是具体场景代码：

public class MyClass
{
    private BigObject myBigObject;

    public MyClass()
    {
        myBigObject = BigObjectsPool.Borrow();
        //initialize myBigObject with some data
    }

    public void ActUpon(ClientClass clientClassInstance)
    {
        clientClassInstance.DoStuff(myBigObject);
    }

    public void Terminate() //MyClass object is no longer needed
    {
        BigObjectsPool.Return(myBigObject);
    }
}

public abstract class ClientClass
{
    public abstract void DoStuff(BigObject bigObject);
}

public class PotentiallyDangerousClientClass : ClientClass
{
    private BigObject cachedBigObject;
    private string cachedString;

    public override void DoStuff(BigObject bigObject)
    {
        cachedString = bigObject.SomeString; //this is ok
        cachedBigObject = bigObject; //this will cause problems
    }
}

如代码所示，PotentiallyDangerousClientClass缓存bigObject的行为非常危险：后续MyClass的其他实例可能会借用同一个BigObject并修改其状态，而缓存了引用的客户端对此毫不知情，最终导致数据错误或逻辑异常。

直接隐藏池化对象、仅暴露不可变字段会大幅降低对象池的实用性；而返回对象副本则完全失去了对象池减少内存分配的核心优势。以下是几种兼顾实用性和安全性的解决方案：

1. 用只读代理包装池化对象 #

创建一个只读代理类，仅暴露BigObject的必要只读属性/无状态方法，完全屏蔽底层池化对象的引用。客户端只能拿到代理实例，无法直接持有池化对象：

public class ReadOnlyBigObjectProxy
{
    private readonly BigObject _innerPooledObject;

    public ReadOnlyBigObjectProxy(BigObject inner)
    {
        _innerPooledObject = inner;
    }

    // 仅暴露只读属性
    public string SomeString => _innerPooledObject.SomeString;

    // 如需操作，仅提供不修改内部状态的方法
    public int CalculateSomeValue()
    {
        return _innerPooledObject.SomeString.Length;
    }
}

// 修改ClientClass的方法签名
public abstract class ClientClass
{
    public abstract void DoStuff(ReadOnlyBigObjectProxy bigObjectProxy);
}

2. 给池化对象添加生命周期校验 #

在BigObject中添加状态标记，标记对象是否处于可用状态（已借出/已归还至池）。每次访问对象的属性或方法时校验状态，若对象已归还则直接抛出异常，及时发现非法引用：

public class BigObject
{
    internal bool IsValid { get; set; } = true;
    private string _someString;

    public string SomeString
    {
        get
        {
            ValidateState();
            return _someString;
        }
        set
        {
            ValidateState();
            _someString = value;
        }
    }

    private void ValidateState()
    {
        if (!IsValid)
            throw new InvalidOperationException("该对象已归还至对象池，不可再使用");
    }
}

// 同步修改对象池的借出/归还逻辑
public static class BigObjectsPool
{
    public static BigObject Borrow()
    {
        var obj = // 从池中获取或创建新实例
        obj.IsValid = true;
        // 重置对象状态
        return obj;
    }

    public static void Return(BigObject obj)
    {
        obj.IsValid = false;
        // 清理对象状态，放回池
    }
}

即使客户端缓存了引用，后续访问时也会触发异常，避免静默的逻辑错误。

3. 代码约定与静态检查（团队内部场景） #

如果是团队内部使用对象池，可以通过明确的代码规范禁止缓存池化对象引用，配合静态代码分析工具（如Roslyn分析器）自动检测是否存在将池化对象赋值给类成员变量的行为，再结合代码审查确保规范落地。

总结 #

没有完美的通用方案，需根据业务场景选择：

• 若需严格隔离，优先选择只读代理方案；
• 若需快速排查问题，状态校验方案更合适；
• 团队内部可控场景下，代码约定+静态检查的成本最低。

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