C#递归地在对象中进行通用搜索[重复]

Question

我正在尝试编写一个用于所有对象的通用搜索。 我有这段代码，它可以很好地搜索一个对象的属性，但我也想搜索相关对象的属性。

例如。我有这些模型/对象

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    public string Address{ get; set; }

    public ICollection<Contract> Contracts { get; set; }
}
public class Contract
{
    public int Id { get; set; }
    public DateTime From{ get; set; }
    public DateTime To{ get; set; }
    public string Comment{ get; set; }
    public int CustomerId { get; set; }

    [ForeignKey("CustomerId")]
    public Customer Customer { get; set; }
}

我想搜索是否有任何属性包含一些字符串，例如。 “彼得”，我会这样称呼它：

string searchString = "Peter";
var customers = db.Customers
    .Include(x => x.Contracts)
    .WhereAnyPropertiesOfSimilarTypeContains(searchString);

此代码将检查“客户”的任何属性是否包含字符串“彼得”。 但我还需要检查相关模型“合同”是否包含“彼得。

public static class EntityHelper
    {
        public static IQueryable<TEntity> WhereAnyPropertiesOfSimilarTypeContains<TEntity, TProperty>(this IQueryable<TEntity> query, TProperty value)
        {
            var param = Expression.Parameter(typeof(TEntity));

            var predicate = PredicateBuilder.False<TEntity>(); //--- True to equal
            var entityFields = GetEntityFieldsToCompareTo<TEntity, TProperty>();
            foreach (var fieldName in entityFields)
            {
                MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });

                var predicateToAdd = Expression.Lambda<Func<TEntity, bool>>(
                    Expression.Call(
                        Expression.PropertyOrField(param, fieldName), method,
                        Expression.Constant(value)), param);

                predicate = predicate.Or(predicateToAdd);  //--- And to equal
            }

            return query.Where(predicate);
        }

        // TODO: You'll need to find out what fields are actually ones you would want to compare on.
        //       This might involve stripping out properties marked with [NotMapped] attributes, for
        //       for example.
        public static IEnumerable<string> GetEntityFieldsToCompareTo<TEntity, TProperty>()
        {
            Type entityType = typeof(TEntity);
            Type propertyType = typeof(TProperty);

            var fields = entityType.GetFields()
                                .Where(f => f.FieldType == propertyType)
                                .Select(f => f.Name);

            var properties = entityType.GetProperties()
                                    .Where(p => p.PropertyType == propertyType)
                                    .Select(p => p.Name);

            return fields.Concat(properties);
        }
    }

谢谢。

Answer 1

重读问题后。我不知道你在尝试什么，但我在这里提出了我有你在寻找什么的想法。

public class Customer : AbstractEntity
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    public string Address { get; set; }

    public ICollection<Contract> Contracts { get; set; }
}
public class Contract : AbstractEntity
{

    //what property here can be string "Peter"? Comments?
    //what are you trying?

    public int Id { get; set; }
    public DateTime From { get; set; }
    public DateTime To { get; set; }
    public string Comment { get; set; }
    public int CustomerId { get; set; }

    [ForeignKey("CustomerId")]
    public Customer Customer { get; set; }
}

public abstract class AbstractEntity
{

    //this method can be used to preselect properties you want
    protected virtual Tuple<bool, ICollection<PropertyInfo>> PropertyCollector()
    {
        return new Tuple<bool, ICollection<PropertyInfo>>(false, null);
    }

    public IEnumerable<Tuple<Type, object>> GetRowValues()
    {
        foreach (var prop in GetRows())
        {
            yield return new Tuple<Type, object>(prop.PropertyType, prop.GetValue(this));
        }
    }

    public ICollection<PropertyInfo> GetRows()
    {

        var tuple = PropertyCollector();

        ISet<PropertyInfo> pInfo;

        if (tuple.Item1)
        {
            pInfo = new HashSet<PropertyInfo>(tuple.Item2);
        }
        else //search all non virtual, private, protected properties, "following POCO scheme"
        {
            pInfo = new HashSet<PropertyInfo>();

            foreach (var prop in GetType().GetProperties())
            {
                foreach (var access in prop.GetAccessors())
                {
                    if ((!access.IsVirtual && !access.IsPrivate) && (prop.CanWrite && prop.CanRead))
                    {
                        pInfo.Add(prop);
                    }
                }
            }
        }
        return pInfo;
    }
}


public static class Searchs
{

    public static ICollection<object> ObjectsWithStringFound(ICollection<Customer> customers, string toBeFound)
    {

        var objs = new List<object>();

        foreach (var cust in customers)
        {
            var strings = cust.GetRowValues().Where(tpl => tpl.Item1 == typeof(string)).Select(tpl => tpl.Item2);
            var contracts = cust.GetRowValues().Where(tpl => tpl.Item2 is IEnumerable<Contract>).Select(tpl => tpl.Item2);

            if (strings.Any(str => str == toBeFound))
            {
                objs.Add(cust);
            }
            else if (contracts.Any(ctr => ((IEnumerable<Contract>)ctr).!!!!!!!!! == toBeFound))
            { //What I suppose I must "match" with "Peter"??!?!
                objs.Add(contracts.First(ctr => ((IEnumerable<Contract>)ctr).!!!!!!!!! == toBeFound));
            }

        }

        return objs;

    }
}

我认为我们彼此不理解。