Étant donné un Type C#, Obtenir de ses Classes de Base et mis en œuvre des Interfaces

Je suis en train de travailler sur un moteur de jeu en C#. La classe je suis en train de travailler sur est appelé CEntityRegistry, et son travail est de garder une trace du nombre d'instances de CEntity dans le jeu. Mon objectif est d'être en mesure d'interroger le CEntityRegistry avec un type donné, et d'obtenir une liste de chaque CEntity de ce type.

Ce que j'aimerais faire, donc, c'est de maintenir une carte:

private IDictionary<Type, HashSet<CEntity>> m_TypeToEntitySet;

Et de mettre à jour le registre ainsi:

private void m_UpdateEntityList()
        {
            foreach (CEntity theEntity in m_EntitiesToRemove.dequeueAll())
            {
                foreach (HashSet<CEntity> set in m_TypeToEntitySet.Values)
                {
                    if (set.Contains(theEntity))
                        set.Remove(theEntity);
                }
            }
            foreach (CEntity theEntity in m_EntitiesToAdd.dequeueAll())
            {
                Type entityType = theEntity.GetType();
                foreach (Type baseClass in entityType.GetAllBaseClassesAndInterfaces())
                  m_TypeToEntitySet[baseClass].Add(theEntity);

            }
        }

Le problème que j'ai c'est qu'il n'y a pas de fonction Type.GetAllBaseClassesAndInterfaces- Comment puis-je l'écrire?

  • mais vous ne voulez sûrement pas une instance d'un type à être compté comme une instance de tous les sous-types et les interfaces ainsi?
  • Apparemment, il n'.
  • Avez-vous considéré que l'utilisation de Type de.IsAssignableFrom(Type) peut faire de votre vie un peu plus simple que d'essayer de cartographier l'ensemble de la hiérarchie d'héritage de tous les CEntity? Pas sûr de ce que exactement comment exactement vous prévoyez sur l'utilisation du référentiel, mais il peut être quelque chose à regarder.
  • Je me demande si votre énergie ne serait pas mieux dépensé vous demander pourquoi cela est nécessaire et, s'il y a une approche plus directe qui ne nécessite pas de réflexion. Aussi, la tenue d'un dictionnaire de tous ces objets pourraient (si vous mettez en œuvre négligemment) les empêcher de jamais être nettoyés et provoquer une fuite de mémoire dans votre programme.
InformationsquelleAutor Mark P Neyer | 2009-12-01
  1. 8

    Type a une propriété BaseType et une méthode FindInterfaces.

    https://msdn.microsoft.com/en-us/library/system.type.aspx

    Donc en fait, il ne fait presque ont Type.GetAllBaseClassesAndInterfaces, mais vous avez à faire deux appels au lieu d'un.

    • Il veut répéter à travers la hiérarchie des types (d'Où GetAllBaseClass es), donc ce n'est pas simple.
    • Je suppose que je ne suis pas sûr de savoir si sa question était de savoir quelle méthode/propriété à utiliser, ou comment écrire une fonction qui va parcourir l'arborescence d'héritage. J'avais supposé de l'ancien.
    • Il peut être plus simple de faire de la CEntity constructeur s'inscrire avec le dictionnaire à la place. Ensuite, vous n'avez pas à la requête de l'arbre d'héritage pour chaque objet. L'utilisation lourde de la réflexion est souvent une indication que quelque chose est incorrect avec votre conception.
    InformationsquelleAutor Nate C-K
  2. 17

    Vous pourriez écrire une extension de la méthode comme ceci:

    public static IEnumerable<Type> GetBaseTypes(this Type type) {
    if(type.BaseType == null) return type.GetInterfaces();

    return Enumerable.Repeat(type.BaseType, 1)
                     .Concat(type.GetInterfaces())
                     .Concat(type.GetInterfaces().SelectMany<Type, Type>(GetBaseTypes))
                     .Concat(type.BaseType.GetBaseTypes());
}
    InformationsquelleAutor SLaks
  3. 6

    Plus raffinée de réponse basé sur l'un de SLaks serait:

    public static IEnumerable<Type> GetBaseClassesAndInterfaces(this Type type)
{
    return type.BaseType == typeof(object) 
        ? type.GetInterfaces()
        : Enumerable
            .Repeat(type.BaseType, 1)
            .Concat(type.GetInterfaces())
            .Concat(type.BaseType.GetBaseClassesAndInterfaces())
            .Distinct();
}
    InformationsquelleAutor dadhi
  4. 1

    Utiliser ce code:

    Func<Type, List<Type>> f = ty =>
{
    var tysReturn = new List<Type>();
    if (ty.BaseType != null)
    {
        tysReturn.Add(ty.BaseType);
    }
    tysReturn.AddRange(ty.GetInterfaces());
    return tysReturn;
};

    La fonction f prendra un Type et une liste de son type de base et à des interfaces.

    Espère que cela aide.

    InformationsquelleAutor CesarGon