Печать полного графа объекта с использованием C # и отражения

Question

У меня есть комплексный объект

class A
{
 int Field1;
 int field2;
 property ClassB ClassB;
 property classC classC;
 etc etc....

}

Я хочу напечатать полный график объекта, используя отражение. Какой-нибудь хороший код там?

Answer 1

Минималистская альтернатива, способная отображать сложные объекты в удобочитаемом формате:

public static string Dump(object o, string name = "", int depth = 3)
{
    try
    {
        var leafprefix = (string.IsNullOrWhiteSpace(name) ? name : name + " = ");

        if (null == o) return leafprefix + "null";

        var t = o.GetType();
        if (depth-- < 1 || t == typeof (string) || t.IsValueType)
            return  leafprefix + o;

        var sb = new StringBuilder();
        var enumerable = o as IEnumerable;
        if (enumerable != null)
        {
            name = (name??"").TrimEnd('[', ']') + '[';
            var elements = enumerable.Cast<object>().Select(e => Dump(e, "", depth)).ToList();
            var arrayInOneLine = elements.Count + "] = {" + string.Join(",", elements) + '}';
            if (!arrayInOneLine.Contains(Environment.NewLine)) // Single line?
                return name + arrayInOneLine;
            var i = 0;
            foreach (var element in elements)
            {
                var lineheader = name + i++ + ']';
                sb.Append(lineheader).AppendLine(element.Replace(Environment.NewLine, Environment.NewLine+lineheader));
            }
            return sb.ToString();
        }
        foreach (var f in t.GetFields())
            sb.AppendLine(Dump(f.GetValue(o), name + '.' + f.Name, depth));
        foreach (var p in t.GetProperties())
            sb.AppendLine(Dump(p.GetValue(o, null), name + '.' + p.Name, depth));
        if (sb.Length == 0) return leafprefix + o;
        return sb.ToString().TrimEnd();
    }
    catch
    {
        return name + "???";
    }
}

Answer 2

Мне больше нравится мой, так как он компилируется. Я реализовал это как серию методов расширения и статических вещей, поэтому поместите это в статический класс где-нибудь в вашем проекте, и методы расширения будут немедленно доступны, как только вы включите пространство имен, содержащее статический класс. Вот как вы это используете:

myObject.PrintGraph();

Он будет рекурсивно туннелировать все время вниз по вашему графику, пока не найдет что-то, что он может Convert.ToString (), который затем будет отладить. Отпечатать в ваше непосредственное окно. Вот пример вывода:

TopLevelProperty: value //Member of myObject
     MyEnumerableProperty: MyItemProperty: value //A property from an object in myObject
          MyEnumerableProperty: MySubEnumerableProperty: MyItemProperty: value //& so on

Это только печатает открытые свойства.

Вот метод PrintGraph:

/// <summary>
/// Prints the graph of this object using Debug.Print.
/// </summary>
/// <param name="o">This object.</param>
/// <param name="prefix">Optional text to prepend to all lines printed by this method.
/// </param>
public static void PrintGraph(this object o, string prefix = "")
{
   Type t = o.GetType(); if (prefix != "") prefix = "     " + prefix;

   foreach (PropertyInfo p in t.GetProperties())
      if (p.PropertyType.IsConvertible()) Debug.Print(prefix + p.Name + ": " +
         Convert.ToString(p.GetValue(o, null)));
      else if (p.PropertyType.IsEnumerable())
         foreach (object sub in (IEnumerable)p.GetValue(o, null)) 
            PrintGraph(sub, prefix + p.Name + ": ");
      else if (p.SimpleGetter()) 
         PrintGraph(p.GetValue(o, null), prefix + p.Name + ": ");
   if (t.IsEnumerable()) foreach (object sub in (IEnumerable)o) PrintGraph(sub);
}

А вот инфраструктура, которая вам нужна, чтобы она заработала:

internal static Type[] ConvertibleTypes = {typeof(bool), typeof(byte), typeof(char),
   typeof(DateTime), typeof(decimal), typeof(double), typeof(float), typeof(int), 
   typeof(long), typeof(sbyte), typeof(short), typeof(string), typeof(uint), 
   typeof(ulong), typeof(ushort)};

/// <summary>
/// Returns true if this Type matches any of a set of Types.
/// </summary>
/// <param name="type">This type.</param>
/// <param name="types">The Types to compare this Type to.</param>
public static bool In(this Type type, params Type[] types) 
{ 
   foreach (Type t in types) if (t.IsAssignableFrom(type)) return true; return false; 
}

/// <summary>
/// Returns true if this Type is one of the types accepted by Convert.ToString() 
/// (other than object).
/// </summary>
public static bool IsConvertible(this Type t) { return t.In(ConvertibleTypes); }

/// <summary>
/// Gets whether this type is enumerable.
/// </summary>
public static bool IsEnumerable(this Type t) 
{ 
   return typeof(IEnumerable).IsAssignableFrom(t); 
}

/// <summary>
/// Returns true if this property's getter is public, has no arguments, and has no 
/// generic type parameters.
/// </summary>
public static bool SimpleGetter(this PropertyInfo info) 
{ 
   MethodInfo method = info.GetGetMethod(false); 
   return method != null && method.GetParameters().Length == 0 && 
      method.GetGenericArguments().Length == 0; 
}

Answer 3

Я сделал что-то для отладки несколько лет назад. Это рекурсивная функция, которая печатает все свойства и подобъект. То, как вы печатаете, зависит от вас. Просто введите нужный код в метод печати. Это не «пуленепробиваемый», но он работает довольно хорошо:

private static void displayObject(object myObject, bool displaySubObject, Type objectType)
{
  print(objectType.FullName);
  if (myObject == null) 
  {
      print(STR_Null);
  }
  else 
  {
    //check for collection
    if (objectType.GetInterface("IEnumerable") != null) 
    {
      int itemNb = 0;
      foreach (object item in (IEnumerable)myObject) 
      {
        displayObject(item, displaySubObject, item.GetType);
        itemNb += 1;
      }
    }
    else 
    {
      ArrayList al = new ArrayList();
      Reflection.PropertyInfo pi = default(Reflection.PropertyInfo);
      Reflection.MemberInfo[] members = objectType.GetMembers();
      foreach (Reflection.MemberInfo mi in objectType.GetMembers()) 
      {
        if ((mi.MemberType & Reflection.MemberTypes.Constructor) != 0){//ignore constructor}
        else if (object.ReferenceEquals(mi.DeclaringType, typeof(object))) {//ignore inherited}
        else if (!al.Contains(mi.Name) & (mi.MemberType & Reflection.MemberTypes.Property) != 0) 
        {
          al.Add(mi.Name);
          pi = (Reflection.PropertyInfo)mi;
          if (!(displaySubObject) || (pi.PropertyType.IsValueType || pi.PropertyType.Equals(typeof(string)))) 
          {
            print(pi, myObject);
          }
          else 
          {
            //display sub objects
            displayObject(pi.GetValue(myObject, null), displaySubObject, i.PropertyType);
          }
        }
      }
    }
  }
}

Надеюсь, это поможет