如何在C#中复用PowerShell实例以优化多脚本执行性能

场景1：单线程/单异步上下文（无并发调用）

这种场景下直接复用单个PowerShell实例即可，实现最简单高效：

public class myclass : IDisposable
{
    private readonly DataRulesPSScripts _psScriptRunner;
    private const string KeyScript = "你的Key脚本内容";
    private const string ExtraColumnsScript = "你的ExtraColumns脚本内容";

    public myclass()
    {
        // 初始化一次，整个类生命周期内复用
        _psScriptRunner = new DataRulesPSScripts();
    }

    internal async Task<(string, string)> GenerateKeys(Dictionary<string, EntityProperty> arg)
    {
        var result = await GenerateValuesFromScript(arg, KeyScript);
        return (result.First().ToString(), result.Last().ToString());
    }

    internal async Task<List<object>> GenerateColumns(Dictionary<string, EntityProperty> arg)
    {
        var result = await GenerateValuesFromScript(arg, ExtraColumnsScript);
        return result.ToList();
    }

    private async Task<IEnumerable<object>> GenerateValuesFromScript(Dictionary<string, EntityProperty> arg, string pwScript)
    {
        var pars = new Dictionary<string, object> { ["_"] = arg };
        var scriptBlock = await _psScriptRunner.CreateScriptBlock(pwScript);
        return _psScriptRunner.RunScriptBlock(scriptBlock, pars).ToList();
    }

    // 实现IDisposable，确保PowerShell资源被正确释放
    public void Dispose()
    {
        _psScriptRunner.Dispose();
        GC.SuppressFinalize(this);
    }

    private class DataRulesPSScripts : IDisposable
    {
        private readonly PowerShell _reusablePs;

        public DataRulesPSScripts()
        {
            _reusablePs = PowerShell.Create();
        }

        public IEnumerable<object> RunScriptBlock(ScriptBlock scriptBlock, Dictionary<string, object> scriptParameters)
        {
            // 每次运行前清理命令队列，避免残留之前的脚本上下文
            _reusablePs.Commands.Clear();
            var vars = scriptParameters.Select(p => new PSVariable(p.Key, p.Value)).ToList();
            return scriptBlock.InvokeWithContext(null, vars);
        }

        public async Task<ScriptBlock> CreateScriptBlock(string pSScript)
        {
            // 用临时PowerShell实例生成ScriptBlock，避免污染复用的实例
            using var tempPs = PowerShell.Create();
            tempPs.AddScript(pSScript);
            var results = await tempPs.InvokeAsync();
            return results[0].BaseObject as ScriptBlock;
        }

        // 释放复用的PowerShell实例
        public void Dispose()
        {
            _reusablePs.Dispose();
            GC.SuppressFinalize(this);
        }
    }
}

关键修改点：

• 在myclass构造函数中初始化一次DataRulesPSScripts，不再每次调用都新建实例
• 让两个类都实现IDisposable接口，确保PowerShell资源被正确释放，避免内存泄漏
• 拆分脚本块生成和运行的上下文：用临时实例生成脚本块，复用实例运行脚本，避免命令队列累积导致的错误

场景2：多线程并发调用

如果你的myclass会被多个线程同时调用，直接复用单个PowerShell实例会有线程安全问题（PowerShell本身不是线程安全的）。这种情况下可以用实例池来平衡性能和线程安全：

public class myclass : IDisposable
{
    private readonly DataRulesPSScripts _psScriptRunner;
    private const string KeyScript = "你的Key脚本内容";
    private const string ExtraColumnsScript = "你的ExtraColumns脚本内容";

    public myclass()
    {
        _psScriptRunner = new DataRulesPSScripts();
    }

    // GenerateKeys、GenerateColumns、GenerateValuesFromScript方法和场景1完全一致，此处省略

    public void Dispose()
    {
        _psScriptRunner.Dispose();
        GC.SuppressFinalize(this);
    }

    private class DataRulesPSScripts : IDisposable
    {
        private readonly PowerShellPool _psPool = new PowerShellPool();

        public IEnumerable<object> RunScriptBlock(ScriptBlock scriptBlock, Dictionary<string, object> scriptParameters)
        {
            var ps = _psPool.Get();
            try
            {
                var vars = scriptParameters.Select(p => new PSVariable(p.Key, p.Value)).ToList();
                return scriptBlock.InvokeWithContext(null, vars);
            }
            finally
            {
                // 用完放回池子里，清理命令队列
                _psPool.Return(ps);
            }
        }

        // CreateScriptBlock方法和场景1一致，用临时实例生成脚本块

        public void Dispose()
        {
            _psPool.DisposeAll();
            GC.SuppressFinalize(this);
        }
    }

    // 简单的PowerShell实例池实现
    private class PowerShellPool
    {
        private readonly Queue<PowerShell> _pool = new Queue<PowerShell>();
        private readonly object _lockObj = new object();

        public PowerShell Get()
        {
            lock (_lockObj)
            {
                if (_pool.Count > 0)
                    return _pool.Dequeue();
                // 池里无可用实例时新建
                return PowerShell.Create();
            }
        }

        public void Return(PowerShell ps)
        {
            lock (_lockObj)
            {
                ps.Commands.Clear();
                _pool.Enqueue(ps);
            }
        }

        public void DisposeAll()
        {
            lock (_lockObj)
            {
                while (_pool.Count > 0)
                    _pool.Dequeue().Dispose();
            }
        }
    }
}

这个方案通过池化PowerShell实例，既避免了频繁创建销毁的开销，又保证了多线程环境下的运行安全。

额外注意事项 #

• 无论哪种方案，都必须实现IDisposable接口，否则PowerShell实例可能会泄漏系统资源
• 如果你的脚本执行时间很长或者占用大量资源，可以根据实际情况调整实例池的最大容量
• 测试时要注意验证脚本上下文的隔离性，确保不同调用之间不会互相干扰

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