Question

This question already has answers here:

Closed 11 years ago.

Possible Duplicate:
Is there an easy way to parse a (lambda expression) string into an Action delegate?

我愿将“拉姆布达”的表述储存在一个集邮档案中,并且以动态方式将这些示意图装入“C#”中的“玛目”。我的目标是混淆和注入规则。是否有任何公用事业可用以从护法中产生lam语吗?

是否有其他轻重解决办法实现同样的目标?

Answer 1

如果你事先知道这些表述的类型,那么你可以将其汇编成一类,然后从由此产生的大会中撤回。

这里有一个例子,它的确(用言词来扼杀和归还ool)并且管理由此产生的规则。

c. 系。 ::

file => file.Length == 0
file => System.IO.Path.GetExtension(file) == ".txt"
file => file == null

由此得出的产出是:

Rules found in file:
file => file.Length == 0,
file => System.IO.Path.GetExtension(file) == ".txt",
file => file == null,

Checking rule file => (file.Length == 0) against input c:	emp
ules.txt: False
Checking rule file => (GetExtension(file) == ".txt") against input c:	emp
ules.txt: True
Checking rule file => (file == null) against input c:	emp
ules.txt: False

资料来源:

using System;
using System.Xml.Linq;
using System.Linq;
using System.IO;
using Microsoft.CSharp;
using System.CodeDom.Compiler;
using System.Reflection;
using System.Linq.Expressions;

class Program
{
    private const string classTemplate = @"
            using System;
            using System.Linq.Expressions;

            public static class RulesConfiguration
            {{
                private static Expression<Func<string, bool>>[] rules = new Expression<Func<string, bool>>[]
                {{
                    {0}
                }};

                public static Expression<Func<string, bool>>[] Rules {{ get {{ return rules; }} }}
            }}
        ";

    static void Main(string[] args)
    {
        var filePath = @"c:	emp
ules.txt";
        var fileContents = File.ReadAllLines(filePath);

        // add commas to the expressions so they can compile as part of the array
        var joined = String.Join("," + Environment.NewLine, fileContents);

        Console.WriteLine("Rules found in file: 
{0}", joined);

        var classSource = String.Format(classTemplate, joined);

        var assembly = CompileAssembly(classSource);

        var rules = GetExpressionsFromAssembly(assembly);

        foreach (var rule in rules)
        {
            var compiledToFunc = rule.Compile();
            Console.WriteLine("Checking rule {0} against input {1}: {2}", rule, filePath, compiledToFunc(filePath));
        }
    }

    static Expression<Func<string, bool>>[] GetExpressionsFromAssembly(Assembly assembly)
    {
        var type = assembly.GetTypes().Single();
        var property = type.GetProperties().Single();
        var propertyValue = property.GetValue(null, null);
        return propertyValue as Expression<Func<string, bool>>[];
    }

    static Assembly CompileAssembly(string source)
    {
        var compilerParameters = new CompilerParameters()
        {
            GenerateExecutable = false,
            GenerateInMemory = true,
            ReferencedAssemblies =
            {
                "System.Core.dll" // needed for linq + expressions to compile
            },
        };
        var compileProvider = new CSharpCodeProvider();
        var results = compileProvider.CompileAssemblyFromSource(compilerParameters, source);
        if (results.Errors.HasErrors)
        {
            Console.Error.WriteLine("{0} errors during compilation of rules", results.Errors.Count);
            foreach (CompilerError error in results.Errors)
            {
                Console.Error.WriteLine(error.ErrorText);
            }
            throw new InvalidOperationException("Broken rules configuration, please fix");
        }
        var assembly = results.CompiledAssembly;
        return assembly;
    }
}

Answer 2

查阅。它是一个老的职位,但总是有用。

友情链接