santisq · May 4, 2026 14:37
diff --git a/README.md b/README.md
diff --git a/MeasureScriptBlockMemoryCommand.cs b/MeasureScriptBlockMemoryCommand.cs
 using System;
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Management.Automation;
 using System.Threading.Tasks;

 internal sealed class MemoryCounterSampleFactory(PerformanceCounter counter, ScriptBlock invocation)
    : IDisposable
 {
    private const long Mb = 1_048_576;
    private readonly PerformanceCounter _counter = counter;
    private readonly DateTime _start = DateTime.Now;
    private readonly string _invocation = invocation.ToString().Trim();
    private readonly float _base = counter.NextValue();

    internal MemoryCounterSample Next()
    {
        DateTime now = DateTime.Now;
        float nextValue = _counter.NextValue();

        return new MemoryCounterSample()
        {
            TimeStamp = now,
            Span = now - _start,
            InvocationMemoryInMb = Math.Max(nextValue - _base, 0) / Mb,
            ProcessMemoryInMb = nextValue / Mb,
            Invocation = _invocation
        };
    }

    public void Dispose() => _counter.Dispose();
 }

 public struct MemoryCounterSample
 {
    public DateTime TimeStamp;
    public TimeSpan Span;
    public float InvocationMemoryInMb;
    public float ProcessMemoryInMb;
    public string? Invocation;
 }

 [Cmdlet(VerbsDiagnostic.Measure, "ScriptBlockMemory")]
 public sealed class MeasureScriptBlockMemoryCommand : PSCmdlet
 {
    [Parameter(Mandatory = true, Position = 0)]
    public ScriptBlock ScriptBlock { get; set; } = null!;

    [Parameter(Position = 1)]
    [ValidateNotNull]
    public TimeSpan Interval { get; set; } = TimeSpan.FromMilliseconds(500);

    protected override void EndProcessing()
    {
        using MemoryCounterSampleFactory factory = new(GetCounter(), ScriptBlock);
        using BlockingCollection<MemoryCounterSample> output = [];

        Task.Run(async () =>
        {
            while (!output.IsAddingCompleted)
            {
                output.Add(factory.Next());
                await Task.Delay(Interval);
            }
        }).ConfigureAwait(false);

        Task.Run(() =>
        {
            try
            {
                _ = ScriptBlock.Invoke();
            }
            finally
            {
                output.CompleteAdding();
            }
        }).ConfigureAwait(false);

        foreach (MemoryCounterSample sample in output.GetConsumingEnumerable())
            WriteObject(sample);
    }

    private static PerformanceCounter GetCounter()
    {
        PerformanceCounterCategory category = new("process");
        using PerformanceCounter counter = new("process", "id process", true);

        foreach (string c in category.GetInstanceNames())
        {
            counter.InstanceName = c;
            if (counter.RawValue == Environment.ProcessId)
            {
                counter.CounterName = "private bytes";
                return counter;
            }
        }

        throw new OperationCanceledException(
            $"Could not find performance counter instance for PID '{Environment.ProcessId}'.");
    }
 }
	using System;
	using System.Collections.Concurrent;
	using System.Diagnostics;
	using System.Management.Automation;
	using System.Threading.Tasks;

	internal sealed class MemoryCounterSampleFactory(PerformanceCounter counter, ScriptBlock invocation)
	: IDisposable
	{
	private const long Mb = 1_048_576;
	private readonly PerformanceCounter _counter = counter;
	private readonly DateTime _start = DateTime.Now;
	private readonly string _invocation = invocation.ToString().Trim();
	private readonly float _base = counter.NextValue();

	internal MemoryCounterSample Next()
	{
	DateTime now = DateTime.Now;
	float nextValue = _counter.NextValue();

	return new MemoryCounterSample()
	{
	TimeStamp = now,
	Span = now - _start,
	InvocationMemoryInMb = Math.Max(nextValue - _base, 0) / Mb,
	ProcessMemoryInMb = nextValue / Mb,
	Invocation = _invocation
	};
	}

	public void Dispose() => _counter.Dispose();
	}

	public struct MemoryCounterSample
	{
	public DateTime TimeStamp;
	public TimeSpan Span;
	public float InvocationMemoryInMb;
	public float ProcessMemoryInMb;
	public string? Invocation;
	}

	[Cmdlet(VerbsDiagnostic.Measure, "ScriptBlockMemory")]
	public sealed class MeasureScriptBlockMemoryCommand : PSCmdlet
	{
	[Parameter(Mandatory = true, Position = 0)]
	public ScriptBlock ScriptBlock { get; set; } = null!;

	[Parameter(Position = 1)]
	[ValidateNotNull]
	public TimeSpan Interval { get; set; } = TimeSpan.FromMilliseconds(500);

	protected override void EndProcessing()
	{
	using MemoryCounterSampleFactory factory = new(GetCounter(), ScriptBlock);
	using BlockingCollection<MemoryCounterSample> output = [];

	Task.Run(async () =>
	{
	while (!output.IsAddingCompleted)
	{
	output.Add(factory.Next());
	await Task.Delay(Interval);
	}
	}).ConfigureAwait(false);

	Task.Run(() =>
	{
	try
	{
	_ = ScriptBlock.Invoke();
	}
	finally
	{
	output.CompleteAdding();
	}
	}).ConfigureAwait(false);

	foreach (MemoryCounterSample sample in output.GetConsumingEnumerable())
	WriteObject(sample);
	}

	private static PerformanceCounter GetCounter()
	{
	PerformanceCounterCategory category = new("process");
	using PerformanceCounter counter = new("process", "id process", true);

	foreach (string c in category.GetInstanceNames())
	{
	counter.InstanceName = c;
	if (counter.RawValue == Environment.ProcessId)
	{
	counter.CounterName = "private bytes";
	return counter;
	}
	}

	throw new OperationCanceledException(
	$"Could not find performance counter instance for PID '{Environment.ProcessId}'.");
	}
	}
No results found