如何搜索各种类型的属性

Question

我有一个名为Part 的基类和Wire 或Connector 等派生类，还有更多继承自Part 的类。

现在我想实现一个搜索函数，在派生类的所有属性中搜索字符串。

如有必要，应尝试将该字符串转换为属性的类型。属性也可以是列表，应该在第一级搜索。

class Part 
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Wire : Part
{
    public NumberWithUnit Diameter { get; set; }
    public Weight Weight { get; set; }
}

class Connector : Part
{
    public List<Part> ConnectedParts { get; set; }
}

我知道如何通过这样的反射来搜索基本类型的属性

private bool SearchProperties<T>(T part, string searchString) where T : Part
{
    var props = typeof(T).GetProperties();
    foreach (var prop in props)
    {
        var value = prop.GetValue(part);
        if (value is string)
        {
            if (string.Equals(value, searchString))
                return true;
        }
        else if (value is int)
        {
            int v;
            if (int.TryParse(searchString, out v))
            {
                if(v == (int) value)
                    return true;
            }
        }
    }
    return false;
}

但这将是一长串类型，例如，我有类型为 Weight 的属性等等。是否有某种通用的搜索方式而不需要转换所有类型？

Answer 1

考虑与您的转化相反。无需将搜索字符串转换为每个可能的值，只需将值转换为字符串即可：

private bool SearchProperties<T>(T part, string searchString) where T : Part
{
    var props = typeof(T).GetProperties();
    foreach (var prop in props)
    {
        var value = prop.GetValue(part);
        if (value is IEnumerable)
        {
            // special handling for collections
        }
        else if(value != null)
        {
            string valueString = value.ToString();
            if (string.Equals(valueString, searchString))
                return true;
        }
    }
    return false;
}

除了对大多数内置类型工作得很好之外，要让它对Weight 等工作，您唯一需要做的就是确保它们实现了ToString()。

另一种解决方案是使用 TypeDescriptor：

private bool SearchProperties<T>(T part, string searchString) where T : Part
{
    var props = typeof(T).GetProperties();
    foreach (var prop in props)
    {
        var value = prop.GetValue(part);
        if (value is IEnumerable)
        {
            // special handling for collections
        }
        else if(value != null)
        {
            object searchValue = null;
            try
            {
                searchValue = TypeDescriptor.GetConverter(value).ConvertFromString(searchString);
            } catch {}
            if (searchValue != null && object.Equals(value, searchValue))
                return true;
        }
    }
    return false;
}

TypeDescriptor 适用于大多数内置类型，但requires extra work 如果您正在处理自定义类型。

Answer 2

我认为以下应该涵盖大部分实际场景：

public static bool SearchProperties(object target, string searchString)
{
    if (target == null) return false;
    // Common types
    var convertible = target as IConvertible;
    if (convertible != null)
    {
        var typeCode = convertible.GetTypeCode();
        if (typeCode == TypeCode.String) return target.ToString() == searchString;
        if (typeCode == TypeCode.DBNull) return false;
        if (typeCode != TypeCode.Object)
        {
            try
            {
                var value = Convert.ChangeType(searchString, typeCode);
                return target.Equals(value);
            }
            catch { return false; }
        }
    }
    if (target is DateTimeOffset)
    {
        DateTimeOffset value;
        return DateTimeOffset.TryParse(searchString, out value) && value == (DateTimeOffset)target;
    }
    var enumerable = target as IEnumerable;
    if (enumerable != null)
    {
        // Collection
        foreach (var item in enumerable)
            if (SearchProperties(item, searchString)) return true;
    }
    else
    {
        // Complex type
        var properties = target.GetType().GetProperties();
        foreach (var property in properties)
        {
            if (property.GetMethod == null || property.GetMethod.GetParameters().Length > 0) continue;
            var value = property.GetValue(target);
            if (SearchProperties(value, searchString)) return true;
        }
    }
    return false;
}

Answer 3

我会给你一个不同的想法。

你可以试试这样的：

 private bool SearchProperties<T, W>(T part, W searchValue) where T : Part
   {
       var props = typeof(T).GetProperties();
       foreach (var prop in props)
       {
           if (typeof(W) == prop.PropertyType)
           {
               var value = prop.GetValue(part, null);

               if (searchValue.Equals(value))
                   return true;
           }
       }
       return false;
   }

你需要这样调用方法：

    private void button12_Click(object sender, EventArgs e)
    {
        Part p = new Part();
        p.Id = 2;
        p.Name = "test";
        p.bla = new Bla();

        SearchProperties<Part, int>(p, 2);
    }    

如果您需要通过与GetHashCode 不同的方式比较复杂属性（重量，...），您可以覆盖方法Equals 或== 运算符。

   class Weight
   {
       public int Id { get; set; }

       public override bool Equals(object obj)
       {
           return Id == ((Weight)obj).Id;
       }
   }