如何将链接的静态类名称和属性值转换为字符串？

Question

Context: Suppose one has the following class structure:

public static class SomeStaticClass
{
    public static class SomeInnerStaticClass
    {
        public static readonly string SomeProperty = "someStringValue";
    }
}

Question:

Is there an easy way to convert the reference SomeStaticClass.SomeInnerStaticClass.SomeProperty to string value of "SomeStaticClass.SomeInnerStaticClass.someStringValue"?

Answer 1

the first thing I posted was wrong because they were static types I wrote a little code and this works.

public static class A
{
    public static class B
    {
        public static string c
        {
            get
            {
                return "hi";
            }
        }
    }

}
class Program
{
    static void Main( string[] args )
    {

        Console.WriteLine(typeof(A.B).FullName.Replace("+",".") + "." +  A.B.c  ) ;
    }


}

Answer 2

Don't you just want:

public static class SClass
{
   public static class SInner
   {
       public static string Property = 
            (typeof(SInner)).DeclaringType.Name+ "." 
            + typeof(SInner).Name + "."
            + "value";
   }
}

Which would output SClass.SInner.Property.value

If you wanted to automated it, you could put it in a while loop and exit once the parent type property IsNested is false.

Answer 3

You could use an expression:

namespace ConsoleApplication2
{
    using System;
    using System.Linq.Expressions;

    class Program
    {
        static void Main(string[] args)
        {
            string fullName = GetExpression(() => SomeClass.SomeProperty);

            Console.WriteLine(fullName);
        }

        public static string GetExpression<TProperty>(Expression<Func<TProperty>> expr)
        {
            string name = expr.Body.ToString();
            string value = expr.Compile().Invoke().ToString();

            name = name.Substring(0, name.LastIndexOf(".") + 1) + value;

            return name;
        }
    }

    public static class SomeClass
    {
        public static string SomeProperty = "Hello";
    }
}

Answer 4

Here's one more elaborate solution. The method accepts a lambda expression denoting a property or a field. It the computes the value of the property or field and prepends it with names of all encapsulating classes.

I guess you want to have a type-safe method of producing some kind of structured / hierarchical identifiers encoded as a hierarchy of classes and properties or fields. I've been using this approach for a few years and it helps prevent many hard-to-catch bugs caused by simple typos.

Code:

public string GetStructuredName(Expression<Func<object>> nameObject)
{
    if (nameObject == null) throw new ArgumentNullException("nameObject");

    // find the expression denoting a property or a field
    MemberExpression member = null;
    switch (nameObject.Body.NodeType)
    {
        case ExpressionType.MemberAccess:
            member = (MemberExpression)nameObject.Body;
            break;
        case ExpressionType.Convert:
        case ExpressionType.ConvertChecked:
            member = ((UnaryExpression)nameObject.Body).Operand as MemberExpression;
            break;
    }
    if (member == null) throw new ArgumentNullException("nameObject");

    StringBuilder sb = new StringBuilder();

    // use the value of the member as the final component of the resulting name
    sb.Append(nameObject.Compile().DynamicInvoke());

    // use short names of embedded type names as components of the resulting name
    Type type = member.Member.DeclaringType;
    while (type != null && type != typeof(Object))
    {
        sb.Insert(0, ".");
        sb.Insert(0, type.Name);
        type = type.DeclaringType;
    }

    return sb.ToString();
}

Example:

public class OuterContainer
{
    public class InnerContainer
    {
        public static string Property
        {
            get { return "value"; }
        }

        public static int Field = 10;
    }
}

GetStructuredName(() => OuterContainer.InnerContainer.Property)
GetStructuredName(() => OuterContainer.InnerContainer.Field)

The output will be:

"OuterContainer.InnerContainer.value"
"OuterContainer.InnerContainer.10"

Answer 5

I don't know about the nature of your input format, but you can do this with System.Linq.Expressions :

    Expression<Func<string>> expr = () =>
        SomeStaticClass.SomeInnerStaticClass.SomeProperty;

    var myResult = String.Concat(expr.Body, ".", expr.Compile().Invoke());