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

Question

语境： 假设一个具有以下阶层结构：

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

问：

是否有一个简单的方法来参考SomeStaticClass.SomeInnerStaticClass.SomeProperty转换为“SomeStaticClass.SomeInnerStaticClass.someStringValue的字符串值“？

Answer 1

我发布的第一件事是错误的，因为它们是静态类型我写了一个小代码，这个工程。

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

不要你只是想：

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

这将输出SClass.SInner.Property.value

如果你想自动化的话，你可以把它放在一个while循环和退出一旦父类型财产IsNested是错误的。

Answer 3

你可以使用一个表达式：

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

我不知道你的输入格式的性质，但你可以System.Linq.Expressions做到这一点：

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

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

Answer 5

这里有一个更详细的解决方案。该方法接受表示属性或字段的lambda表达式。它计算属性或字段的值，并将其与所有封装类的名称相加。

我想你想有一个类型安全的方法来生成某种类型的结构化/分层标识符编码为类和属性或字段的层次结构。我已经使用这种方法几年了，它有助于防止由简单的拼写错误导致的许多难以捉摸的错误。

代码：

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(); 
} 

例子：

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) 

输出将是：

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