LINQ causing my obfuscator to break

Question

I have the following LINQ that is causing my obfuscator to break.

.Where(f => f.FileName == fileName).OrderByDescending(f => f.Position).FirstOrDefault();

Is there another way I could reword this LINQ statement to test against my obfuscator?

I've reported the bug, but it could take 1-2 months to fix, so I need to try recode this LINQ in the meantime.

Update:

The exact cause in the LINQ is :

.Where(f => f.FileName == fileName)

Answer 1

How exactly does the problem manifest? Since the C# expression compiler (used in the LINQ above) uses the memberinfo tokens directly (rather than relying on strings as reflection), I can't see that you could do any better. Likewise, assuming it is an IL obfuscator (not a source obfuscator), re-writing it as a query expression should achieve nothing, nix, zip, zero and nada. You you can try...

var first = (from f in [whatever]
             where f.FileName == fileName
             orderby f.Position descending
             select f).FirstOrDefault();

What exactly happens?

---

Edit based on comment: if the problem is the "capture", you could try manually building the expression with a constant (instead of a captured value) - where Foo is your type:

    var param = Expression.Parameter(typeof(Foo), "f");
    var body = Expression.Equal(Expression.PropertyOrField(param, "FileName"),
        Expression.Constant(filename));
    var predicate = Expression.Lambda<Func<Foo, bool>>(body, param);

then use:

    .Where(predicate).OrderByDescending(f => f.Position).FirstOrDefault();

The problem, of course, is convincing it that "FileName" and Foo.FileName must stay the same...

---

And here's a version that doesn't need the string:

    Expression<Func<Foo, string>> liftFileName = foo => foo.FileName;
    var predicate = Expression.Lambda<Func<Foo, bool>>(
        Expression.Equal(liftFileName.Body, Expression.Constant(filename)),
        liftFileName.Parameters);

Answer 2

In the presence of a broken tool, it is impossible to provide a guaranteed fix. You'll have to tinker with it. Try swapping Where and OrderBy.... Perhaps FirstOrDefault() is breaking, so maybe do that part by hand. In fact, even OrderBy... can probably be replace with a sort. There's a bunch of other stuff you could try.

BTW, Is this LINQ-to-SQL or LINQ-to-Objects? They behave in fundamentally different ways.

Answer 3

The solution would be to exlcude the .FileName and .Position properties from obfuscation(renaming).

To avoid having to do this on every query, switch to an obfuscator which supports LINQ-to-* such as Crypto Obfuscator.