如何在lambda函数c#的Where中使用列表？

我现在有这个代码，我想使用周末列表，而不是静态日期

Sunday

和

Saturday

。如何在项目

z.DayOfWeek

和周末列表之间使用相等函数

    DateTime start = new DateTime(2021,3,3);
    DateTime end = new DateTime(2021,3,27);
    
    List<DateTime> blackOut = new List<DateTime>
    {
        new DateTime(2021,3,10),
        new DateTime(2021,3,11)
        
    };
    
var days = Enumerable.Range(0, (int)(end - start).TotalDays)
          .Select(x => start.AddDays(x))
          .Where(z => z.DayOfWeek != DayOfWeek.Saturday && 
                      z.DayOfWeek != DayOfWeek.Sunday &&
                      !blackOut.Contains(z))
          .Count();

DateTime start=newdatetime（2021,3,3）；
DateTime end=新的日期时间（2021,3,27）；
列表中断=新列表
{
新日期时间（2021,3,10），
新日期时间（2021,3,11）
};
变量天数=可枚举的.Range（0，（int）（结束-开始）.TotalDays）
.Select（x=>start.AddDays（x））
其中（z=>z.DayOfWeek！=DayOfWeek.Saturday&&
z、 星期天&&
！断电。包含（z））
.Count（）；

假设我有一个包含weekendslist的周末列表，我尝试的是：

List<string> weekendslist = new List<string>();
weekendslist.Add(DayOfWeek.Saturday.ToString());
weekendslist.Add(DayOfWeek.Sunday.ToString());
var days = Enumerable.Range(0, (int)(end - start).TotalDays)
          .Select(x => start.AddDays(x))
          .Where(z => weekendslist.Contains(z.DayOfWeek.ToString())
                      !blackOut.Contains(z))
          .Count();

List weekendslist=newlist（）；
weekendslist.Add（DayOfWeek.Saturday.ToString（））；
添加（DayOfWeek.Sunday.ToString（））；
变量天数=可枚举的.Range（0，（int）（结束-开始）.TotalDays）
.Select（x=>start.AddDays（x））
.Where（z=>weekendslist.Contains（z.DayOfWeek.ToString（））
！断电。包含（z））
.Count（）；

但这对我不起作用。有人知道我该怎么做才能做到这一点吗

---

参考：

使用

枚举定义如何

enum Weekends
{
    Saturday,
    Sunday
}

或者另一种选择是为
DayOfWeek

public static class WeekendExtension
{
    public static bool IsWeekend(this DayOfWeek dayOfWeek)
    {
        return dayOfWeek == DayOfWeek.Saturday || 
            dayOfWeek == DayOfWeek.Sunday;
    }
}

以下代码与您的尝试相同，仅使用
DayOfWeek
enum值而不是字符串，并正确地对
包含的内容求反：

DateTime start = new DateTime(2021, 3, 3);
DateTime end = new DateTime(2021, 3, 27);
List<DateTime> blackOut = new List<DateTime>
{
    new DateTime(2021, 3, 10), 
    new DateTime(2021, 3, 11)
};
List<DayOfWeek> weekendslist = new List<DayOfWeek>
{
    DayOfWeek.Saturday,
    DayOfWeek.Sunday
};
var days = Enumerable
    .Range(0, (int)(end - start).TotalDays)
    .Select(x => start.AddDays(x))
    .Where(z => 
           !weekendslist.Contains(z.DayOfWeek) && 
           !blackOut.Contains(z))
    .Count();
Console.WriteLine(days);

DateTime start=newdatetime（2021,3,3）；
DateTime end=新的DateTime（2021,3,27）；
列表中断=新列表
{
新日期时间（2021年3月10日），
新日期时间（2021年3月11日）
};
List weekendslist=新列表
{
星期五，星期六，
星期天，星期天
};
变量天数=可枚举
.范围（0，（整数）（结束-开始）。总天数）
.Select（x=>start.AddDays（x））
.其中（z=>
！weekendslist.Contains（z.DayOfWeek）和
！断电。包含（z））
.Count（）；
控制台写入线（天）；
创建一个工作日列表，然后只需调用
Where（x=>theList.Contains（x））
？您在这里遇到了什么具体问题？您能向我解释一下您的方法吗？您似乎忘记了否定您的
周列表。Contains
。目前你只有周末。要继续@TimSchmelter的评论，请在我的答案中使用代码，但不要使用静态列表，而是使用类似于
MyListFints的内容。选择（myInt=>（DayOfWeek）myInt）
谢谢你的回答，但问题是枚举是常量，weekendslist可以每次更改。因此，将
IsWeekend
更改为动态…我如何解决此错误<代码>扩展方法必须在非泛型静态类中定义
如果我们瞄准的是一个不断变化的目标，我需要你以我能理解的方式解释这个问题。你的问题，用词来说，是指“排除周末”，这意味着你希望排除的日子是固定的。我不明白这个问题。把它放到一个静态的类中。我相应地编辑了我的答案。看到它在这里工作了吗：好的，谢谢你，现在可以了。
var days = Enumerable.Range(0, (int)(end - start).TotalDays)
    .Select(x => start.AddDays(x))
    .Where(z => !z.DayOfWeek.IsWeekend() &&
                !blackOut.Contains(z))
    .Count();

DateTime start = new DateTime(2021, 3, 3);
DateTime end = new DateTime(2021, 3, 27);
List<DateTime> blackOut = new List<DateTime>
{
    new DateTime(2021, 3, 10), 
    new DateTime(2021, 3, 11)
};
List<DayOfWeek> weekendslist = new List<DayOfWeek>
{
    DayOfWeek.Saturday,
    DayOfWeek.Sunday
};
var days = Enumerable
    .Range(0, (int)(end - start).TotalDays)
    .Select(x => start.AddDays(x))
    .Where(z => 
           !weekendslist.Contains(z.DayOfWeek) && 
           !blackOut.Contains(z))
    .Count();
Console.WriteLine(days);