2

简短版：代码中的注释是否正确？我认为它们是不正确的，应该颠倒过来。

public Type GetTestClass(Object left, Object right)
{
    if (left == null || right == null) return null;

    Type leftClass = left.GetType();
    Type rightClass = right.GetType();
    Type testClass;
    if (leftClass.IsInstanceOfType(right))
    {
        testClass = leftClass;
        if (!rightClass.IsInstanceOfType(left))
        {
            // rightClass is a subclass of leftClass
            testClass = rightClass;
        }
    }
    else if (rightClass.IsInstanceOfType(left))
    {
        testClass = rightClass;
        if (!leftClass.IsInstanceOfType(right))
        {
            // leftClass is a subclass of rightClass
            testClass = leftClass;
        }
    }
    else
    {
        // The two classes are not related.
        testClass = null;
    }

return testClass;
}

我在我正在处理的代码库中遇到了这段代码，我认为注释不正确。我相信评论//rightClass is a subclass of leftClass和//leftClass is a subclass of rightClass不正确。例如，如果leftClass是类型Object并且rightClass是类型MyClass（从 Object 继承），那么这就是我认为代码的工作方式......

  1. ObjectMyClass是 FALSE的一个实例
  2. MyClassObject是 TRUE的一个实例
  3. testClass被设定为MyClass
  4. NOT（是 FALSEObject的一个实例MyClass）是 TRUE
  5. testClass被设定为Object
  6. testClass返回 which ==Object

我相信这是正确的功能......最终代码试图返回两个类的超级类（你也可以说是公共基类），或者如果它们不相关，则返回 null。使用上面的示例（步骤 1-5）实际上是否正确地说 leftClass 是 rightClass 的 SUPER 类...或者反过来说 rightClass 是 leftClass 的 SUBCLASS？

4

2 回答 2

1

leftClass.IsInstanceOfType(right)意思是“右为左”。rightClass.IsInstanceOfType(left)意思是“左是右”。

如果右边是左边，但左边不是右边，那么左边一定是超类，右边一定是子类。这相当于第一种情况，您有注释“rightClass 是 leftClass 的子类”。所以，看起来评论的意图实际上是准确的。

但是，我发现该方法存在一些问题。评论是您最不必担心的事情。

  1. NullReferenceException如果任一参数为空，它将抛出。

  2. 它对 进行了不必要的调用GetType()，因为 的实际源代码IsInstanceOfType如下所示：

    public virtual bool IsInstanceOfType(object o)
{
    if (o == null)
    {
        return false;
    }
    return this.IsAssignableFrom(o.GetType());
}

    您应该接受@pswg 的建议并使用IsAssignableFrom，并可能考虑重构签名比较两个类型而不是两个对象。

  3. 任何两种具体类型总是至少有一个共同的基本类型System.Object. 此处返回 null 不是可接受的结果。

  4. 它不处理一种类型不是从另一种类型线性派生的情况，但两者仍然有一个比System.Object. 例如，

    public class Base { }

public class A : Base { }

public class B : Base { }

    您的方法会说A并且B是不相关的并返回 null，正确的“公共基础”将是Base.

我会查看Easest way to get a common base class from a collection of types提供的实现，它仍然不完美，但比您发布的要好。

更新：工作代码

我决定不吝啬，我已经在下面发布了我为此目的使用的方法。祝你好运。

    /// <summary> Finds the most derived common base class of all the provided types, or System.Object if there is no common base class  </summary>
    public static Type CommonBaseClass(params Type[] types)
    {
        if(ReferenceEquals(types,null)) return typeof(object);
        types = types.Where(x => !ReferenceEquals(x,null)).Distinct().ToArray();
        switch (types.Length)
        {
            case 0: return typeof(object);
            case 1: return types[0].IsInterface ? typeof(object): types[0];
            default:
                IEnumerable<IEnumerable<Type>> hierarchies = types.Select(ClassHierarchy).OrderBy(x => x.Count());
                Queue<Type> smallest = new Queue<Type>(hierarchies.First().Reverse());
                hierarchies = hierarchies.Skip(1);
                do
                {
                    int maxPossible = smallest.Count;
                    hierarchies = hierarchies.Select(each => each.Take(maxPossible));
                    Type candidate = smallest.Dequeue();
                    if (hierarchies.All(each => each.Last() == candidate))
                        return candidate;
                } while (smallest.Count > 1);
                return typeof(object);
        }
    }


    ///<summary>Gets the class hierarchy of the provided type, in order of derivation, e.g. : (System.Object,CustomBaseType,CustomConcreteType,...), or the singleton of System.Object type if the provided type is an interface or null </summary>
    public static IEnumerable<Type> ClassHierarchy(this Type type)
    {
        if (type == null || type.IsInterface) type = typeof(object);
        var stack = new Stack<Type>();
        do
        {
            stack.Push(type);
            type = type.BaseType;
        } while (type != null);
        return stack;

    }
于 2013-04-29T16:12:21.653 回答
0

编辑：更新以反映处理接口类型的更改。
编辑：添加了额外的功能以支持 2 种以上的类型。

首先：一个类型不能是另一个类型的实例（除非我们谈论的是 type 的实例Type。）只有一个对象可以是一个类型的实例。

类型可以是彼此的子类型（使用IsSubType）。类型可以分配给另一种类型（使用IsAssignableFrom）。

要查找常见类型，请尝试此示例。这将始终产生一个通用类型（对象）：

    /// <summary>
    /// Returns the most common type of two types.
    /// If no common type can be found, null is returned.
    /// </summary>
    static public Type GetCommonBaseClass(Type a, Type b)
    {
        if ((a == null) || (b ==null))
            return null;
        if (a.IsInterface || b.IsInterface)
            return null;
        if (a.IsAssignableFrom(b))
            return a;
        while (true)
        {
            if (b.IsAssignableFrom(a))
                return b;
            b = b.BaseType;
        }
    }

    /// <summary>
    /// Returns the most common type of one or more types.
    /// If no common type can be found, null is returned.
    /// </summary>
    static public Type GetCommonBaseClass(params Type[] types)
    {
        if ((types == null) || (types.Length == 0))
            return null;
        Type type = types[0];
        for (int i = 0; i < types.Length; i++)
            type = GetCommonBaseClass(type, types[i]);
        return type;
    }

并从您的函数中调用：

public Type GetTestClass(Object left, Object right)
{
     return GetCommonBaseClass(left.GetType(), right.GetType());
}
于 2013-04-29T16:24:20.547 回答