Question

我想处理Timeblocks，这意味着一组两个DateTimes，例如代表员工的存在。是否已经有任何结构可用于在特定时间之前或之后搜索块？我可以通过很多方式来表达这种情况，就像我说的有两个DateTimes的开始和结束，或者有一个Datetime for start和TimeSpan。但是我希望它们能够在一种集合中处理。那么有什么类似我可以使用或者我必须完全自己实现它吗？

由于

Answer 1

这个图书馆很棒 - 可能会受到启发

Time Period Library for .NET

Answer 2

班级：

public class TimePeriod
{
    public DateTime Oldest { get; set; }
    public DateTime Newest { get; set; }

    public TimePeriod(DateTime oldest, DateTime newest)
    {
        Oldest = oldest;
        Newest = newest;
    }

    public bool Contains (DateTime time)
    {
        return Oldest.CompareTo(time) <= 0 && Newest.CompareTo(time) >= 0;
    }

    public bool IsAfter(DateTime time)
    {
        return Newest.CompareTo(time) <= 0;
    }

    public bool IsBefore(DateTime time)
    {
        return Oldest.CompareTo(time) >= 0; 
    }
}

测试：

class Program
{
    static void Main(string[] args)
    {
        var period = new TimePeriod(
                    DateTime.Now.AddDays(-2),
                    DateTime.Now.AddDays(1));

        var date = DateTime.Now;
        var contains = period.Contains(date); // true
        var isBefore = period.IsBefore(date); // false
        var isAfter = period.IsAfter(date);   // false

        date = DateTime.Now.AddDays(-10);
        contains = period.Contains(date); // false
        isBefore = period.IsBefore(date); // true
        isAfter = period.IsAfter(date);   // false

        date = DateTime.Now.AddDays(10);
        contains = period.Contains(date); // false
        isBefore = period.IsBefore(date); // false
        isAfter = period.IsAfter(date);   // true
    }
}

现在，您可以使用集合和linq以及扩展方法和lambda表达式来查找时间块。

Answer 3

这不是内置的。如果您想自己实现，可能需要创建 struct 。这将为您提供值类型的复制语义。此类值的行为与int或DateTime等内置类型相似。使用起来非常直观。

Answer 4

您可以查看TimeSpan。这是一个处理“时间块”的结构

Answer 5

之前我使用过DateSpan结构。你可以随意扩展，但这会给你一个起点。

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace StackOverFlowDateSpan
{
[StructLayout(LayoutKind.Auto)]
[Serializable]
public struct DateSpan : IComparable, IComparable<DateSpan>, IEquatable<DateSpan>
{
    public DateSpan(DateTime start, DateTime end)
        : this()
    {
        Start = start;
        End = end;
    }

    #region Properties

    public TimeSpan Duration
    {
        get { return TimeSpan.FromTicks((End - Start).Ticks); }
    }

    public DateTime End { get; private set; }
    public DateTime Start { get; private set; }

    #endregion

    public int CompareTo(DateSpan other)
    {
        long otherTicks = other.Duration.Ticks;
        long internalTicks = Duration.Ticks;

        return internalTicks > otherTicks ? 1 : (internalTicks < otherTicks ? -1 : 0);
    }

    public bool Equals(DateSpan other)
    {
        return End.Equals(other.End) && Start.Equals(other.Start);
    }

    public int CompareTo(object other)
    {
        if (other == null)
        {
            return 1;
        }

        if (!(other is DateSpan))
        {
            throw new ArgumentNullException("other");
        }

        return CompareTo((DateSpan)other);
    }

    public override bool Equals(object other)
    {
        if (ReferenceEquals(null, other))
        {
            return false;
        }
        return other is DateSpan && Equals((DateSpan)other);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            return (End.GetHashCode() * 397) ^ Start.GetHashCode();
        }
    }

    public static bool operator ==(DateSpan left, DateSpan right)
    {
        return left.Equals(right);
    }

    public static bool operator !=(DateSpan left, DateSpan right)
    {
        return !left.Equals(right);
    }

    private sealed class EndStartEqualityComparer : IEqualityComparer<DateSpan>
    {
        #region IEqualityComparer<DateSpan> Members

        public bool Equals(DateSpan x, DateSpan y)
        {
            return x.End.Equals(y.End) && x.Start.Equals(y.Start);
        }

        public int GetHashCode(DateSpan obj)
        {
            unchecked
            {
                return (obj.End.GetHashCode() * 397) ^ obj.Start.GetHashCode();
            }
        }

        #endregion
    }

    private static readonly IEqualityComparer<DateSpan> _endStartComparerInstance = new EndStartEqualityComparer();

    public static IEqualityComparer<DateSpan> EndStartComparer
    {
        get { return _endStartComparerInstance; }
    }
}
}

Answer 6

感谢您的帮助！我将仔细研究TimePeriod库并对Linq进行一些实验。我已经有了一个实现二进制搜索的approch，所以如果有人感兴趣你可以写我;）

是否有处理Timeblocks的结构？

6 个答案: