从对象检查linq委托函数

我试图找到可以替换的对象列表

Class Letter{
int ID;
string Name;
string AdvCode;
int isDeleted;
}

Class Replacers{
int ID;
string MainAdvCode;
string ReplacesAdvCode;
}

示例数据：

替代者

0455400

1955400

2955455

LettersA
0 pack 455
1 addon 400

LettersB
0 big 955
1 pack 455

LettersC
0 addon 400
1 big   955
2 pack 455

LettersD
0 pack 455
1 none 019

solution: 
LetterA 1 isDeleted
LeterB 1 isDeleted
LetterC 0 and 2 isDeleted
LetterD --- 

这样，如果一封信的Advcode为455，而另一封信的Advcode为400，则400将被标记为删除。然后，如果另一个字母有955，则455标记为删除，400（已标记）标记为删除

问题是我当前的代码400和455正在标记为删除

Public class Main{
List<Letter> Letters;
List<Replacers> replaces;

   //select the ones to replace the replacements aka the little guys

   //check if the replacements replacer exists if yes mark deleted

   var filterMethodReplacements = new Func<Letter, bool>(IsAdvInReplacements);//Working

   var filterMethodReplacers = new Func<Letter, bool>(IsAdvInReplacers);//NOT WORKING????

   var resReplacements=letters.Where(filterMethodReplacements);//working

   foreach (Letter letter in resReplacements)
   {
         //select the Replacers aka the ones that contain the little guys

        var resReplacers = letters.Where(filterMethodReplacers);

        if (resReplacers != null)

             letter.isDeleted = 1;
    }

        private bool IsAdvInReplacements(Letter letter)
        {
            return (from a in Replacables where a.ReplaceAdvCode == letter.AdvCode select a).Any();
        }
        private bool IsAdvInReplacers(Letter letter)
        {
            //??????????????????????????????
            return (from a in Replacables where a.MainAdvCode == letter.AdvCode select a).Any();
        }
}

公共类主{
列出信件；
列表替换；
//选择要替换的，也就是小家伙
//检查替换是否存在如果是标记已删除
var filterMethodReplacements=新函数（IsAdvInReplacements）；//正在工作
var filterMethodReplacers=new Func（IsAdvInReplacers）；//不工作？？？？
var resReplacements=letters.Where（filterMethodReplacements）；//正在工作
foreach（替换字母）
{
//选择替换者，也就是那些包含小家伙的人
var resreplaces=字母。其中（filtermethodreplaces）；
if（resReplacers！=null）
字母.isDeleted=1；
}
私人职业介绍所（信函）
{
返回（从中的a返回，其中a.ReplaceAdvCode==letter.AdvCode选择a）.Any（）；
}
私人书房（信件）
{
//??????????????????????????????
返回（从a中的a返回，其中a.MainAdvCode==letter.AdvCode选择a）.Any（）；
}
}

见下文，解决方案是按名称分组，然后迭代替换

    public class Letter
    {
        public int ID;
        public string Name;
        public string AdvCode;
        public string Type;
        public Boolean isDeleted;

        public override string ToString()
        {
            return this.Name + "[" + this.ID + "]" + ":" + this.Type + " AdvCode=" + AdvCode + " Deleted: " +  this.isDeleted.ToString();
        }
    }

    public class Replacers
    {
        public int ID;
        public string MainAdvCode;
        public string ReplacesAdvCode;
    }

class Program
{

static void Main(string[] args)
    {
        List<Letter> letters = GetLetters();
        List<Replacers> replacables = GetReplacers();



        foreach (IGrouping<string, Letter> g in letters.GroupBy(x => x.Name))
        {
            List<Letter> byName = g.ToList();


            foreach (Replacers r in replacables)
            {
                if (byName.Any(x => x.AdvCode == r.MainAdvCode) && byName.Any(x=>x.AdvCode==r.ReplacesAdvCode))
                {
                    //If we contain the code to replace...
                    foreach (Letter letter in byName.Where(x=>x.AdvCode==r.ReplacesAdvCode)){
                        letter.isDeleted = true;
                    }
                }
            }
        }

        Console.WriteLine("Result");
        foreach (Letter l in letters.Where(x=>x.isDeleted))
        {
            Console.WriteLine(l.ToString());
        }
        Console.WriteLine("Press key to close");
        Console.ReadKey();

  }

    public static List<Letter> GetLetters()
    {
        List<Letter> letters = new List<Letter>(){
            new Letter(){
                Name = "LettersA",
                ID = 0,
                AdvCode="455",
                Type="pack",
                isDeleted = false
            },
            new Letter(){
                Name = "LettersA",
                Type="addon",
                ID = 1,
                AdvCode="400",
                isDeleted = false
            },
              new Letter(){
                Name = "LettersB",
                ID = 0,
                AdvCode="955",
                Type="big",
                isDeleted = false
            },
            new Letter(){
                Name = "LettersB",
                Type="pack",
                ID = 1,
                AdvCode="455",
                isDeleted = false
            },
              new Letter(){
                Name = "LettersC",
                ID = 0,
                AdvCode="400",
                Type="addon",
                isDeleted = false
            },
            new Letter(){
                Name = "LettersC",
                Type="big",
                ID = 1,
                AdvCode="955",
                isDeleted = false
            },
             new Letter(){
                Name = "LettersC",
                Type="pack",
                ID = 2,
                AdvCode="455",
                isDeleted = false
            },
              new Letter(){
                Name = "LettersD",
                ID = 0,
                AdvCode="455",
                Type="pack",
                isDeleted = false
            },
            new Letter(){
                Name = "LettersD",
                Type="none",
                ID = 1,
                AdvCode="019",
                isDeleted = false
            },
        };

        return letters;

    }

    public static List<Replacers> GetReplacers()
    {
        return new List<Replacers>(){
            new Replacers(){
                ID = 0,
                MainAdvCode = "455",
                ReplacesAdvCode = "400"
            },
            new Replacers(){
                ID = 1,
                MainAdvCode = "955",
                ReplacesAdvCode = "400"
            },
            new Replacers(){
                ID = 2,
                MainAdvCode = "955",
                ReplacesAdvCode = "455"
            },
        };
    }

公开课信函
{
公共int ID；
公共字符串名称；
公共字符串代码；
公共字符串类型；
删除公共布尔值；
公共重写字符串ToString（）
{
返回此.Name+“[”+this.ID+“]“+”：“+this.Type+”AdvCode=“+AdvCode+”已删除：“+this.isDeleted.ToString（）”；
}
}
公共类替换程序
{
公共int ID；
公共字符串代码；
公共字符串替换SADVCODE；
}
班级计划
{
静态void Main（字符串[]参数）
{
列出字母=GetLetters（）；
List replaces=GetReplacers（）；
foreach（用字母对g进行分组。GroupBy（x=>x.Name））
{
按名称列出=g.ToList（）；
foreach（电缆中的替换件）
{
if（byName.Any（x=>x.AdvCode==r.MainAdvCode）&&byName.Any（x=>x.AdvCode==r.ReplacesAdvCode））
{
//如果我们包含要替换的代码。。。
foreach（byName.Where中的字母（x=>x.AdvCode==r.ReplacesAdvCode））{
letter.isDeleted=真；
}
}
}
}
控制台。写入线（“结果”）；
foreach（字母l，其中（x=>x.isDeleted））
{
Console.WriteLine（l.ToString（））；
}
控制台。写入线（“按键关闭”）；
Console.ReadKey（）；
}
公共静态列表GetLetters（）
{
列表字母=新列表（）{
新信（）{
Name=“lettsa”，
ID=0，
AdvCode=“455”，
Type=“pack”，
isDeleted=false
},
新信（）{
Name=“lettsa”，
Type=“addon”，
ID=1，
AdvCode=“400”，
isDeleted=false
},
新信（）{
Name=“LettersB”，
ID=0，
AdvCode=“955”，
Type=“big”，
isDeleted=false
},
新信（）{
Name=“LettersB”，
Type=“pack”，
ID=1，
AdvCode=“455”，
isDeleted=false
},
新信（）{
Name=“LettersC”，
ID=0，
AdvCode=“400”，
Type=“addon”，
isDeleted=false
},
新信（）{
Name=“LettersC”，
Type=“big”，
ID=1，
AdvCode=“955”，
isDeleted=false
},
新信（）{
Name=“LettersC”，
Type=“pack”，
ID=2，
AdvCode=“455”，
isDeleted=false
},
新信（）{
Name=“LettersD”，
ID=0，
AdvCode=“455”，
Type=“pack”，
isDeleted=false
},
新信（）{
Name=“LettersD”，
Type=“无”，
ID=1，
AdvCode=“019”，
isDeleted=false
},
};
回信；
}
公共静态列表GetReplacers（）
{
返回新列表（）{
新的替代者（）{
ID=0，
MainAdvCode=“455”，
ReplacesAdvCode=“400”
},
新的替代者（）{
ID=1，
MainAdvCode=“955”，
ReplacesAdvCode=“400”
},
新的替代者（）{
ID=2，
MainAdvCode=“955”，
ReplacesAdvCode=“455”
},
};
}

你的事情太简单了……你为什么要做所有的函数？还有其他的？这是我能想到的解决这个问题的最简单的方法。我只想用最简单的方法解决这个问题。非常感谢你的帮助。谢谢。我不懂这句话例如，如果一个字母的Advcode为455，另一个字母的Advcode为400，请给出一些字母数据集的示例。