web-dev-qa-db-ja.com

C＃：オブジェクトのすべてのプロパティを印刷する

オブジェクトのすべてのプロパティなどをコンソールに書き込むことができる.NETに組み込まれたメソッドはありますか？もちろんリフレクションを使用して作成できますが、これが既に存在するかどうかに興味があります。特にVisual Studioのイミディエイトウィンドウで実行できるためです。そこで（デバッグモードで）オブジェクト名を入力し、Enterキーを押すと、すべてのものがかなりきれいに印刷されます。

このような方法はありますか？

c#genericsconsoleobject
166
Svish

ObjectDumperクラスはそれを行うことが知られています。確認したことはありませんが、イミディエイトウィンドウがそれを使用していると常に疑っています。

編集：ObjectDumperのコードは実際にあなたのマシン上にあることを実感しました。に行きます：

c：/ Program Files/Microsoft Visual Studio 9.0/Samples/1033/CSharpSamples.Zip

これにより、LinqSamplesというフォルダーに解凍されます。そこには、ObjectDumperと呼ばれるプロジェクトがあります。それを使用します。

（これにより、コメントのDavidも幸せになります:)）

61
BFree

TypeDescriptorクラスを使用してこれを行うことができます。

foreach(PropertyDescriptor descriptor in TypeDescriptor.GetProperties(obj))
{
    string name=descriptor.Name;
    object value=descriptor.GetValue(obj);
    Console.WriteLine("{0}={1}",name,value);
}

TypeDescriptorはSystem.ComponentModel名前空間に存在し、Visual Studioがオブジェクトをプロパティブラウザーに表示するために使用するAPIです。最終的には（他のソリューションと同様に）リフレクションに基づいていますが、リフレクションAPIからのかなり優れた抽象化レベルを提供します。

288
Sean

LINQサンプルのObjectDumperに基づいて、各プロパティを独自の行にダンプするバージョンを作成しました。

このクラスのサンプル

namespace MyNamespace
{
    public class User
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public Address Address { get; set; }
        public IList<Hobby> Hobbies { get; set; }
    }

    public class Hobby
    {
        public string Name { get; set; }
    }

    public class Address
    {
        public string Street { get; set; }
        public int ZipCode { get; set; }
        public string City { get; set; }    
    }
}

の出力があります

{MyNamespace.User}
  FirstName: "Arnold"
  LastName: "Schwarzenegger"
  Address: { }
    {MyNamespace.Address}
      Street: "6834 Hollywood Blvd"
      ZipCode: 90028
      City: "Hollywood"
  Hobbies: ...
    {MyNamespace.Hobby}
      Name: "body building"

これがコードです。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Text;

public class ObjectDumper
{
    private int _level;
    private readonly int _indentSize;
    private readonly StringBuilder _stringBuilder;
    private readonly List<int> _hashListOfFoundElements;

    private ObjectDumper(int indentSize)
    {
        _indentSize = indentSize;
        _stringBuilder = new StringBuilder();
        _hashListOfFoundElements = new List<int>();
    }

    public static string Dump(object element)
    {
        return Dump(element, 2);
    }

    public static string Dump(object element, int indentSize)
    {
        var instance = new ObjectDumper(indentSize);
        return instance.DumpElement(element);
    }

    private string DumpElement(object element)
    {
        if (element == null || element is ValueType || element is string)
        {
            Write(FormatValue(element));
        }
        else
        {
            var objectType = element.GetType();
            if (!typeof(IEnumerable).IsAssignableFrom(objectType))
            {
                Write("{{{0}}}", objectType.FullName);
                _hashListOfFoundElements.Add(element.GetHashCode());
                _level++;
            }

            var enumerableElement = element as IEnumerable;
            if (enumerableElement != null)
            {
                foreach (object item in enumerableElement)
                {
                    if (item is IEnumerable && !(item is string))
                    {
                        _level++;
                        DumpElement(item);
                        _level--;
                    }
                    else
                    {
                        if (!AlreadyTouched(item))
                            DumpElement(item);
                        else
                            Write("{{{0}}} <-- bidirectional reference found", item.GetType().FullName);
                    }
                }
            }
            else
            {
                MemberInfo[] members = element.GetType().GetMembers(BindingFlags.Public | BindingFlags.Instance);
                foreach (var memberInfo in members)
                {
                    var fieldInfo = memberInfo as FieldInfo;
                    var propertyInfo = memberInfo as PropertyInfo;

                    if (fieldInfo == null && propertyInfo == null)
                        continue;

                    var type = fieldInfo != null ? fieldInfo.FieldType : propertyInfo.PropertyType;
                    object value = fieldInfo != null
                                       ? fieldInfo.GetValue(element)
                                       : propertyInfo.GetValue(element, null);

                    if (type.IsValueType || type == typeof(string))
                    {
                        Write("{0}: {1}", memberInfo.Name, FormatValue(value));
                    }
                    else
                    {
                        var isEnumerable = typeof(IEnumerable).IsAssignableFrom(type);
                        Write("{0}: {1}", memberInfo.Name, isEnumerable ? "..." : "{ }");

                        var alreadyTouched = !isEnumerable && AlreadyTouched(value);
                        _level++;
                        if (!alreadyTouched)
                            DumpElement(value);
                        else
                            Write("{{{0}}} <-- bidirectional reference found", value.GetType().FullName);
                        _level--;
                    }
                }
            }

            if (!typeof(IEnumerable).IsAssignableFrom(objectType))
            {
                _level--;
            }
        }

        return _stringBuilder.ToString();
    }

    private bool AlreadyTouched(object value)
    {
        if (value == null)
            return false;

        var hash = value.GetHashCode();
        for (var i = 0; i < _hashListOfFoundElements.Count; i++)
        {
            if (_hashListOfFoundElements[i] == hash)
                return true;
        }
        return false;
    }

    private void Write(string value, params object[] args)
    {
        var space = new string(' ', _level * _indentSize);

        if (args != null)
            value = string.Format(value, args);

        _stringBuilder.AppendLine(space + value);
    }

    private string FormatValue(object o)
    {
        if (o == null)
            return ("null");

        if (o is DateTime)
            return (((DateTime)o).ToShortDateString());

        if (o is string)
            return string.Format("\"{0}\"", o);

        if (o is char && (char)o == '\0') 
            return string.Empty; 

        if (o is ValueType)
            return (o.ToString());

        if (o is IEnumerable)
            return ("...");

        return ("{ }");
    }
}

そして、あなたはそれをそのように使うことができます：

var dump = ObjectDumper.Dump(user);

編集

  • 双方向参照は現在停止しています。したがって、オブジェクトのHashCodeはリストに格納されます。
  • AlreadyTouched修正済み（コメントを参照）
  • FormatValueの修正（コメントを参照）
94
ms007

多分 JavaScriptSerializer.Serialize ？

24
Marc Gravell

Seanの返信のTypeDescriptorについて（評判が悪いためコメントできません）... GetProperties（）よりもTypeDescriptorを使用する利点の1つは、TypeDescriptorが実行時にオブジェクトにプロパティを動的にアタッチするメカニズムを備えていることです。 。

たとえば、実行時にプロパティとメソッドを追加できるPowerShellのPSObjectを使用する場合、これらのメンバーを標準メンバーセットにマージするカスタムTypeDescriptorを実装しました。 TypeDescriptorを使用することにより、コードはその事実を認識する必要がありません。

コンポーネント、コントロール、そしておそらくDataSetsもこのAPIを利用していると思います。

6
Josh

次のスニペットは、目的の機能を実行します。

Type t = obj.GetType(); // Where obj is object whose properties you need.
PropertyInfo [] pi = t.GetProperties();
foreach (PropertyInfo p in pi)
{
    System.Console.WriteLine(p.Name + " : " + p.GetType());
}

これを拡張メソッドとして記述すると、すべてのタイプのオブジェクトで使用できると思います。

5
TheVillageIdiot

これがまさに反射の目的です。単純な解決策はないと思いますが、とにかくリフレクションはそれほどコード集約的ではありません。

1
Jon B

他のソリューション/ライブラリは、最終的にリフレクションを使用してタイプを内省します...

0
mP.

そうは思わないでください。私はいつもそれらを書くか、他の誰かの作品を使ってその情報を手に入れなければなりませんでした。私が知っている限り、反映する必要があります。

編集：
チェック this out 。長いオブジェクトグラフのデバッグを調査していて、ウォッチを追加すると、VSがこのクラスMscorlib_CollectionDebugView<>をスローしたときにこれに気付きました。これは、ウォッチウィンドウ/コードデバッグモードで表示するためにコレクションを適切に表示するための内部タイプです。これで内部参照できるようになりましたが、Reflectorを使用してコードをコピー（mscorlibから）し、独自のコードを作成できます（上記のリンクにはコピー/貼り付けの例があります）。本当に便利に見えます。

0
Matt Kocaj