C# 基于一组布尔值构建字符串的最有效方法是什么

我有7个布尔值。根据它们的值，我需要构建一个字符串。最有效的方法是什么

例如，我的布尔值为：

bool green = false;
bool red = true;
bool purple = true;
bool orange = false;
bool black = true;
bool blue = true;
bool brown = false;

每个布尔变量（理论上）都有一个与其关联的字符串。我要生成的最后一个字符串取决于“true”值

这里，我要生成的字符串是“红人-乌鸦-袭击者-德克萨斯人”

与“false”变量关联的字符串不会包含在最终字符串中

我正在处理的实际问题规模更大，大约有50个布尔值，我的需求有50个与之关联的字符串

还有什么比使用

StringBuilder

的大型

if-else

方法更有效的方法吗

我的变量名不代表我需要输出的字符串。

bool green=false；
bool green = false;
bool red = true;
bool purple = true;
bool orange = false;
bool black = true;
bool blue = true;
bool brown = false;

var bools = new Dictionary<string, bool>
{
     { $"{nameof(green)}", green}
    ,{ $"{nameof(red)}", red}
    ,{ $"{nameof(purple)}", purple}
    ,{ $"{nameof(orange)}", orange}
    ,{ $"{nameof(black)}", black}
    ,{ $"{nameof(blue)}", blue}
    ,{ $"{nameof(brown)}", brown}
};

Console.Write(string.Join("-", bools.Where(b => b.Value).Select(b => b.Key)));

布尔红=真；
布尔紫=真；
布尔橙色=假；
布尔黑=真；
布尔蓝=真；
布尔布朗=假；
var bools=新字典
{
{$“{nameof（绿色）}”，绿色}
，{$“{nameof（red）}”，red}
，{$“{nameof（紫色）}”，紫色}
，{$“{nameof（orange）}”，orange}
，{$“{nameof（black）}”，black}
，{$“{nameof（blue）}”，blue}
，{$“{nameof（brown）}”，brown}
};
Write（string.Join（“-”，bools.Where（b=>b.Value）。选择（b=>b.Key））；

我正在考虑使用字典进行配对

    static void Main(string[] args)
    {
        Dictionary<string, string> pair = new Dictionary<string, string>();

        pair.Add("green", "green");
        pair.Add("red", "redskiins");
        pair.Add("purple", "ravens");
        pair.Add("orange", "orange");
        pair.Add("black", "raiders");
        pair.Add("blue", "texans");
        pair.Add("brown", "brown");

        List<string> display = new List<string>();

        bool green = false;
        bool red = true;
        bool purple = true;
        bool orange = false;
        bool black = true;
        bool blue = true;
        bool brown = false;

        if (green)
            display.Add(pair["green"]);
        if (red)
            display.Add(pair["red"]);
        if (purple)
            display.Add(pair["purple"]);
        if (orange)
            display.Add(pair["orange"]);
        if (black)
            display.Add(pair["black"]);
        if (blue)
            display.Add(pair["blue"]);
        if (brown)
            display.Add(pair["brown"]);

        string finalStr = string.Join(" - ", display);
        Console.WriteLine(finalStr);

        Console.Read();
    }

static void Main（字符串[]args）
{
字典对=新字典（）；
配对。添加（“绿色”、“绿色”）；
配对。添加（“红色”、“红色”）；
配对。添加（“紫色”、“乌鸦”）；
添加（“橙色”、“橙色”）；
添加（“黑色”、“掠夺者”）；
添加（“蓝色”、“德克萨斯州”）；
添加（“棕色”、“棕色”）；
列表显示=新列表（）；
布尔绿=假；
布尔红=真；
布尔紫=真；
布尔橙色=假；
布尔黑=真；
布尔蓝=真；
布尔布朗=假；
如果（绿色）
显示。添加（成对[“绿色”]）；
如果（红色）
显示。添加（成对[“红色”]）；
if（紫色）
显示。添加（成对[“紫色”]）；
if（橙色）
显示。添加（成对[“橙色”]）；
if（黑色）
显示。添加（对[“黑色”]）；
如果（蓝色）
显示。添加（成对[“蓝色”]）；
如果（棕色）
显示。添加（成对[“棕色”]）；
string finalStr=string.Join（“-”，display）；
控制台写入线（finalStr）；
Console.Read（）；
}

输出：

---

我会这样做，使用一个索引到输入字符串（颜色）的字典和一个元组作为值：

        // Create your dictionary, indexed with the color, with a tuple as a value to describe
        // boolean state and matching string fragment
        var dictTeams = new Dictionary<string, Tuple<bool, string>>()
        {
            { "green", new Tuple<bool, string>(false, "packers") },
            { "red", new Tuple<bool, string>(true, "redskins") },
            { "purple", new Tuple<bool, string>(true, "ravens") },
            { "orange", new Tuple<bool, string>(false, "bears") },
            { "black", new Tuple<bool, string>(true, "raiders") },
            { "blue", new Tuple<bool, string>(true, "texans") },
            { "brown", new Tuple<bool, string>(false, "browns") }
        };

        // You can either initialize your dictionary all at once or fill it in later on.
        dictTeams.Add("white", new Tuple<bool, string>(true, "patriots"));

        // Select the keys of the entries marked true and aggregate them into a string.
        // Here you could also add a filter for only colors selected in another list by adding
        // a constraint in the Where clause using the key in addition to the boolean value.
        var outString = dictTeams.Where(c => c.Value.Item1)
                                 .Select(c => c.Value.Item2)
                                 .Aggregate((a, b) => a + " - " + b);

及

---

您是如何将字符串与之“关联”的？由于您需要检查每个布尔变量，因此简单的if（color）{}检查所有布尔变量将是最好的检查方法。首先，最好的方法是使用字典数据结构，其中键是字符串，值是bool。这样，您就可以在键上迭代。并将其添加到循环中的字符串中。@Guilherme我有一些要求，例如，如果“green”为true，则将“packer”添加到输出字符串中。我认为您应该像@mattwillkinson所说的那样，将其组织到某个集合结构中。我还建议使用字典，但前提是字符串没有重复（不同的值）。这是一个非常聪明、非常简洁的解决方案。真的很喜欢。我喜欢这种方法。

        // Create your dictionary, indexed with the color, with a tuple as a value to describe
        // boolean state and matching string fragment
        var dictTeams = new Dictionary<string, Tuple<bool, string>>()
        {
            { "green", new Tuple<bool, string>(false, "packers") },
            { "red", new Tuple<bool, string>(true, "redskins") },
            { "purple", new Tuple<bool, string>(true, "ravens") },
            { "orange", new Tuple<bool, string>(false, "bears") },
            { "black", new Tuple<bool, string>(true, "raiders") },
            { "blue", new Tuple<bool, string>(true, "texans") },
            { "brown", new Tuple<bool, string>(false, "browns") }
        };

        // You can either initialize your dictionary all at once or fill it in later on.
        dictTeams.Add("white", new Tuple<bool, string>(true, "patriots"));

        // Select the keys of the entries marked true and aggregate them into a string.
        // Here you could also add a filter for only colors selected in another list by adding
        // a constraint in the Where clause using the key in addition to the boolean value.
        var outString = dictTeams.Where(c => c.Value.Item1)
                                 .Select(c => c.Value.Item2)
                                 .Aggregate((a, b) => a + " - " + b);

dictTeams["green"].BoolState = false;

var outString = dictTeams.Where(c => c.Value.BoolState && lstUserColors.Contains(c.Key))
                         .Select(c => c.Value.StringFragment)
                         .Aggregate((a, b) => a + " - " + b);