Search text file and compare with others

You can even do with LINQ, either using Query Syntax or Method Syntax (which you called lambda), for the sake of readability, I prefer Query Syntax .

var lista = new List<string> {
    "odo_prs003a.asp",
    "odo_gen0067b.asp",
    "gen0001.js",
    "estilo.css"
};

var lfixa = new List<string> {
    "odo_prs003a.asp",
    "cmc002a.asp",
    "cmc0067d.asp",
    "odo_gen0067b.asp",
    "gen0001.js",
    "ass0000.asp",
    "calendar-br.js",
    "css002c.css",
};

var delQuery = 
    from item in lista
    join fixo in lfixa on item equals fixo into ljoin
    from test in ljoin.DefaultIfEmpty()
    where test == null
    select item;

var delMethod = lista
    .GroupJoin(lfixa, item => item, fixo => fixo, (item, fixo) => new { item, fixo })
    .SelectMany(list => list.fixo.DefaultIfEmpty(), (list, fixo) => new { list.item, fixo })
    .Where(list => list.fixo == null)
    .Select(list => list.item);

var delClasico = new List<string>();        
foreach (var item in lista)
{
    if (!lfixa.Contains(item))
    {
        delClasico.Add(item);
    }           
}

foreach (var item in delQuery)
{
    Console.WriteLine(item);
}

foreach (var item in delMethod)
{
    Console.WriteLine(item);
}

foreach (var item in delClasico)
{
    Console.WriteLine(item);
}

In the above example, I search by using Query Syntax (I store the return in delQuery ), Method Syntax (I store the return in delMethod ) and using a conventional loop ).

Note that delClasico adds unnecessary complexity, Method Syntax has exactly the same cost, but does it in a more elegant way.

However, I do not see an advantage in using Query Syntax instead of a good old for loop, either by performance, readability, or some other hidden reason.

As I see you are trying to compare two file structures, I will give you an implementation ... It gets two paths, then compares all the files with the same name ... identifying all the files that only protect a structure files, and the files that belong to the two structures, but are not identical:

public class Arquivo
{
    public string Path { get; set; }
    public string Nome { get; set; }
    public string NomeCompleto { get { return this.Path + this.Nome; } }
    public byte[] Hash { get; set; }
}

.

static void CompararPastas(string origemPath, string destinoPath)
{
    var arquivosOrigem = new List<Arquivo>();
    var arquivosDestino = new List<Arquivo>();

    var pastaOrigem = new DirectoryInfo(origemPath);
    var pastaDestino = new DirectoryInfo(destinoPath);

    LerPasta(pastaOrigem, origemPath, ref arquivosOrigem);
    LerPasta(pastaDestino, destinoPath, ref arquivosDestino);

    var somenteOrigem =
        from arquivoOrigem in arquivosOrigem
        join arquivoDestino in arquivosDestino on arquivoOrigem.NomeCompleto equals arquivoDestino.NomeCompleto into notInDestino
        from arquivoDestino in notInDestino.DefaultIfEmpty()
        where arquivoDestino == null
        select arquivoOrigem;

    foreach (var arquivo in somenteOrigem)
    {
        //arquivo não presente no destino, você pode copiar o mesmo para a origem.
    }

    var somenteDestino =
        from arquivoDestino in arquivosDestino
        join arquivoOrigem in arquivosOrigem on arquivoDestino.NomeCompleto equals arquivoOrigem.NomeCompleto into notInOrigem
        from arquivoOrigem in notInOrigem.DefaultIfEmpty()
        where arquivoOrigem == null
        select arquivoDestino;

    foreach (var arquivo in somenteDestino)
    {
        //arquivo não presente na origem, você pode apagar o mesmo para o destino.
    }

    var modificados =
        from arquivoOrigem in arquivosOrigem
        join arquivoDestino in arquivosDestino on arquivoOrigem.NomeCompleto equals arquivoDestino.NomeCompleto
        where arquivoOrigem.Hash != arquivoDestino.Hash
        select arquivoOrigem;

    foreach (var arquivo in modificados)
    {
        //arquivo na origem é diferente do arquivo no destino, você pode substituir o arquivo da origem pelo destino;
    }
}

static void LerPasta(DirectoryInfo pasta, string basePath, ref List<Arquivo> arquivos)
{
    foreach (var subPasta in pasta.GetDirectories())
    {
        LerPasta(subPasta, basePath, ref arquivos);
    }

    foreach (var arquivo in pasta.GetFiles())
    {
        LerArquivo(arquivo, basePath, ref arquivos);
    }
}

static void LerArquivo(FileInfo arquivo, string basePath, ref List<Arquivo> arquivos)
{
    var file = new Arquivo();
    file.Path = arquivo.DirectoryName.Replace(basePath, string.Empty);
    file.Nome = arquivo.Name;
    using (var lobjLeitura = arquivo.OpenRead())
    {
        using (var lobjSha512 = new SHA256Managed())
        {
            file.Hash = lobjSha512.ComputeHash(lobjLeitura);
        }
    }
    arquivos.Add(file);
}

You can use the Except method. In the following code, the variable resultado will store the records that are not present in the _fixo list. If you want the result to be the records that exist in common in both lists, you can use the Intersect method.

var resultado = _recebido.Except(_fixo);

See working at Ideone