-1 
var mapper = Mappers.Xy<MeasureModel>()
           .X(model => model.DateTime.Ticks)   //use DateTime.Ticks as X
           .Y(model => model.Value);           //use the value property as Y

//The next code simulates data changes every 500 ms
Timer = new Timer
{
    Interval = 1000
};
Timer.Tick += TimerOnTick;
R = new Random();
Timer.Start();

ChartValues.Add(new MeasureModel
{
    DateTime = now,
    Value = R.Next(0, 5)
});

从上面，我该怎么做，而不是让 R 随机，我可以将它设置为递减。就像它像 5.0 4.4 3.2 等一样下降，而不是在 0 到 5 之间随机下降

4

4 回答 4

0

在设置第一个计时器的方法中，添加另一个，如下所示：

//The next code simulates data changes every 500 ms
Timer = new Timer
{
    Interval = 1000
};
Timer.Tick += TimerOnTick;
R = new Random();
Timer.Start();

//another timer
SecondTimer = new Timer() { Interval = 2000 };
SecondTimer.Enabled = true;
SecondTimer.Tick += SecondTimer_Tick;

定义一些min变量

double min = 4.9;

在SecondTimer_Tick方法中，调整这些变量并生成新值。 Random.NextDouble将生成从 0 到 1 的数字（即 0.887），将其添加到您的minvar。此外，将您的最小值减少一些值（在本例中为 0.2）

private void SecondTimer_Tick(object sender, EventArgs e)
{
    min -= 0.2;

    if (min == 0)
        //stop timer or something
        SecondTimer.Stop();

    Random R = new Random();
    var value = R.NextDouble();
    value += min;
}

希望这可以帮助。

编辑： 添加一些检查随机生成器生成的值是否太大。例如，如果你min是 4.8 并且生成的值是 0.5 - 将它们加在一起会得到 5.3，我想这对你的情况来说价值太大了。

于 2017-01-24T09:40:07.413 回答
0

var r = R.NextDouble()*5会给你从 0 到 5 的十进制数。

语义上你可以像这样反转数字，var r= 5 - R.NextDouble()*5

当然 5 可以是任意数量的变量。

现在在每个计时器滴答时从随机生成的数字中减少值。

private double decrementingValue = 5;

... 

r = R.NextDouble()* 5;
decrementingValue -= r;

if(decrementingValue <= 0) 
       decrementingValue= 0; // you are finished
于 2017-01-24T09:40:36.120 回答
0

您可以使用抽象测量源

public interface IMeasurementSource
{
    MeasureModel GetNext();
}

为您的类（可能是表单）提供一些IMeasurementSource实现并将其保存在类字段中。例如

private IMeasurementSource measurementSource = new BouncingMesasurementSource(5, 0.1);

并在每次计时器滴答时调用它：

ChartValues.Add(measurementSource.GetNext());

实现抽象

您可以通过从真实来源获取测量值来实现此接口。或者您可以使用随机测量生成器：

public class RandomMeasurementSource : IMeasurementSource
{
    private readonly Random random = new Random();
    private readonly int min;
    private readonly int max;

    public RandomMeasurementSource(int min, int max)
    {
        this.min = min;
        this.max = max;
    }

    public MeasureModel GetNext()
    {
        return new MeasureModel { DateTime = DateTime.Now, Value = random.Next(min, max) };
    }
}

或弹跳将返回并强制在零和最大值之间：

public class BouncingMeasurementSource : IMeasurementSource
{
    private readonly double max;
    private double step;
    private double current;

    public BouncingMeasurementSource(int max, double step)
    {
        this.max = max;
        this.step = step;
        this.current = max;
    }

    public MeasureModel GetNext()
    {
        var model = new MeasureModel { DateTime = DateTime.Now, Value = current };
        current -= step;

        if (current < 0 || max < current)
        {
            step = -step;
            current = current < 0 ? 0 : max;
        }

        return model;
    }
}
于 2017-01-24T10:02:26.287 回答
0

构建一个生成器类，它将为您完成新值的所有计算。

作为示例，这里有一个非常基本的实现，可以作为您的课程的入门者

enum Direction
{
    Increase,
    Decrease,
}

class ValueGenerator
{
    private readonly Random _generator;

    public ValueGenerator( Random generator )
    {
        if ( generator == null )
            throw new ArgumentNullException( nameof( generator ) );
        _generator = generator;
    }

    public double MinInterval { get; set; } = 0;
    public double MaxInterval { get; set; } = 1;
    public double MinValue { get; set; } = 0;
    public double MaxValue { get; set; } = 100;
    public double CurrentValue { get; set; } = 0;
    public Direction CurrentDirection { get; set; } = Direction.Increase;
    public int PossibilityToChangeDirection { get; set; } = 10;

    public double NextValue()
    {
        if ( _generator.Next( PossibilityToChangeDirection + 1 ) == PossibilityToChangeDirection / 2 )
        {
            switch ( CurrentDirection )
            {
                case Direction.Increase:
                    CurrentDirection = Direction.Decrease;
                    break;
                case Direction.Decrease:
                    CurrentDirection = Direction.Increase;
                    break;
                default:
                    throw new InvalidOperationException( );
            }
        }

        var newInterval = ( MaxInterval - MinInterval ) * _generator.NextDouble( ) + MinInterval;
        if ( CurrentDirection == Direction.Decrease )
            newInterval = -newInterval;

        if ( CurrentValue + newInterval < MinValue )
            CurrentValue = MinValue;
        else if ( CurrentValue + newInterval > MaxValue )
            CurrentValue = MaxValue;
        else
            CurrentValue += newInterval;

        return CurrentValue;
    }
}

使用示例

//The next code simulates data changes every 500 ms
Timer = new Timer
{
    Interval = 1000
};
Timer.Tick += TimerOnTick;

var vg = new ValueGenerator( new Random( ) )
{
    MinValue = 0,
    MaxValue = 5,
    MinInterval = 0.1,
    MaxInterval = 0.7,
    CurrentValue = 3.0,
    CurrentDirection = Direction.Decrease,
    PossibilityToChangeDirection = 10,
};

Timer.Start();

ChartValues.Add(new MeasureModel
{
    DateTime = now,
    Value = vg.NextValue(),
});
于 2017-01-24T10:17:36.320 回答