Question

class Base
{
}
class A: Base
{
}
class B:A
{
}

我希望能够为B的实例获取字符串“Base.A.B”

当然我可以做到

class B:A
{
   const string NAME = "Base.A.B";
}

但那有点脆弱，如果我改变了东西，我必须在许多地方改变它

我从

开始

class Base
{
protected string Name {get{return typeof(Base).Name;}};
}

使用每个类层次结构级别的dea调用其base.Name方法。但是我现在不得不两次命名Base（不可否认，如果我忘记它会在编译时失败）但它仍然看起来很脆弱。

Answer 1

此方法：

public static string GetHierarchy(Type t)
{
    if (t == null)
    {
        return "";
    }

    string rec = GetHierarchy(t.BaseType);

    return rec + "." + t.Name.ToString();
}

当这样调用时：

string str = GetHierarchy(typeof(B));

将产生以下结果：

".Object.Base.A.B"

编辑以防止NullReferenceException

Answer 2

这个怎么样：

class Base {
   public virtual string GetName() { return "Base"; }
}

class A : Base {
   public override string GetName() { return base.GetName() + ".A"; }
}

class B : A  {
   public override string GetName() { return base.GetName() + ".B"; }
}

只是一个想法：）

Answer 3

您可以考虑使用反射。

您可以注释您的课程，如

[Name("Base")]
public class Base { }

[Name("A:Base")]
public class A : Base { }

[Name("B:A:Base")]
public class B : A { }

然后你可以使用例如：

System.Attribute[] attrs = System.Attribute.GetCustomAttributes(typeof(B));

给你attr [0] ==“B：A：Base”

Answer 4

与其他人的代码相同，但我付出了努力，所以我该死的很好（唯一的区别是我不想“.object”卡在最后）。

    public class Class1 { }
    public class Class2 : Class1 { }
    public class Class3 : Class2 { }

    private void button1_Click(object sender, EventArgs e)
    {
        Class3 c3 = new Class3();
        Console.WriteLine(TypeToString(c3.GetType()));
    }

    private string TypeToString(Type t)
    {
        if (t == null)
            return "";
        if ((t.BaseType == null) || (t.BaseType == typeof(object)))
            return t.Name;
        return TypeToString(t.BaseType) + "." + t.Name;
    }

Answer 5

这是基于@Jaime的答案，所以我会给予他大部分功劳，但我修改了它，这样你就不必把自定义属性放在需要你记住更新它们。

*您需要添加对System.Reflection的引用

class Base
{
    public virtual string GetName()
    {
        return MethodBase.GetCurrentMethod().DeclaringType.ToString();
    }
}

class A : Base
{
    public override string GetName()
    {
        return base.GetName() + "." + MethodBase.GetCurrentMethod().DeclaringType.ToString();

    }
}

class B : A
{
    public override string GetName()
    {
        return base.GetName() + "." + MethodBase.GetCurrentMethod().DeclaringType.ToString();
    }
}

class C : B
{
    public override string GetName()
    {
        return base.GetName() + "." + MethodBase.GetCurrentMethod().DeclaringType.ToString();
    }
}

C test = new C();
test.GetName(); // Yields "Base.A.B.C"

Answer 6

我编写了以下扩展方法和递归方法。我相信它为这个问题提供了一个很好的解决方案。

检查出来，任何反馈都会很好=）

public static class FamilyTreeExtension
    {
        public static string GetFamilyTree(this Type t)
        {
            return GetFamilyTreeRecursive(t, t.Name);
        }

        public static string GetFamilyTreeRecursive(Type t, string leaf)
        {
            Type baseType = t.BaseType;

            string currentTree;

            if (baseType != null)
            {
                currentTree = string.Format("{0}.{1}", baseType.Name, leaf);
                return GetFamilyTreeRecursive(baseType, currentTree);
            }
            else
            {
                return leaf;
            }
        }
    }

用法：

...
private void reflectionTryOut()
        {
            string validate = typeof(C).GetFamilyTree();
        }
    }

    public class A
    {}

    public class B : A
    {}

    public class C : B
    {}

结果： Object.A.B.C

试图获取表示类层次结构的字符串

6 个答案: