Comment rechercher rapidement des objets de certaines classes ou classes enfants en C #

Si je comprends bien, si B hérite de A et que vous recherchez A, vous voulez également renvoyer tous les objets B.

Je le ferais de cette façon: Modifiez votre AddObject existant méthode pour ajouter l'objet à plusieurs collections. Vous pouvez utiliser la propriété Type.BaseType pour obtenir le type de base. Faites-le en boucle, jusqu'à ce que vous atteigniez la classe object .

public void AddObject(object obj) {
    Type type;
    do {
        type = obj.GetType();
        if (!objs.ContainsKey(type) {
            objs[type] = new List<object>();
        }
        objs[type] = obj;
        if(type == typeof(object)) break;
        type = type.BaseType;
    } while(true);
}

Vous devez vérifier que si la liste mise en cache contient un objet Assignable de type T . Essayez le code ci-dessous qui vérifie cette relation

public void AddObject(object obj)
{
    if (!objs.ContainsKey(obj.GetType()))
    {
        objs[obj.GetType()] = new List<object>() { obj };
    }
    else
    {
        objs[obj.GetType()].Add(obj);
    }
}

Je sais que votre code ci-dessus est juste pour illustrer le cas, mais il y a un bogue dans la fonction AddObject , vous enregistrer un objet plutôt qu'une liste, la fonction devrait être quelque chose comme ceci:

public List<object> GetObjectsOfType<T>()
{
   foreach (var pair in objs)
   {
      if (pair.Key == typeof(T) || typeof(T).IsAssignableFrom(pair.Key))
      {
         return pair.Value;
      }
   }

   return new List<object>();
}

Vous pouvez utiliser le Méthode Type.IsAssignableFrom pour déterminer quelles classes peuvent être affectées au générique.

Modifiez la méthode GetObjectsOfType comme suit:

objs[obj.GetType()].Add(obj);

Donc, ce que vous voulez, c'est quelque chose de similaire au dictionnaire. Essayons de le mettre en œuvre étape par étape. Mon code est fortement commenté, donc je vais laisser le code parler. En gros, tout ce que vous avez à faire est de laisser des miettes de pain en cours de route lorsque vous ajoutez votre objet dans votre porte-objet.

var a = new A();
var b = new B();
var c = new C();
var objectholder = new Objectholder();
objectholder.AddObject(a);
objectholder.AddObject(b);
objectholder.AddObject(c);
// Contains A and B and C
var allA = objectholder.GetObjectsOf<A>().ToArray();

Enfin, jetons un œil à ObjectHolder comme je l'imaginais. Le plus dur dans votre cas, je pense que vous n'avez pas gardé le principe de responsabilité unique et que vous avez essayé de tout faire en une seule fois.

 public class Objectholder
 {
    /// <summary>
    /// Holds Type vs object information.
    /// Each object is seperated into its own Type.
    /// </summary>
    private readonly ConcurrentDictionary<Type, List<object>> _dict = new ConcurrentDictionary<Type, List<object>>();

    /// <summary>
    /// I already explained about this class before so here I will pass.
    /// </summary>
    private readonly InheritanceInfo inheritanceInfo = new InheritanceInfo();

    /// <summary>
    /// Adds an object to ObjectHolder.
    /// </summary>
    /// <param name="obj">Object to add</param>
    public void AddObject(object obj) {
        _dict.AddOrUpdate(obj.GetType(), t => AddValueFactory(obj), (t, li) => UpdateValueFactory(obj, li));
    }

    /// <summary>
    /// Gets Objects which are assignable to type of T.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    public IEnumerable<T> GetObjectsOf<T>() {
        var tree = inheritanceInfo.GetAssignables(typeof(T)).Concat(new[] { typeof(T) });
        return tree.SelectMany(t => _dict[t]).Cast<T>();
    }

    /// <summary>
    /// Adds a value to dictionary.
    /// </summary>
    /// <param name="obj">Object to add.</param>
    /// <returns></returns>
    private List<object> AddValueFactory(object obj)
    {
        inheritanceInfo.Update(obj.GetType());
        var l = new List<object>();
        l.Add(obj);
        return l;
    }

    /// <summary>
    /// Updates a value in dictionary.
    /// </summary>
    /// <param name="obj">Object to add.</param>
    /// <param name="li">List of objects</param>
    /// <returns></returns>
    private List<object> UpdateValueFactory(object obj, List<object> li)
    {
        inheritanceInfo.Update(obj.GetType());
        li.Add(obj);
        return li;
    }
}

// Mock classes
public class A { }
public class B : A { }
public class C : B { }

L'utilisation de ObjectHolder code> correspond à ce que vous vouliez faire.

public class InheritanceInfo
{
    private class InheritanceChain
    {
        /// <summary>
        /// LinkedList which holds inheritance chain from least derived to most derived for a given Type.
        /// </summary>
        private readonly LinkedList<Type> _linkedList = new LinkedList<Type>();

        /// <summary>
        /// Creates an Inheritance chain for a given type which holds information about base types.
        /// </summary>
        /// <param name="t">Type for which inheritance chain will be created.</param>
        public InheritanceChain(Type t)
        {
            Type type = t;
            do
            {
                if (type == typeof(object))
                {
                    break;
                }
                _linkedList.AddFirst(type);
                type = type.BaseType;
            } while (true);
        }

        /// <summary>
        /// First element of LinkedList. This will be used for iteration.
        /// </summary>
        public LinkedListNode<Type> First => _linkedList.First;
    }

    /// <summary>
    /// Dictionary which holds Type vs DerivedTypes information. Basically does the all handling.
    /// </summary>
    private readonly ConcurrentDictionary<Type, SingleStepDerivedTypes> _inheritanceDictionary;

    /// <summary>
    /// InheritanceInfo class holds information about each Type's inheritance tree.
    /// Each Type holds information about one step down the inheritance tree.
    /// Example: public class C:B{}
    ///          public class B:A{}
    ///          public class A  {}
    /// Inheritance infor for class A holds info about only B because C is derived from B and
    /// it is not a direct descendant of A.
    /// </summary>
    public InheritanceInfo() {
        _inheritanceDictionary = new ConcurrentDictionary<Type, SingleStepDerivedTypes>();
    }

    /// <summary>
    /// Updates the given Type inheritance tree info.
    /// </summary>
    /// <param name="type"></param>
    public void Update(Type type) {
        var element = new InheritanceChain(type).First;
        while (element.Next != null) {
            _inheritanceDictionary.AddOrUpdate(element.Value, (_)=>AddValueFactory(element.Next.Value), (_,sdt)=>UpdateValueFactory(element.Next.Value,sdt));
            element = element.Next;
        }
    }

    /// <summary>
    /// Gets all the assignable types for the given type t.
    /// </summary>
    /// <param name="t">Type for which assignable types will be searched.</param>
    /// <returns>All the assignable types for Type t.</returns>
    public IEnumerable<Type> GetAssignables(Type t)
    {
        if(_inheritanceDictionary.TryGetValue(t ,out var derivedTypes) == false) {
            return Array.Empty<Type>();
        }
        var recursive = derivedTypes.GetTypes().SelectMany(tp=>GetAssignables(tp));
        return recursive.Concat(derivedTypes.GetTypes());
    }

    /// <summary>
    /// Add value to the dictionary
    /// </summary>
    /// <param name="t">Type to add to ConcurrentDictionary</param>
    /// <returns>SingleStepDerivedTypes which holds information about derived type t</returns>
    private static SingleStepDerivedTypes AddValueFactory(Type t) {
        var s = new SingleStepDerivedTypes();
        s.Add(t);
        return s;
    }

    /// <summary>
    /// Updates the already created SingleStepDerivedTypes object.
    /// </summary>
    /// <param name="t">Type to add</param>
    /// <param name="sdt">SingleStepDerivedTypes</param>
    /// <returns>Updated SingleStepDerivedTypes.</returns>
    private static SingleStepDerivedTypes UpdateValueFactory(Type t, SingleStepDerivedTypes sdt) {
        sdt.Add(t);
        return sdt;
    }
}



public class SingleStepDerivedTypes
{
    /// <summary>
    /// HashSet which holds information about derived Types.
    /// </summary>
    private readonly HashSet<Type> _singleStepDerivedTypes;

    /// <summary>
    /// Constructor ;)
    /// </summary>
    public SingleStepDerivedTypes() {
        _singleStepDerivedTypes = new HashSet<Type>();
    }

    /// <summary>
    /// Adds a Type to the Derived Type information.
    /// </summary>
    /// <param name="type">Type to add.</param>
    public void Add(Type type) {
        _singleStepDerivedTypes.Add(type);
    }

    /// <summary>
    /// Gets the contained information about types.
    /// </summary>
    /// <returns>IEnumerable of Types contained in this object.</returns>
    public IEnumerable<Type> GetTypes() {
        return _singleStepDerivedTypes;
    }
}