找到一种重用我的功能的方法，该功能以一种小的方式变化

Question

所以我正在编写一个 C# 应用程序，使用 .net/c# 4.0 我有一个接受自定义类型和字典的方法。 我将它重用于各种事情，但由于某种原因，我想不出一种封装逻辑的方法。问题是这一行

    if (FastIntParse.FastParse(_dict[_Rule.Key].hourly_data[a].PropertyA) > 
_Rule.Value)

在另一个用途中它可能是

    if (FastIntParse.FastParse(_dict[_Rule.Key].hourly_data[a].PropertyB) > 
_Rule.Value)

在各种情况下唯一不同的是我用来与规则值进行比较的属性。出于某种原因，我想不出一种方法来重用它，因为我没有传递给某个函数的值，因为该值是在函数中派生的。我如何编写一个函数来抽象它需要知道它需要派生哪个值并将该信息传递给它，即传递它需要检查的属性而不是所述属性的值。

    int a;
    for (int z= 0;z<=2;z++)
    {
    a = (z * z) * 24;
    for (; (a%24) <= _Rule.AlertEndTime; a++)
    {
        if (FastIntParse.FastParse(_dict[_Rule.Key].hourly_data[a].PropertyA) >
 _Rule.Value)
        {

            EnqueueRuleTrigger(_Rule);
            break;
        }
    }
    }

我不断地在需要的地方用适当的属性重写这个方法......这显然是非常浪费的，并且需要在许多地方进行任何更改。 提前致谢

Answer 1

您可以使用表达式，然后在方法中提取属性，然后使用反射将其绑定到方法中的对象

class Program
{
    static void Main(string[] args)
    {
        List<PropertyBag> bags = new List<PropertyBag>()
                                     {
                                         new PropertyBag() {Property1 = 1, Property2 = 2},
                                         new PropertyBag() {Property1 = 3, Property2 = 4}
                                     };

        Runme(x => x.Property1, bags);
        Runme(x => x.Property2, bags);

        Console.ReadLine();


    }

    public static void Runme(Expression<Func<PropertyBag, int>> expression, List<PropertyBag> bags)
    {
        var memberExpression = expression.Body as MemberExpression;
        var prop = memberExpression.Member as PropertyInfo;

        bags.ForEach( bag => 
                Console.WriteLine(prop.GetValue(bag, null))
            );
    }
}


public class PropertyBag
{
    public int Property1 { get; set; }
    public int Property2 { get; set; }
}

}

Answer 2

要解决访问不同属性和使用不同布尔函数（、==）的问题，您可以使用如下委托：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

namespace ConsoleApplication1
{
    delegate bool CompareFunction(Fii test, Foo item);

    class Program
    {
        static List<Foo> list = new List<Foo>() {
            new Foo() { PropertyA = 0, PropertyB = 9 },
            new Foo() { PropertyA = 1, PropertyB = 10 }
        };
        static Fii test = new Fii() { PropertyA = 1 };

        static void Main(string[] args)
        {
            Bar(list, delegate(Fii item1, Foo item2) { return item2.PropertyA < item1.PropertyA; });
            Bar(list, delegate(Fii item1, Foo item2) { return item2.PropertyB > item1.PropertyA; });
            Bar(list, delegate(Fii item1, Foo item2) { return item2.PropertyA == item1.PropertyA; });
            Console.ReadLine();
        }

        static void Bar(List<Foo> list, CompareFunction cmp)
        {
            foreach (Foo item in list)
                if (cmp(test, item))
                    Console.WriteLine("true");
                else
                    Console.WriteLine("false");
        }
    }

    class Foo
    {
        public int PropertyA { get; set; }
        public int PropertyB { get; set; }
    }

    class Fii
    {
        public int PropertyA { get; set; }
    }
}

Answer 3

让你的函数接受一个 lambda 参数并将其传递给 _ => _.PropertyA、_ => _.PropertyB 等：

void CheckAndEnqueueRulesByProperty (Func<YourObject, string> propertyGetter)
{
    ...
    if (FastIntParse.FastParse (propertyGetter (
            _dict[_Rule.Key].hourly_data[a])) > _Rule.Value)
    {
        ...
    }
    ...
}

如果您要使用相同的逻辑检查多种类型的对象，请将此函数设为通用。