Tüm nesneleri C # 'daki bir günlüğe dökmenin en iyi yolu nedir?

Bu nedenle, çalışma zamanında geçerli bir nesnenin durumunu görüntülemek için, Visual Studio Immediate penceresinin bana verdiği şeyi gerçekten seviyorum. Sadece basit yapıyorum

? objectname

Bana nesnenin güzel biçimlendirilmiş bir "dökümünü" verecek.

Bunu kodda yapmanın kolay bir yolu var mı, böylece oturum açarken benzer bir şey yapabilir miyim?

Linq örnekleriyle birlikte gönderilen ObjectDumper koduna bir şey dayandırabilirsiniz . Bir örnek almak için
bu ilgili sorunun cevabına da bir göz atın .

Daha büyük bir nesne grafiği için, Json kullanımını tercih ediyorum, ancak biraz farklı bir stratejiyle. İlk olarak, çağrılması kolay ve Json dönüşümünü saran statik bir yöntemle (not: bunu bir uzantı yöntemi yapabilir) statik bir sınıfım var.

using Newtonsoft.Json;

public static class F
{
    public static string Dump(object obj)
    {
        return JsonConvert.SerializeObject(obj);
    }
}

Sonra senin Immediate Windowiçinde

var lookHere = F.Dump(myobj);

lookHere, Localsbaşına $ ile eklenen pencerede otomatik olarak görünür veya ona bir saat ekleyebilirsiniz. Denetçideki Valuesütunun sağ tarafında, yanında açılır bir imleç bulunan bir büyüteç vardır. Açılır imleci seçin ve Json görselleştiriciyi seçin.

Visual Studio 2013 kullanıyorum.

Bunu yapmanın daha iyi yolları olduğundan eminim, ancak geçmişte bir nesneyi günlüğe kaydedebileceğim bir dizeye serileştirmek için aşağıdaki gibi bir yöntem kullandım:

  private string ObjectToXml(object output)
  {
     string objectAsXmlString;

     System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(output.GetType());
     using (System.IO.StringWriter sw = new System.IO.StringWriter())
     {
        try
        {
           xs.Serialize(sw, output);
           objectAsXmlString = sw.ToString();
        }
        catch (Exception ex)
        {
           objectAsXmlString = ex.ToString();
        }
     }

     return objectAsXmlString;
  }

Yöntemin, serileştirilmiş nesne yerine istisnayı da döndürebileceğini göreceksiniz, bu nedenle günlüğe kaydetmek istediğiniz nesnelerin serileştirilebilir olduğundan emin olmak isteyeceksiniz.

Visual Studio Hemen Penceresini kullanabilirsiniz

Sadece bunu yapıştırın ( actualaçıkça nesne adınıza değiştirin ):

Newtonsoft.Json.JsonConvert.SerializeObject(actual);

Nesneyi JSON'da yazdırmalıdır

Bunu textmechanic text tool veya notepad ++ üzerine kopyalayıp kaçan tırnakları ( \") ile "ve satırsonlarını ( \r\n) boş alanla değiştirebilmeniz, ardından çift tırnak işaretlerini ( ") baştan ve sondan kaldırıp jsbeautifier'a yapıştırarak daha okunaklı hale getirebilmelisiniz.

OP'nin yorumuna GÜNCELLE

public static class Dumper
{
    public static void Dump(this object obj)
    {
        Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(obj)); // your logger
    }
}

bu, herhangi bir nesneyi atmanıza izin vermelidir.

Umarım bu size biraz zaman kazandırır.

ServiceStack.Text , tam olarak bunu yapan bir T.Dump () genişletme yöntemine sahiptir, her türden tüm özellikleri güzel okunabilir bir biçimde özyinelemeli olarak döker.

Örnek kullanım:

var model = new TestModel();
Console.WriteLine(model.Dump());

ve çıktı:

{
    Int: 1,
    String: One,
    DateTime: 2010-04-11,
    Guid: c050437f6fcd46be9b2d0806a0860b3e,
    EmptyIntList: [],
    IntList:
    [
        1,
        2,
        3
    ],
    StringList:
    [
        one,
        two,
        three
    ],
    StringIntMap:
    {
        a: 1,
        b: 2,
        c: 3
    }
}

İşte güzel biçimlendirilmiş düz bir nesne yazmanın aptalca basit bir yolu:

using Newtonsoft.Json.Linq;

Debug.WriteLine("The object is " + JObject.FromObject(theObjectToDump).ToString());

Olan şey, nesnenin önce tarafından bir JSON dahili temsiline JObject.FromObjectdönüştürülmesi ve ardından ToString. (Ve elbette bir JSON dizesi, basit bir nesnenin çok güzel bir temsilidir, özellikle ToStringde satırsonları ve girintiler içereceği için.) "ToString" elbette gereksizdir ( +bir dizeyi ve bir nesneyi birleştirmek için kullanılmasıyla ima edildiği gibi ), ancak Burada belirtmek isterim.

Tüm nesne özelliklerinde yansıma ve döngü kullanabilir, ardından değerlerini alabilir ve günlüğe kaydedebilirsiniz. Biçimlendirme gerçekten önemsizdir (bir nesnenin özelliklerini ve değerlerini girintilemek için \ t kullanabilirsiniz):

MyObject
    Property1 = value
    Property2 = value2
    OtherObject
       OtherProperty = value ...

Yapmaktan hoşlandığım şey ToString () 'i geçersiz kılmaktır, böylece tür adının ötesinde daha kullanışlı çıktılar elde ederim. Bu, hata ayıklayıcıda kullanışlıdır, bir nesne hakkında istediğiniz bilgileri, onu genişletmeye gerek kalmadan görebilirsiniz.

Nesneleri ve koleksiyonları dizelere (ve daha fazlasına) kolayca dökmeye izin veren ObjectPrinter adlı bir kitaplık buldum . Tam olarak ihtiyacım olan şeyi yapıyor.

Aşağıda, aynı şeyi yapan (ve iç içe geçmiş özellikleri işleyen) başka bir sürüm daha basit olduğunu düşünüyorum (harici kitaplıklara bağımlılık yoktur ve günlük kaydı dışında başka şeyler yapmak için kolayca değiştirilebilir):

public class ObjectDumper
{
    public static string Dump(object obj)
    {
        return new ObjectDumper().DumpObject(obj);
    }

    StringBuilder _dumpBuilder = new StringBuilder();

    string DumpObject(object obj)
    {
        DumpObject(obj, 0);
        return _dumpBuilder.ToString();
    }

    void DumpObject(object obj, int nestingLevel = 0)
    {
        var nestingSpaces = "".PadLeft(nestingLevel * 4);

        if (obj == null)
        {
            _dumpBuilder.AppendFormat("{0}null\n", nestingSpaces);
        }
        else if (obj is string || obj.GetType().IsPrimitive)
        {
            _dumpBuilder.AppendFormat("{0}{1}\n", nestingSpaces, obj);
        }
        else if (ImplementsDictionary(obj.GetType()))
        {
            using (var e = ((dynamic)obj).GetEnumerator())
            {
                var enumerator = (IEnumerator)e;
                while (enumerator.MoveNext())
                {
                    dynamic p = enumerator.Current;

                    var key = p.Key;
                    var value = p.Value;
                    _dumpBuilder.AppendFormat("{0}{1} ({2})\n", nestingSpaces, key, value != null ? value.GetType().ToString() : "<null>");
                    DumpObject(value, nestingLevel + 1);
                }
            }
        }
        else if (obj is IEnumerable)
        {
            foreach (dynamic p in obj as IEnumerable)
            {
                DumpObject(p, nestingLevel);
            }
        }
        else
        {
            foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(obj))
            {
                string name = descriptor.Name;
                object value = descriptor.GetValue(obj);

                _dumpBuilder.AppendFormat("{0}{1} ({2})\n", nestingSpaces, name, value != null ? value.GetType().ToString() : "<null>");
                DumpObject(value, nestingLevel + 1);
            }
        }
    }

    bool ImplementsDictionary(Type t)
    {
        return t.GetInterfaces().Any(i => i.Name.Contains("IDictionary"));
    }
}

Kendi WriteLine yönteminizi yazabilirsiniz.

public static void WriteLine<T>(T obj)
    {
        var t = typeof(T);
        var props = t.GetProperties();
        StringBuilder sb = new StringBuilder();
        foreach (var item in props)
        {
            sb.Append($"{item.Name}:{item.GetValue(obj,null)}; ");
        }
        sb.AppendLine();
        Console.WriteLine(sb.ToString());
    }

Gibi kullanın-

WriteLine(myObject);

Bir koleksiyon yazmak için kullanabileceğimiz-

 var ifaces = t.GetInterfaces();
        if (ifaces.Any(o => o.Name.StartsWith("ICollection")))
        {

            dynamic lst = t.GetMethod("GetEnumerator").Invoke(obj, null);
            while (lst.MoveNext())
            {
                WriteLine(lst.Current);
            }
        }   

Yöntem şöyle görünebilir:

 public static void WriteLine<T>(T obj)
    {
        var t = typeof(T);
        var ifaces = t.GetInterfaces();
        if (ifaces.Any(o => o.Name.StartsWith("ICollection")))
        {

            dynamic lst = t.GetMethod("GetEnumerator").Invoke(obj, null);
            while (lst.MoveNext())
            {
                WriteLine(lst.Current);
            }
        }            
        else if (t.GetProperties().Any())
        {
            var props = t.GetProperties();
            StringBuilder sb = new StringBuilder();
            foreach (var item in props)
            {
                sb.Append($"{item.Name}:{item.GetValue(obj, null)}; ");
            }
            sb.AppendLine();
            Console.WriteLine(sb.ToString());
        }
    }

if, else ifArayüzleri, öznitelikleri, temel türü vb. Kullanmak ve kontrol etmek ve özyinelemeyi (bu özyinelemeli bir yöntem olduğundan) bu şekilde bir nesne dökümü elde edebiliriz, ancak bu kesinlikle sıkıcıdır. Microsoft'un LINQ Örneğindeki nesne damperini kullanmak zamandan tasarruf etmenizi sağlar.

@Engineforce cevabına dayanarak, Xamarin Çözümünün bir PCL projesinde kullandığım bu sınıfı yaptım:

/// <summary>
/// Based on: https://stackoverflow.com/a/42264037/6155481
/// </summary>
public class ObjectDumper
{
    public static string Dump(object obj)
    {
        return new ObjectDumper().DumpObject(obj);
    }

    StringBuilder _dumpBuilder = new StringBuilder();

    string DumpObject(object obj)
    {
        DumpObject(obj, 0);
        return _dumpBuilder.ToString();
    }

    void DumpObject(object obj, int nestingLevel)
    {
        var nestingSpaces = "".PadLeft(nestingLevel * 4);

        if (obj == null)
        {
            _dumpBuilder.AppendFormat("{0}null\n", nestingSpaces);
        }
        else if (obj is string || obj.GetType().GetTypeInfo().IsPrimitive || obj.GetType().GetTypeInfo().IsEnum)
        {
            _dumpBuilder.AppendFormat("{0}{1}\n", nestingSpaces, obj);
        }
        else if (ImplementsDictionary(obj.GetType()))
        {
            using (var e = ((dynamic)obj).GetEnumerator())
            {
                var enumerator = (IEnumerator)e;
                while (enumerator.MoveNext())
                {
                    dynamic p = enumerator.Current;

                    var key = p.Key;
                    var value = p.Value;
                    _dumpBuilder.AppendFormat("{0}{1} ({2})\n", nestingSpaces, key, value != null ? value.GetType().ToString() : "<null>");
                    DumpObject(value, nestingLevel + 1);
                }
            }
        }
        else if (obj is IEnumerable)
        {
            foreach (dynamic p in obj as IEnumerable)
            {
                DumpObject(p, nestingLevel);
            }
        }
        else
        {
            foreach (PropertyInfo descriptor in obj.GetType().GetRuntimeProperties())
            {
                string name = descriptor.Name;
                object value = descriptor.GetValue(obj);

                _dumpBuilder.AppendFormat("{0}{1} ({2})\n", nestingSpaces, name, value != null ? value.GetType().ToString() : "<null>");

                // TODO: Prevent recursion due to circular reference
                if (name == "Self" && HasBaseType(obj.GetType(), "NSObject"))
                {
                    // In ObjC I need to break the recursion when I find the Self property
                    // otherwise it will be an infinite recursion
                    Console.WriteLine($"Found Self! {obj.GetType()}");
                }
                else
                {
                    DumpObject(value, nestingLevel + 1);
                }
            }
        }
    }

    bool HasBaseType(Type type, string baseTypeName)
    {
        if (type == null) return false;

        string typeName = type.Name;

        if (baseTypeName == typeName) return true;

        return HasBaseType(type.GetTypeInfo().BaseType, baseTypeName);
    }

    bool ImplementsDictionary(Type t)
    {
        return t is IDictionary;
    }
}

Yukarıdaki yolların tümü, nesnelerinizin XML veya JSON'a serileştirilebilir olduğunu veya
kendi çözümünüzü uygulamanız gerektiğini varsayar .

Ama sonunda yine de şu gibi sorunları çözmeniz gereken noktaya gelirsiniz:

• nesnelerde özyineleme
• serileştirilemez nesneler
• istisnalar
• ...

Artı daha fazla bilgi istediğiniz günlüğü:

• olay ne zaman oldu
• çağrı yığını
• hangi üç
• web oturumunda ne vardı
• hangi ip adresi
• uRL
• ...

Tüm bunları ve daha fazlasını çözen en iyi çözüm var.
Şu Nuget paketini kullanın: Desharp .
Tüm uygulama türleri için - hem web hem de masaüstü uygulamaları .
'S Bkz Desharp Github belgelerine . It has birçok konfigürasyon seçenekleri .

İstediğiniz yeri arayın:

Desharp.Debug.Log(anyException);
Desharp.Debug.Log(anyCustomValueObject);
Desharp.Debug.Log(anyNonserializableObject);
Desharp.Debug.Log(anyFunc);
Desharp.Debug.Log(anyFunc, Desharp.Level.EMERGENCY); // you can store into different files

• günlüğü güzel HTML olarak (veya yapılandırılabilir METİN biçiminde) kaydedebilir
• isteğe bağlı olarak arka planda yazılabilir (yapılandırılabilir)
• maksimum nesne derinliği ve maksimum dizi uzunluğu için seçeneklere sahiptir (yapılandırılabilir)
• Yinelenebilir nesneler için döngüler ve diğer her şey için geriye doğru yansıma kullanır,
  gerçekten de .NET ortamında bulabileceğiniz her şey için .

Yardımcı olacağına inanıyorum.