为什么这个 LinqPad 程序在第二次运行时会产生不同的结果？

Question

I am developing a simple PID controller in LinqPad:

The PID Class

class PidController
{
    public float Proportional { get; set; }
    public float Integral { get; set; }
    public float Derivative { get; set; }
    public float SetPoint { get; set; }
    public float Kp { get; set; }
    public float Ki { get; set; }
    public float Kd { get; set; }

    float _lastError;
    DateTime _lastTime = DateTime.Now;

    public PidController(float kp, float ki, float kd)
    {
        Kp = kp; Ki = ki; Kd = kd;
    }

    public float GetControlValue(float actual)
    {
        var currentTime = DateTime.Now;
        var deltaTime = (float)(currentTime - _lastTime).TotalSeconds;
        var error = SetPoint - actual;

        Proportional = error;
        Integral = Integral + error * deltaTime;
        Derivative = (error - _lastError) / deltaTime;

        _lastError = error;

        return Kp * Proportional + Ki * Integral + Kd * Derivative;
    }
}

For testing and tuning, the controller will control this simple process:

The Controlled Process

class SimpleProcess
{
    private DateTime _lastTime = DateTime.Now;
    private float _output;

    public float Output { get { UpdateOutput(); return _output; }}
    public float Input { get; set; }

    private void UpdateOutput()
    {
        var deltaTime = (float)(DateTime.Now - _lastTime).TotalSeconds;
        _output += Input * deltaTime;
    }
}

...using this main loop:

The Main Program Loop

void Main()
{
    var pid = new PidController(1f, 0f, 0f) { SetPoint = 100f };
    var proc = new SimpleProcess();

    // pid.Dump();
    // proc.Dump();

    var values = new List<ProcessValue>();

    for (int i = 0; i < 50; i++)
    {
        var actual = proc.Output;
        var controlValue = pid.GetControlValue(actual);
        proc.Input = controlValue;

        var value = new ProcessValue
        {
            index = i,
            timestamp = DateTime.Now.ToString("ss.fff"),
            p = pid.Proportional,
            i = pid.Integral,
            d = pid.Derivative,
            input = controlValue,
            output = actual
        };

        values.Add(value);

        Thread.Sleep(100);
    }

    values.Dump();
}

public class ProcessValue
{
    public int index;
    public string timestamp;
    public float p, i, d, input, output;
}

Everything works as expected on the first run:

index  timestamp  p      i       d         input output
0      53.309     100    0.46    21490.59  100   0 
1      53.411     89.69  10.06  -96.27     89.69 10.30 
etc...

However, I started getting unexpected results on the second and subsequent runs after I commented out the line proc.Dump() :

index  timestamp  p    i    d    input  output 
0      10.199     100  0    ∞    NaN    0 
1      10.299     NaN  NaN  NaN  NaN    NaN 
2      10.399     NaN  NaN  NaN  NaN    NaN 
etc...

Why is the second run (and subsequent runs) returning different results in my case?

Any of the following actions will cause the next run to succeed:

• modify the code (even just adding/removing a single whitespace)
• press [CTRL]+[SHIFT]+[F5]

The following makes the code run correctly every time:

• uncomment the line proc.Dump()

This answer mentions that static variables will be cached between runs, but I have no static variables. I suspect the problem is related to the Application Domain Caching feature in LinqPad, but I'm trying to understand why I'm affected by this.

Update

StriplingWarrior's answer is correct, my first derivative calculation resulted in Infinity when they system was performing well (ie after LinqPad had cached the first run), causing all subsequent calculations to fail. Modifying my program in any way was invalidating this cache and caused the deltaTime to be large enough to avoid the error again on the next run.

Since a derivative term makes no sense on the first interval, I decided to handle this by simply ignoring it:

var p = Kp * Proportional;
var i = Ki * Integral;
var d = float.IsInfinity(Derivative) ? 0 : Kd * Derivative;

return p + i + d;

Answer 1

You can test what Andrew theorizes in your comments above, by changing the first part of your main method thusly:

var sw = new Stopwatch();
sw.Start();
var pid = new PidController(1f, 0f, 0f) { SetPoint = 100f };
var proc = new SimpleProcess();

// pid.Dump();
// proc.Dump();

var values = new List<ProcessValue>();

for (int i = 0; i < 50; i++)
{
    var actual = proc.Output;
    var controlValue = pid.GetControlValue(actual);
    if(sw.IsRunning){
        sw.Stop();
        sw.ElapsedTicks.Dump();
    }

Running on my machine, I can see that the first run takes 10,000+ ticks, whereas the second run takes only 20 ticks. I'm guessing this makes your calculations based on differences in DateTime.Now have very small delta values, and yield the differences you're seeing.