C# 对象类型比较

Question

如何比较声明为类型的两个对象的类型。

我想知道两个对象是否属于同一类型或来自同一基类。

感谢任何帮助。

例如

private bool AreSame(Type a, Type b) {

}

Answer 1

如果您希望两个对象实例属于某种类型，您也可以使用“IS”关键字。这也适用于将子类与父类以及实现接口的类等进行比较。不过，这不适用于 Type 类型的类型。

if (objA Is string && objB Is string)
// they are the same.

public class a {}

public class b : a {}

b objb = new b();

if (objb Is a)
// they are of the same via inheritance

Answer 2

假设a 和b 是两个对象。如果要查看a 和b 是否在同一个继承层次结构中，则使用Type.IsAssignableFrom：

var t = a.GetType();
var u = b.GetType();

if (t.IsAssignableFrom(u) || u.IsAssignableFrom(t)) {
  // x.IsAssignableFrom(y) returns true if:
  //   (1) x and y are the same type
  //   (2) x and y are in the same inheritance hierarchy
  //   (3) y is implemented by x
  //   (4) y is a generic type parameter and one of its constraints is x
}

如果您想检查一个是否是另一个的基类，请尝试 Type.IsSubclassOf。

如果您知道具体的基类，那么只需使用is 关键字：

if (a is T && b is T) {
  // Objects are both of type T.
}

否则，您将不得不直接遍历继承层次结构。

Answer 3

不过，这个想法有一点问题，因为每个对象（实际上，每个类型）都有一个公共基类 Object。您需要定义的是您想要在继承链上走多远（无论它们是相同的还是具有相同的直接父级，或者一个是另一个的直接父级，等等）并做你的那样检查。 IsAssignableFrom 可用于确定类型是否相互兼容，但不能完全确定它们是否具有相同的父对象（如果这是您所追求的）。

如果您的严格标准是函数应该返回 true if...

• 类型相同
• 一种类型是另一种类型的父级（直接或其他）
• 这两种类型具有相同的直接父级

你可以使用

private bool AreSame(Type a, Type b) 
{
    if(a == b) return true; // Either both are null or they are the same type

    if(a == null || b == null) return false; 

    if(a.IsSubclassOf(b) || b.IsSubclassOf(a)) return true; // One inherits from the other

    return a.BaseType == b.BaseType; // They have the same immediate parent
}

Answer 4

我使用接口和具体类尝试了以下层次结构。 它遍历其中一种类型的基类链，直到到达“对象”，在该“对象”处，我们检查当前目标类型是否可分配给源类型。 我们还检查类型是否具有公共接口。如果他们这样做，那么他们'AreSame'

希望这会有所帮助。

 public interface IUser
{
     int ID { get; set; }
     string Name { get; set; }
}

public class NetworkUser : IUser
{
    public int ID
    {
        get;
        set;
    }

    public string Name
    {
        get;
        set;
    }
}

public class Associate : NetworkUser,IUser
{
    #region IUser Members

    public int ID
    {
        get;
        set;
    }

    public string Name
    {
        get;
        set;
    }

    #endregion
}

public class Manager : NetworkUser,IUser
{
    #region IUser Members

    public int ID
    {
        get;
        set;
    }

    public string Name
    {
        get;
        set;
    }

    #endregion
}


public class Program
{

    public static bool AreSame(Type sourceType, Type destinationType)
    {
        if (sourceType == null || destinationType == null)
        {
            return false;
        }

        if (sourceType == destinationType)
        {
            return true;
        }

        //walk up the inheritance chain till we reach 'object' at which point check if 
    //the current destination type is assignable from the source type      
    Type tempDestinationType = destinationType;
        while (tempDestinationType.BaseType != typeof(object))
        {
            tempDestinationType = tempDestinationType.BaseType;
        }
        if( tempDestinationType.IsAssignableFrom(sourceType))
        {
            return true;
        }

        var query = from d in destinationType.GetInterfaces() join s in sourceType.GetInterfaces()
                    on d.Name equals s.Name
                    select s;
        //if the results of the query are not empty then we have a common interface , so return true 
    if (query != Enumerable.Empty<Type>())
        {
            return true;
        }
        return false;            
    }

    public static void Main(string[] args)
    {

        AreSame(new Manager().GetType(), new Associate().GetType());
    }
}