Question

我有一个与此类似的课程

 public class Model
{
    public TimeSpan Time1 {get; set;}
    public TimeSpan Time2 { get; set; }
    public TimeSpan Time3 { get; set; }
    public TimeSpan Time4 { get; set; }

}

现在让我们想象一下，我必须在运行时填充时间，然后计算出时间1和时间2之间的剩余时间，然后当通过时查找时间2和时间3之间剩余的时间，依此类推。但是，我需要考虑现在的时间。

例如：

现在是下午1点

时间1 =早上5:00 时间2 =中午12:00 时间3 =下午4:00 时间4 =下午6:00

因此，由于时间是下午1:00，我需要找到时间2和时间3之间的差异

现在除了反思之外还有更聪明的方法来确定这个吗？我应该在课堂上添加一些东西

Answer 1

如果您需要保留类的现有结构，可以添加一个方法来枚举时间：

public class Model
{
    public TimeSpan Time1 {get; set;}
    public TimeSpan Time2 { get; set; }
    public TimeSpan Time3 { get; set; }
    public TimeSpan Time4 { get; set; }

    public IEnumerable<TimeSpan> GetTimes()
    {
        yield return Time1;
        yield return Time2;
        yield return Time3;
        yield return Time4;
    }
}

并像这样使用它：

foreach (TimeSpan time in model.GetTimes())
{
    // use the TimeSpan
}

Answer 2

为什么不使用数组或列表？

public class Model
{
    public List<DateTime> Dates { get; set; }
}

Answer 3

如果我正确理解了您的问题，为什么不能使用Dictionary<TimeSpan, string>，其中密钥为实际TimeSpan，并且值为名称，例如"Time1"？这样，您可以对键进行排序，找到所需的对，然后获取其名称。

Answer 4

您可以添加一个属性或方法，将时间作为列表返回，以便于处理。然后，您的外部代码可以作为列表或单个属性访问时间。您仍然必须显式访问每个属性，但至少它来自同一个类，因此您不会将外部代码与数据结构紧密耦合。

Answer 5

这是未经测试的，需要一些优化，但作为一个思考示例，使用数组并迭代它。

public class Model
{
    private TimeSpan[] _timeSpans = new TimeSpan[4] { new TimeSpan(), new TimeSpan(), new TimeSpan(), new TimeSpan() };

    public TimeSpan Time1
    {
        get { return _timeSpans[0]; }
        set { _timeSpans[0] = value; }
    }
    public TimeSpan Time2
    {
        get { return _timeSpans[1]; }
        set { _timeSpans[1] = value; }
    }
    public TimeSpan Time3
    {
        get { return _timeSpans[2]; }
        set { _timeSpans[2] = value; }
    }
    public TimeSpan Time4
    {
        get { return _timeSpans[3]; }
        set { _timeSpans[3] = value; }
    }

    // DateTime.TimeOfDay holds the time portion of a time
    public TimeSpan GetDifference(TimeSpan currentTime)
    {
        int start = -1;
        for(int i = 0; i<_timeSpans.Length;i++)
        {
            if(_timeSpans[i] >= currentTime)
            {
                start = i;
                break;
            }
        }
        if(start == -1) throw new ArgumentException("handle the case where currentTime is smaller than all of them");
        int end = (start + 1 < _timeSpans.Length) ? start + 1 : 0;
        return _timeSpans[end] - _timeSpans[start];
    }

Answer 6

构造数组提供了一个简单的linq语句来计算时间跨度：

public class Model
{
    public TimeSpan Time1 { get; set; }
    public TimeSpan Time2 { get; set; }
    public TimeSpan Time3 { get; set; }
    public TimeSpan Time4 { get; set; }

    public TimeSpan GetSpan(TimeSpan time)
    {
        var times = new[] { Time1, Time2, Time3, Time4 };

        return Enumerable.Range(1, times.Length - 1)
            .Select(i => new[] { times[i - 1], times[i] })
            .Where(t => t[0] <= time && time < t[1])
            .Select(t => t[1] - t[0])
            .FirstOrDefault();
    }
}

在C＃中枚举类属性

6 个答案: