C# 检查日期中的月份和年份是否在列表中的序列中

我有一个C#

axiomisubdata

列表，其中有几列，每列有几行数据。列表中的一列被命名为

Term

，它的类型为

DateTime

，我试图找出一种方法，如果列

Term

的元素相等或它们的月份和年份顺序相同，则返回

true

例如，对于列表中的术语，我有以下数据：

   Term      CC
 dd/mm/yyyy
 10/10/2016  A
 10/9/2016   A
 10/8/2016   A
 10/7/2016   A
 10/6/2016   A
 16/5/2016   A
 10/4/2016   A
 10/3/2016   A
 10/2/2016   A
 10/1/2016   A
 10/12/2015  A

当将上述列表传递给函数并将其传递给方法时，它应返回true，因为从2015年12月到2016年10月，按顺序进行上述操作，如果条件相等，它也应返回true

我可以使用下面的代码在同等条件下完成它

if ((AxiomSubSet.Select(x => x.term).Distinct().ToList()).Count == 1)
{
//do something
}

---

您可以将您的列表与按日期顺序排序的相同列表进行比较，以查看它们是否已按顺序排列

看

---

基本上，创建列表的副本，按日期排序，并使用

.SequenceEqual

将其与原始列表进行比较。您可以将列表与按日期排序的相同列表进行比较，以查看它们是否已按顺序排列

看

---

基本上，创建列表的副本，按日期排序，并使用

.SequenceEqual

将其与原始列表进行比较。您可以将列表与按日期排序的相同列表进行比较，以查看它们是否已按顺序排列

看

---

基本上，创建列表的副本，按日期排序，并使用

.SequenceEqual

将其与原始列表进行比较。您可以将列表与按日期排序的相同列表进行比较，以查看它们是否已按顺序排列

看

---

基本上，创建列表的副本，按日期排序，并使用

.SequenceEqual

将其与原始列表进行比较。您可以从一个简单的方法开始，将序列中的所有项目与之前的项目配对：

public static IEnumerable<Tuple<T, T>> Pairwise<T>(this IEnumerable<T> source)
{
    using (var iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
            yield break;

        T prev = iterator.Current;

        while (iterator.MoveNext())
        {
            yield return Tuple.Create(prev, iterator.Current);
            prev = iterator.Current;
        }
    }
}

---

您可以从一个简单的方法开始，将序列中的所有项与前面的项配对：

public static IEnumerable<Tuple<T, T>> Pairwise<T>(this IEnumerable<T> source)
{
    using (var iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
            yield break;

        T prev = iterator.Current;

        while (iterator.MoveNext())
        {
            yield return Tuple.Create(prev, iterator.Current);
            prev = iterator.Current;
        }
    }
}

---

您可以从一个简单的方法开始，将序列中的所有项与前面的项配对：

public static IEnumerable<Tuple<T, T>> Pairwise<T>(this IEnumerable<T> source)
{
    using (var iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
            yield break;

        T prev = iterator.Current;

        while (iterator.MoveNext())
        {
            yield return Tuple.Create(prev, iterator.Current);
            prev = iterator.Current;
        }
    }
}

---

您可以从一个简单的方法开始，将序列中的所有项与前面的项配对：

public static IEnumerable<Tuple<T, T>> Pairwise<T>(this IEnumerable<T> source)
{
    using (var iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
            yield break;

        T prev = iterator.Current;

        while (iterator.MoveNext())
        {
            yield return Tuple.Create(prev, iterator.Current);
            prev = iterator.Current;
        }
    }
}

（答案因评论而更改。原始答案见下文。）

因此，您只需要确保列表中的每个日期比上一个日期早一个月。给出日期列表：

List<Date> dates;

如果只有月份和年份重要，只需在循环内修改测试：

    if (Dates[x].Year > Dates[x-1].Year) 
    {
        // current date is after previous date. List is out of order.
        return false;
    }
    if (Dates[x].Year < Dates[x-1].Year)
    {
        // current year is before previous year. This one is in order.
        continue;
    }
    if (Dates[x].Month > Dates[x-1].Month)
    {
        // Years are equal, but this date is after previous date.
        // List is out of order.
        return false;
    }

if（日期[x].Year>日期[x-1].Year）
{
//当前日期在上一个日期之后。列表无序。
返回false；
}
if（日期[x].年<日期[x-1].年）
{
//本年度在上一年度之前。本年度正常。
继续；
}
如果（日期[x].月份>日期[x-1].月份）
{
//年数相等，但此日期在前一日期之后。
//这张单子坏了。
返回false；
}

我真的不知道是否有LINQ方法可以做到这一点。

（答案因评论而改变。原始答案见下文。）

因此，您只需要确保列表中的每个日期比上一个日期早一个月。给出日期列表：

List<Date> dates;

如果只有月份和年份重要，只需在循环内修改测试：

    if (Dates[x].Year > Dates[x-1].Year) 
    {
        // current date is after previous date. List is out of order.
        return false;
    }
    if (Dates[x].Year < Dates[x-1].Year)
    {
        // current year is before previous year. This one is in order.
        continue;
    }
    if (Dates[x].Month > Dates[x-1].Month)
    {
        // Years are equal, but this date is after previous date.
        // List is out of order.
        return false;
    }

if（日期[x].Year>日期[x-1].Year）
{
//当前日期在上一个日期之后。列表无序。
返回false；
}
if（日期[x].年<日期[x-1].年）
{
//本年度在上一年度之前。本年度正常。
继续；
}
如果（日期[x].月份>日期[x-1].月份）
{
//年数相等，但此日期在前一日期之后。
//这张单子坏了。
返回false；
}

我真的不知道是否有LINQ方法可以做到这一点。

（答案因评论而改变。原始答案见下文。）

因此，您只需要确保列表中的每个日期比上一个日期早一个月。给出日期列表：

List<Date> dates;

如果只有月份和年份重要，只需在循环内修改测试：

    if (Dates[x].Year > Dates[x-1].Year) 
    {
        // current date is after previous date. List is out of order.
        return false;
    }
    if (Dates[x].Year < Dates[x-1].Year)
    {
        // current year is before previous year. This one is in order.
        continue;
    }
    if (Dates[x].Month > Dates[x-1].Month)
    {
        // Years are equal, but this date is after previous date.
        // List is out of order.
        return false;
    }

if（日期[x].Year>日期[x-1].Year）
{
//当前日期在上一个日期之后。列表无序。
返回false；
}
if（日期[x].年<日期[x-1].年）
{
//本年度在上一年度之前。本年度正常。
继续；
}
如果（日期[x].月份>日期[x-1].月份）
{
//年数相等，但此日期在前一日期之后。
//这张单子坏了。
返回false；
}

我真的不知道是否有LINQ方法可以做到这一点。

（答案因评论而改变。原始答案见下文。）

因此，您只需要确保列表中的每个日期比上一个日期早一个月。给出日期列表：

List<Date> dates;

如果只有月份和年份重要，只需在循环内修改测试：

    if (Dates[x].Year > Dates[x-1].Year) 
    {
        // current date is after previous date. List is out of order.
        return false;
    }
    if (Dates[x].Year < Dates[x-1].Year)
    {
        // current year is before previous year. This one is in order.
        continue;
    }
    if (Dates[x].Month > Dates[x-1].Month)
    {
        // Years are equal, but this date is after previous date.
        // List is out of order.
        return false;
    }

if（日期[x].Year>日期[x-1].Year）
{
//当前日期在上一个日期之后。列表无序。
返回false；
}
if（日期[x].年<日期[x-1].年）
{
//本年度在上一年度之前。本年度正常。
继续；
}
如果（日期[x].月份>日期[x-1].月份）
{
//年数相等，但此日期在前一日期之后。
//这张单子坏了。
返回false；
}

---

我真的不知道是否有办法做到这一点。

这将检查列表中的日期是否连续。在循环中放置的

这将检查列表中的日期是否连续。在循环中放置的
这将检查列表中的日期是否连续。在循环中放置的
这将检查你名单上的日期