C# 避免使用Distinct从列表中写入文件的所有重复项，特定值除外

我想做什么

在从列表写入文件之前

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

List List=新列表（）；

我使用distinct以避免重复：

IEnumerable<string> sepStr = List.Distinct(); 

foreach (string StrExtractToFile in sepStr) 
{                       
     using (StreamWriter sw = File.AppendText(doc.txt))
           sw.WriteLine(StrExtractToFile);
}

IEnumerable sepStr=List.Distinct（）；
foreach（sepStr中的字符串StrExtractToFile）
{                       
使用（StreamWriter sw=File.AppendText（doc.txt））
sw.WriteLine（StrExtractToFile）；
}

但我想避免除了单词“border”之外的所有重复项。如果列表中存在，则必须将“border.”与重复项一起传递到文件中，必须避免其他重复项

---

我不确定，什么是一个适当的或正确的说更好的方式来做这件事。我不确定

String.Contains方法是否适合这种情况

您可以使用Linq来实现这一点，但我只需要使用一个快速循环

List<String> Str = new List<String>();
foreach (string s in SplitContList)
{
    if (s == "Border" || !Str.Contains(s))
        Str.Add(s);
}

List Str=newlist（）；
foreach（SplitContList中的字符串s）
{
如果（s==“Border”| |！Str.Contains（s））
Str.Add（s）；
}

---

如果字符串为“Border”或不在列表中，则可以将其添加到列表中。

您可以使用Linq执行此操作，但我只需要使用快速循环

List<String> Str = new List<String>();
foreach (string s in SplitContList)
{
    if (s == "Border" || !Str.Contains(s))
        Str.Add(s);
}

void Main()
{
    var items = new List<String>{"Brett", "James", "James", "Border", "Border", "John"};
    var distincts = items.Where(x => x != "Border").Distinct().ToList();
    var borders = items.Where(x => x == "Border").ToList();
    distincts.Concat(borders).ToList().ForEach(x => Console.WriteLine(x));
}

List Str=newlist（）；
foreach（SplitContList中的字符串s）
{
如果（s==“Border”| |！Str.Contains（s））
Str.Add（s）；
}

如果字符串为“Border”或不在列表中，则将其添加到列表中。

void Main（）
void Main()
{
    var items = new List<String>{"Brett", "James", "James", "Border", "Border", "John"};
    var distincts = items.Where(x => x != "Border").Distinct().ToList();
    var borders = items.Where(x => x == "Border").ToList();
    distincts.Concat(borders).ToList().ForEach(x => Console.WriteLine(x));
}

{
var items=新列表{“Brett”、“James”、“James”、“Border”、“Border”、“John”}；
var distincts=items.Where（x=>x！=“Border”）.Distinct（）.ToList（）；
var borders=items.Where（x=>x==“Border”）.ToList（）；
distincts.Concat（borders.ToList（）.ForEach（x=>Console.WriteLine（x））；
}

void Main（）
{
var items=新列表{“Brett”、“James”、“James”、“Border”、“Border”、“John”}；
var distincts=items.Where（x=>x！=“Border”）.Distinct（）.ToList（）；
var borders=items.Where（x=>x==“Border”）.ToList（）；
distincts.Concat（borders.ToList（）.ForEach（x=>Console.WriteLine（x））；
}

也许有一个优雅的LINQ解决方案我没有想到，但经典的解决方案也不难想到

List<string> results = new List<string>();
foreach(var s in SplitContList)
{
    if(!results.Contains(s) || s == "border.")
    {
        results.Add(s);
    }
}

列表结果=新列表（）；
foreach（SplitContList中的变量s）
{
如果（！results.Contains（s）| | s==“border.”）
{
结果：添加（s）；
}
}

也许有一个优雅的LINQ解决方案我没有想到，但经典的解决方案也不难想到

List<string> results = new List<string>();
foreach(var s in SplitContList)
{
    if(!results.Contains(s) || s == "border.")
    {
        results.Add(s);
    }
}

列表结果=新列表（）；
foreach（SplitContList中的变量s）
{
如果（！results.Contains（s）| | s==“border.”）
{
结果：添加（s）；
}
}

我选择@Elemental Pete只需一个改变就可以回答

var SplitContList = new List<string>();
        var Str = new List<String>();
        foreach (var s in SplitContList)
            if (s.Equals("border",StringComparison.InvariantCultureIgnoreCase)|| !Str.Contains(s))
                Str.Add(s);

var SplitContList=new List（）；
var Str=新列表（）；
foreach（SplitContList中的变量s）
如果（s.Equals（“border”，StringComparison.InvariantCultureIgnoreCase）| |！Str.Contains（s））
Str.Add（s）；

---

以防万一你不在乎以防万一

我选择@Elemental Pete，只要换一个答案

var SplitContList = new List<string>();
        var Str = new List<String>();
        foreach (var s in SplitContList)
            if (s.Equals("border",StringComparison.InvariantCultureIgnoreCase)|| !Str.Contains(s))
                Str.Add(s);

  var filteredList = SplitContList
                      .Where(c => c != "border")
                      .GroupBy(v => v)
                      .Select(group => group.First())
                      .Concat(SplitContList.Where(c => c == "border")).ToList();

var SplitContList=new List（）；
var Str=新列表（）；
foreach（SplitContList中的变量s）
如果（s.Equals（“border”，StringComparison.InvariantCultureIgnoreCase）| |！Str.Contains（s））
Str.Add（s）；

---

以防万一您不在乎case

您可以让您的自定义

IEqualityComparer

获得所需的行为：

  var filteredList = SplitContList
                      .Where(c => c != "border")
                      .GroupBy(v => v)
                      .Select(group => group.First())
                      .Concat(SplitContList.Where(c => c == "border")).ToList();

class CustomComparer : EqualityComparer<string>
{
    public override bool Equals(string x, string y)
    {
        if (x == "border" || y == "border") return false;
        return Default.Equals(x, y);
    }

    public override int GetHashCode(string obj)
    {
        return obj.GetHashCode();
    }
}

或者，您可以执行以下操作：

SplitContList.Select((w, i) => new { w, key = w == "border" ? i : 0 })
             .Distinct()
             .Select(x => x.w);

---

您可以自定义

IEqualityComparer

，以获得所需的行为：

class CustomComparer : EqualityComparer<string>
{
    public override bool Equals(string x, string y)
    {
        if (x == "border" || y == "border") return false;
        return Default.Equals(x, y);
    }

    public override int GetHashCode(string obj)
    {
        return obj.GetHashCode();
    }
}

或者，您可以执行以下操作：

SplitContList.Select((w, i) => new { w, key = w == "border" ? i : 0 })
             .Distinct()
             .Select(x => x.w);

---

我将使用另一个集合，它包含已附加的字符串并检入循环

List<string> List = new List<string>();
HashSet<string> alreadyUsed = new HashSet<string>();
using (StreamWriter sw = File.AppendText(doc.txt))
{
    foreach (string StrExtractToFile in List)
    {
        if (StrExtractToFile == "border" || !alreadyUsed.Contains(StrExtractToFile))
        {
            alreadyUsed.Add(StrExtractToFile);
            sw.WriteLine(StrExtractToFile);
        }
    }
}

List List=新列表（）；
HashSet alreadyUsed=新HashSet（）；
使用（StreamWriter sw=File.AppendText（doc.txt））
{
foreach（列表中的字符串StrExtractToFile）
{
if（StrExtractToFile==“border”| |！alreadyUsed.Contains（StrExtractToFile））
{
添加（StrExtractToFile）；
sw.WriteLine（StrExtractToFile）；
}
}
}

我将使用另一个集合，它包含已附加的字符串并检入循环

List<string> List = new List<string>();
HashSet<string> alreadyUsed = new HashSet<string>();
using (StreamWriter sw = File.AppendText(doc.txt))
{
    foreach (string StrExtractToFile in List)
    {
        if (StrExtractToFile == "border" || !alreadyUsed.Contains(StrExtractToFile))
        {
            alreadyUsed.Add(StrExtractToFile);
            sw.WriteLine(StrExtractToFile);
        }
    }
}

List List=新列表（）；
HashSet alreadyUsed=新HashSet（）；
使用（StreamWriter sw=File.AppendText（doc.txt））
{
foreach（列表中的字符串StrExtractToFile）
{
if（StrExtractToFile==“border”| |！alreadyUsed.Contains（StrExtractToFile））
{
添加（StrExtractToFile）；
sw.WriteLine（StrExtractToFile）；
}
}
}

订单重要吗？@taquion你好，是的，订单很重要。列表会一直更新，但必须保存订单。我一个字符串一个字符串地从一个列表写到另一个文件，同样地从一个文件写到另一个列表。顺序重要吗？@taquion你好，是的，顺序很重要。列表会一直更新，但必须保存订单。我一个字符串一个字符串地从一个列表写到另一个文件，同样的方式从一个文件写到另一个列表。@djangojazz答案也可以，但它枚举了两倍的列表，而这个（基本Pete的）答案只做了一次。Hello，我编辑了我的问题，因为它不清楚，所以似乎没有任何东西能满足我的需要，或者我做错了什么，只是check@djangojazz答案也有效，但它列举了两次列表而这个（基本皮特的）答案只列举了一次Hello，我已经编辑了我的问题，因为它不清楚，所以似乎没有任何东西能满足我的需要，或者我做错了什么，只需检查我尝试了两种方法，但它删除了写入文件的边框，不确定也许我做错了什么。我对我的问题进行了编辑，以使其更准确clear@nikorio：那么您希望根本不显示重复项？如果列表是

a，border，a，b，c，border，c，d

结果列表应该是什么？我尝试了两种方法，但它删除了写入文件的边框，不确定我是否做错了什么。我对我的问题进行了编辑，以使其更准确clear@nikorio：那么您希望根本不显示重复项？如果