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

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

当然我可以简单地做

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

但这有点脆弱，如果我改变一些东西，我必须在很多地方改变它

我从

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

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

4

6 回答 6

3

这种方法：

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

于 2012-06-29T00:28:48.280 回答
1

这个怎么样：

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"; }
}

只是一个想法:)

于 2012-06-29T00:22:04.387 回答
0

您可以考虑使用反射。

你可以注释你的类，比如

[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"

于 2012-06-29T00:29:28.250 回答
0

与其他代码相同，但我努力了，所以我会很好地发布它（唯一的区别是我不希望“.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;
    }
于 2012-06-29T00:32:14.583 回答
0

这是基于@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"
于 2012-06-29T00:50:32.630 回答
0

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

看看吧，任何反馈都会很好=）

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.ABC

于 2012-06-29T00:56:23.497 回答