如何从外部方法修改方法作用域变量？C#实现方案探讨

假设我们有一个类，其中某方法创建一个缓冲区，等待其填满后执行逻辑，缓冲区由另一线程通过类的公共方法写入（此处仅以缓冲区为例，实际可推广至int等变量，核心需求是仅从外部修改变量）。

第一种实现（逻辑简洁但不可行） #

这种实现将缓冲区设为方法作用域变量，生命周期可自动管理，但外部方法无法访问它：

public class FunctionScope
{   
    // 这个类里只有该方法关心缓冲区
    private void GetInput()
    {
        // 我们要修改的目标对象，假设是某种缓冲区
        SomeWeirdBufferThing targetBuffer = new();
        
        // 等待缓冲区被填满
        while (!targetBuffer.IsFull)
        {
            // 空操作
        }
        
        // 处理缓冲区数据
        targetBuffer.DoSomethingWithTheData();
        
        // 此处targetBuffer超出作用域，自动被清理，无需手动操作
    }
    
    // 另一线程在GetInput()等待时调用该方法
    public void WriteToBuffer(string valueToWrite)
    {
        // 无法访问targetBuffer，因为它属于GetInput()的作用域
        targetBuffer.Write(valueToWrite);
    }
}

第二种实现（可运行但有缺陷） #

将缓冲区设为类成员，解决了访问问题，但存在两个缺点：一是需要手动清理变量，二是无法阻止类内其他代码修改该缓冲区：

public class ClassScope
{
    // 要修改的目标对象
    private readonly SomeWeirdBufferThing targetBuffer = new();

    // 这个类里只有该方法关心缓冲区
    private void GetInput()
    {       
        // 必须先清空缓冲区，防止类内其他地方修改过它（我们绝不希望这种情况，但无法阻止）
        targetBuffer.Clear();
    
        // 等待缓冲区被填满
        while (!targetBuffer.IsFull)
        {
            // 空操作
        }
        
        // 处理缓冲区数据
        targetBuffer.DoSomethingWithTheData();
        
        // targetBuffer不会随GetInput()结束而销毁，必须手动清理
        targetBuffer.Clear();
    }
    
    // 另一线程在GetInput()等待时调用该方法
    public void WriteToBuffer(string valueToWrite)
    {
        // 可以正常访问缓冲区
        this.targetBuffer.Write(valueToWrite);
    }
}

疑问 #

1. 能否让第一种方案可行？
2. 若不能，如何严格限制第二种方案中变量的访问？
   要求解决方案以避免程序员出错为核心，语言无关或C#特定方案均可。

关于第一种方案的可行性 #

第一种方案无法直接修复：方法作用域的变量在方法外部完全不可见，跨线程的WriteToBuffer方法根本无法获取到targetBuffer的引用。即便通过某种手段传递引用，也会打破原有的作用域隔离逻辑，引入额外复杂度，违背最初的简洁性初衷。

针对第二种方案的访问限制方案 #

核心目标是：让缓冲区仅能被GetInput()初始化/等待/处理，仅能被WriteToBuffer()写入，同时阻止类内其他代码修改它，尽可能减少手动清理负担。

方案1：C#特定——嵌套私有类封装 #

把缓冲区和所有操作逻辑封装到嵌套私有类中，只暴露必要的限定接口，从编译层面阻止类内其他方法直接访问缓冲区：

public class RestrictedBufferClass
{
    // 嵌套私有类，完全封装缓冲区的状态和操作
    private class BufferHandler
    {
        private readonly SomeWeirdBufferThing _buffer = new();
        private bool _isActive = false;

        // 仅允许GetInput触发初始化
        public void StartWaiting()
        {
            _buffer.Clear();
            _isActive = true;
        }

        // 仅允许WriteToBuffer在激活状态下写入
        public void Write(string value)
        {
            if (!_isActive)
                throw new InvalidOperationException("缓冲区未处于可写入状态");
            _buffer.Write(value);
        }

        // 等待并处理数据，结束后自动清理并标记非激活
        public void WaitAndProcess()
        {
            while (!_buffer.IsFull) { }
            _buffer.DoSomethingWithTheData();
            _isActive = false;
            _buffer.Clear();
        }
    }

    private readonly BufferHandler _handler = new();

    private void GetInput()
    {
        _handler.StartWaiting();
        _handler.WaitAndProcess();
    }

    public void WriteToBuffer(string valueToWrite)
    {
        _handler.Write(valueToWrite);
    }

    // 类内其他方法无法直接接触原始缓冲区，只能通过_handler的限定接口操作
}

该方案将所有缓冲区操作的权限锁死在嵌套类内部，外部类的其他方法没有任何途径误修改缓冲区，同时自动处理清理逻辑。

方案2：语言无关——接口隔离原则 #

定义两个权限拆分的接口，让缓冲区类实现接口，外部类分别持有对应接口的引用，从设计层面限制操作范围：

// 仅暴露写入权限的接口
public interface IBufferWriter
{
    void Write(string value);
}

// 仅暴露内部处理权限的接口（internal限制外部访问）
internal interface IBufferProcessor
{
    void StartProcessing();
    void WaitAndProcess();
}

// 缓冲区实现类，同时实现两个接口
public class SomeWeirdBufferThing : IBufferWriter, IBufferProcessor
{
    private bool _isActive = false;

    public void Write(string value)
    {
        if (!_isActive)
            throw new InvalidOperationException("缓冲区未激活");
        // 实际写入逻辑
    }

    void IBufferProcessor.StartProcessing()
    {
        Clear();
        _isActive = true;
    }

    void IBufferProcessor.WaitAndProcess()
    {
        while (!IsFull) { }
        DoSomethingWithTheData();
        _isActive = false;
        Clear();
    }

    // 其他私有/内部方法
    private void Clear() { /*...*/ }
    public bool IsFull { get; private set; }
    private void DoSomethingWithTheData() { /*...*/ }
}

// 外部使用类
public class IsolatedBufferClass
{
    // 仅持有写入接口，WriteToBuffer只能调用Write方法
    private readonly IBufferWriter _writer;
    // 仅持有处理接口，GetInput只能调用处理相关方法
    private readonly IBufferProcessor _processor;

    public IsolatedBufferClass()
    {
        var buffer = new SomeWeirdBufferThing();
        _writer = buffer;
        _processor = buffer;
    }

    private void GetInput()
    {
        _processor.StartProcessing();
        _processor.WaitAndProcess();
    }

    public void WriteToBuffer(string valueToWrite)
    {
        _writer.Write(valueToWrite);
    }

    // 类内其他方法无法访问缓冲区的额外方法，只能通过限定接口操作
}

这种方案通过接口拆分权限，即使类内其他方法拿到_writer或_processor，也只能执行对应权限的操作，从根源上避免误修改。

方案3：C#特定——异步模型替代忙等 #

如果可以调整线程模型，用异步等待替代忙等，既能保留局部变量的自动生命周期，又能让写入方法临时访问缓冲区：

public class AsyncLocalBufferClass
{
    private SomeWeirdBufferThing _currentBuffer;
    private readonly TaskCompletionSource<bool> _tcs = new();

    private async Task GetInputAsync()
    {
        using var targetBuffer = new SomeWeirdBufferThing(); // using自动清理
        _currentBuffer = targetBuffer;
        
        // 等待缓冲区填满的信号，替代忙等
        await _tcs.Task;
        
        targetBuffer.DoSomethingWithTheData();
        _currentBuffer = null;
        _tcs.TrySetResult(false); // 重置信号源
    }

    public void WriteToBuffer(string valueToWrite)
    {
        _currentBuffer?.Write(valueToWrite);
        if (_currentBuffer?.IsFull ?? false)
        {
            _tcs.TrySetResult(true); // 触发处理逻辑
        }
    }
}

该方案通过异步模型减少了缓冲区作为类成员的暴露时间，using关键字自动处理清理，同时_currentBuffer仅在GetInputAsync()执行期间有效，大幅降低误修改的概率。

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