调试用对象输出

最新推荐文章于 2023-03-28 00:28:34 发布
最新推荐文章于 2023-03-28 00:28:34 发布
阅读量178 收藏
点赞数
文章标签： c#
原文链接：http://www.cnblogs.com/xlshcn/archive/2009/04/06/objectdump.html
版权

编写程序跟踪输出时，有时候需要输出某个对象所有字段和属性的值，类似于Watch。如果只有一个两个类的对象，事情并不麻烦，但是如果有很多类的对象，那么单独写就很费时。鉴于此，我写了一个通用的对象转储输出类，用于针对绝大多数对象进行转储为字符串形式。

 

ContractedBlock.gif ExpandedBlockStart.gif Code
using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Reflection;

namespace Abacl.Library.Diagnostics
{
    [Flags]
    public enum ObjectDumpOptions
    {
        Fields = 0x00000001,
        Properties = 0x00000002,

        NonPublic = 0x00000010,
        Static = 0x00000020,

        Recurisive = 0x00001000,
        ExpandArray = 0x00002000,

        WithType = 0x00010000,
        UsingFullTypeName = 0x00040000,
        UsingTypeKeywords = 0x00080000,
        WithName = 0x00100000,

        SingleLine = 0x01000000,
        NullIsNull = 0x02000000,

        Default = Fields | Recurisive | UsingTypeKeywords | WithName | WithType | ExpandArray,
        DefaultBrief = Fields | Recurisive | UsingTypeKeywords | WithType | WithName | SingleLine,
        DefaultBriefMultiLines = Fields | Recurisive | UsingTypeKeywords | WithType| WithName
    }

    public static class TextDump
    {
        public static string DumpObject(object obj, ObjectDumpOptions options)
        {
            return DumpObject(obj, options, 0);
        }

        public static string DumpObject(object obj, ObjectDumpOptions options, int indent)
        {
            StringBuilder sb = new StringBuilder();

            if (obj == null)
            {
                if ((options & ObjectDumpOptions.NullIsNull) != 0)
                {
                    return null;
                }
                else
                {
                    return "<null>";
                }
            }
            else
            {
                Type type = obj.GetType();

                if ((options & ObjectDumpOptions.WithType) != 0)
                {
                    sb.Append('(');

                    if ((options & ObjectDumpOptions.UsingTypeKeywords) != 0)
                    {
                        if (type.IsArray)
                        {
                            sb.Append("array ");
                        }

                        if (type.IsClass && type != typeof(string))
                        {
                            if (type.IsSubclassOf(typeof(Delegate)))
                            {
                                sb.Append("delegate ");
                            }
                            else if (type.IsValueType)
                            {
                                sb.Append("struct ");
                            }
                            else
                            {
                                sb.Append("class ");
                            }
                        }

                        if (type.IsAnsiClass || type.IsUnicodeClass || type.IsAutoClass)
                        {
                            if (type.IsValueType && !type.IsPrimitive && !type.IsEnum)
                            {
                                sb.Append("struct ");
                            }
                        }

                        if (type.IsEnum)
                        {
                            sb.Append("enum ");
                        }

                        if (type.IsInterface)
                        {
                            sb.Append("interface ");
                        }
                    }

                    if ((options & ObjectDumpOptions.UsingFullTypeName) != 0)
                    {
                        sb.Append(ConvertToTypeKeywords(type, true));
                    }
                    else
                    {
                        sb.Append(ConvertToTypeKeywords(type, false));
                    }

                    sb.Append(')');
                }

                if (type.IsPrimitive)
                {
                    if (type == typeof(char))
                    {
                        sb.Append('\'' + obj.ToString() + '\'');
                    }
                    else
                    {
                        sb.Append(obj.ToString());
                    }
                }
                else if (type.IsEnum)
                {
                    sb.Append(obj.ToString());
                }
                else if (type == typeof(string))
                {
                    sb.Append('"' + obj.ToString() + '"');
                }
                else if (type.IsSubclassOf(typeof(Delegate)))
                {
                    Delegate d = (Delegate)obj;

                    if ((options & ObjectDumpOptions.UsingFullTypeName) != 0)
                    {
                        sb.Append(d.Method.DeclaringType.FullName + '.' + d.Method.Name);
                    }
                    else
                    {
                        sb.Append(d.Method.DeclaringType.Name + '.' + d.Method.Name);
                    }
                }
                else if (type.IsArray)
                {
                    Array array = (Array)obj;

                    if ((options & ObjectDumpOptions.ExpandArray) != 0)
                    {
                        sb.Append('[');
                        if ((options & ObjectDumpOptions.SingleLine) == 0)
                        {
                            Indent(ref indent, sb);
                        }

                        bool first = true;

                        for (int i = array.GetLowerBound(0); i < array.GetUpperBound(0); ++i)
                        {
                            if (!first)
                            {
                                sb.Append(", ");

                                if ((options & ObjectDumpOptions.SingleLine) == 0)
                                {
                                    NewLine(indent, sb);
                                }
                            }

                            sb.AppendFormat("array[{0}] = ", i);
                            sb.Append(DumpObject(array.GetValue(i), GetRecurisiveOptions(options), indent));
                            first = false;
                        }

                        if ((options & ObjectDumpOptions.SingleLine) == 0)
                        {
                            Unindent(ref indent, sb);
                        }
                        sb.Append(']');
                    }
                    else
                    {
                        sb.AppendFormat("<{0} elements>", array.Length);
                    }
                }
                else
                {
                    sb.Append('[');
                    if ((options & ObjectDumpOptions.SingleLine) == 0)
                    {
                        Indent(ref indent, sb);
                    }

                    bool isFirst = true;

                    if ((options & ObjectDumpOptions.Fields) != 0)
                    {
                        foreach (FieldInfo field in type.GetFields(GetBindingFlags(options)))
                        {
                            if (!isFirst)
                            {
                                sb.Append(", ");

                                if ((options & ObjectDumpOptions.SingleLine) == 0)
                                {
                                    NewLine(indent, sb);
                                }
                            }

                            if ((options & ObjectDumpOptions.WithName) != 0)
                            {
                                sb.Append(field.Name);
                                sb.Append(" = ");
                            }

                            sb.Append(DumpObject(field.GetValue(obj), GetRecurisiveOptions(options), indent));
                            isFirst = false;
                        }
                    }

                    if ((options & ObjectDumpOptions.Properties) != 0)
                    {
                        foreach (PropertyInfo property in type.GetProperties(GetBindingFlags(options)))
                        {
                            if (!isFirst)
                            {
                                sb.Append(", ");

                                if ((options & ObjectDumpOptions.SingleLine) == 0)
                                {
                                    NewLine(indent, sb);
                                }
                            }

                            if ((options & ObjectDumpOptions.WithName) != 0)
                            {
                                sb.Append(property.Name);
                                sb.Append(" = ");
                            }

                            ParameterInfo[] parameters = property.GetIndexParameters();

                            if (parameters == null || parameters.Length == 0)
                            {
                                sb.Append(DumpObject(property.GetValue(obj, null), GetRecurisiveOptions(options), indent));
                            }
                            else
                            {
                                sb.Append("<>");
                            }

                            isFirst = false;
                        }
                    }
                    if ((options & ObjectDumpOptions.SingleLine) == 0)
                    {
                        Unindent(ref indent, sb);
                    }
                    sb.Append(']');
                }

                return sb.ToString();
            }
        }

        public static string DumpMethod(ObjectDumpOptions options, string methodName, object result, params object[] args)
        {
            StringBuilder sb = new StringBuilder();
            int indent = 0;

            sb.Append(methodName);
            sb.Append('(');

            if ((options & ObjectDumpOptions.SingleLine) == 0 && args.Length != 0)
            {
                Indent(ref indent, sb);
            }

            bool isFirst = true;

            foreach (object arg in args)
            {
                if (!isFirst)
                {
                    sb.Append(", ");

                    if ((options & ObjectDumpOptions.SingleLine) == 0)
                    {
                        NewLine(indent, sb);
                    }
                }

                sb.Append(DumpObject(arg, options, indent));
                isFirst = false;
            }

            if ((options & ObjectDumpOptions.SingleLine) == 0 && args.Length != 0)
            {
                Unindent(ref indent, sb);
            }

            sb.Append(") = ");
            sb.Append(DumpObject(result, options, indent));

            return sb.ToString();
        }

        private static string ConvertToTypeKeywords(Type type, bool fullName)
        {
            Debug.Assert(type != null);

            if (type == typeof(bool))
            {
                return "bool";
            }

            if (type == typeof(char))
            {
                return "char";
            }

            if (type == typeof(byte))
            {
                return "byte";
            }

            if (type == typeof(sbyte))
            {
                return "sbyte";
            }

            if (type == typeof(short))
            {
                return "short";
            }

            if (type == typeof(ushort))
            {
                return "ushort";
            }

            if (type == typeof(int))
            {
                return "int";
            }

            if (type == typeof(uint))
            {
                return "uint";
            }

            if (type == typeof(long))
            {
                return "long";
            }

            if (type == typeof(ulong))
            {
                return "ulong";
            }

            if (type == typeof(float))
            {
                return "float";
            }

            if (type == typeof(double))
            {
                return "double";
            }

            if (type == typeof(decimal))
            {
                return "decimal";
            }

            if (type == typeof(string))
            {
                return "string";
            }

            if (type == typeof(Nullable))
            {
                return ConvertToTypeKeywords(Nullable.GetUnderlyingType(type), fullName) + "?";
            }

            if (fullName)
            {
                return type.FullName;
            }
            else
            {
                return type.Name;
            }
        }

        private static BindingFlags GetBindingFlags(ObjectDumpOptions options)
        {
            BindingFlags flags = BindingFlags.Public;

            if ((options & ObjectDumpOptions.NonPublic) != 0)
            {
                flags |= BindingFlags.NonPublic;
            }

            if ((options & ObjectDumpOptions.Static) != 0)
            {
                flags |= BindingFlags.Static;
            }
            else
            {
                flags |= BindingFlags.Instance;
            }

            return flags;
        }

        private static ObjectDumpOptions GetRecurisiveOptions(ObjectDumpOptions options)
        {
            if ((options & ObjectDumpOptions.Recurisive) == 0)
            {
                options &= ~ObjectDumpOptions.Fields;
                options &= ~ObjectDumpOptions.Properties;
                options &= ~ObjectDumpOptions.ExpandArray;
            }

            return options;
        }

        private static void Indent(ref int indent, StringBuilder sb)
        {
            ++indent;
            NewLine(indent, sb);
        }

        private static void Unindent(ref int indent, StringBuilder sb)
        {
            --indent;
            NewLine(indent, sb);
        }

        private static void NewLine(int indent, StringBuilder sb)
        {
            sb.Append(Environment.NewLine);
            sb.Append(new string(' ', indent * 2));
        }
    }
}

 

不同的ObjectDumpOptions指示不同的输出格式：

 

Fields：转储字段

Properties：转储属性

NonPublic：转储非公共成员（字段、属性等）

Static：转储静态成员（如选择此选项，则实例成员不会包括的输出中）

Recursive：递归转储所有内含的类型（如不包含此项，则仅转储直接成员）

ExpandArray：扩展所有数组元素（如不包含此项，则仅输出数组的元素类型以及元素数量

WithType：输出结果中包含字段或属性的类型名

UsingFullTypeName：使用完整的类型名（包含名字空间）

UsingTypeKeywords：使用C#的关键字来代替部分内置类型，如int表示Int32

WithName：输出结果中包含字段或属性的名称

SingleLine：单行输出（如果不包含此项，则会适当分行）

NullIsNull：如果输入对象是null，则转储结果为null，否则转储结果为字符串“<null>”

Default，DefaultBrief，DefaultBriefMultiLines：包括一些常用的选项。

 

DumpObject函数用于转储一个对象，DumpMethod函数用于转储一个方法的调用。对于下面这个程序：

 

ContractedBlock.gif ExpandedBlockStart.gif Code
    public class Test
    {
        private int m_field;

        public int Property
        {
            get
            {
                return m_field;
            }
        }

        public Test(int value)
        {
            m_field = value;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Test test = new Test(100);
            string dump = TextDump.DumpObject(test, ObjectDumpOptions.Fields | ObjectDumpOptions.Properties | ObjectDumpOptions.NonPublic | ObjectDumpOptions.Recurisive | ObjectDumpOptions.ExpandArray | ObjectDumpOptions.WithType | ObjectDumpOptions.WithName | ObjectDumpOptions.NullIsNull);

            Console.WriteLine(dump);
        }
    }

 

输出的结果是：

 

(Test)[
  m_field = (int)100,
  Property = (int)100
]

 

 

转载于:https://www.cnblogs.com/xlshcn/archive/2009/04/06/objectdump.html

ang142014
关注
在 QML 中，可以使用 console 对象来输出日志信息到调试控制台
m0_46376834的博客
03-16 750
在运行该 QML 代码时，输出的日志信息会显示在调试控制台中，帮助开发者跟踪应用程序的运行状态和排查问题。对象在 QML 中是一个非常有用的工具，可以帮助开发者更好地理解应用程序的执行过程。对象提供了一些方法用于在运行时输出调试信息，帮助开发者调试和诊断应用程序。对象来输出日志信息到调试控制台。类似于 JavaScript 中的。在 QML 中，可以使用。
php输出数据对象,php输出方式和变量及数据类型的认识
weixin_29124947的博客
03-10 1356
php的打印输出1. echo输出echo 回显,现率最高,但是没有返回值echo 打印多个变量 echo 变量1,变量2echo 可以输出html标签例:$email='admin@qq.com';$emails='admin@qq.com';echo $email;echo $emails;// echo输出html标签 .是连接符echo''.$email.'';2. print输出(打印数...
配合日志使用，用debug输出对象内容
lz12666的博客
03-20 382
我们现在都用lombak，tostring方法都被实现了所有参数的打印，加上这个tostring注解把父类的参数也搞出来，代码里经常需要debug整个对象的信息， 在可能发送异常的代码点用try-catch捕获下异常，然后处理，不要try-catch一大段代码，保障try-catch到点，不要一个点出问题，整个程序都不能跑了 ...
C#: Reflection
半亩方塘
09-22 919
反射(Reflection): 就是能够在运行时刻查询到类型信息的进程。他有以下的各个部分，可以根据你应用的需要选择其中的一个或者某些来使用：1． Assembly：使用它来定义和加载一些Assembly, 加载存在于Assembly 中的modules,并且可以得到这个Assembly的类型，同时创建他的实例（MSN原文：Use Assembly to define and load ass
Class 类 isInstance 和 isAssignableFrom
xpmail2014的博客
11-13 186
相同点就是都是可以判断是否可以实例化成当前类或者接口的对象。比如当前类，子类，接口的实现类。 区别的话， 1.isInstance传入的参数是对象。isAssignableFrom传入的参数是类。 2.如果传入null的话，isInstance会返回false，isAssignableFrom则会抛nullPointException....
CRNN安装
csdn-gs
03-09 4454
本来看中了crnn的end2end性能，结果一安装，我擦泪，坑怎么这么多。记住：CRNN库版本依赖非常严重！非常严重！严重！重！下面是我的安装记录，希望对大家有帮助~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~0、环境要求Ubuntu14 64位gcc版本5.4.0python源码编译的时...
C# 反射:Reflection用法速通
最新发布
qq_45397103的博客
03-28 510
C# Reflection的解析,包含实例
Javascript调试之console对象——你不知道的一些小技巧
12-10
比如`console.group("Group Title")`开始一个分组，然后输出相关信息，最后用`console.groupEnd()`结束分组。 在测试和调试过程中，我们常常需要验证某个条件是否满足。`console.assert()`方法允许我们在代码中设置...
C++ log调试日志输出
01-04
C++中的日志调试涉及自定义日志系统、使用第三方库和内置流对象。正确地设计和使用日志系统可以帮助开发者更快地定位问题，提高开发效率。在实际项目中，根据需求选择合适的方法并进行适当的优化，是实现高效日志...
Latex换行与高亮与其宏定义的使用
あなたの可愛い41
06-18 1282
Latex的换行写在前面宏定义的编写格式字体高亮换行宏定义与高亮的冲突 写在前面 因为latex的段落中的空行是需要代码来控制的，也就是 \ \newline \indent 但是在有的文章中，我们是需要频繁换行的，所以，我们就需要使用宏定义来优化代码的长度，这样也更加方便我们进行latex的编写 宏定义的编写格式 \def\skip#1{\ \newline \indent{#1}} 这个就是表示 \skip 等价于 \ \newline \indent 字体高亮 \usepackage{so
反射(8)程序集反射 Type 类
03-31 327
Type 类 表示类型声明：类类型、接口类型、数组类型、值类型、枚举类型、类型参数、泛型类型定义，以及开放或封闭构造的泛型类型。这个类是线程安全的。 Type 为 System.Reflection 功能的根，也是访问元数据的主要方式。使用 Type 的成员获取关于类型声明的信息，如构造函数、方法、字段、属性和类的事件，以及在其中部署该类的模块和程序集。 Type 是允许...
C#学习基本概念之Type类
weixin_33937913的博客
12-06 828
Type 类表示类型声明：类类型、接口类型、数组类型、值类型、枚举类型、类型参数、泛型类型定义，以及开放或封闭构造的泛型类型。（ Classes, Value types, Arrays, Interfaces, Enumerations, Delegates, Constructed generic types and generi...
图解C# Console 输出和Console相关编程复习总结
bcbobo21cn的专栏
04-20 1万+
1 基本控制台输出 首先进入 SharpDevelop ，新建一个控制台工程； SharpDevelop简介： http://blog.csdn.net/bcbobo21cn/article/details/44200205 using System; namespace conwrdemo { class Program { public static
如何在VBNET中使用调试输出类-Debug和Trace
weixin_34067980的博客
09-16 819
Debug类和Trace类位于System.Diagnostic命名空间. 默认情况下应用程序能够直接使用Debug和Trace对象,调用其方法. 它们的都提供了一组跟踪代码执行情况的方法和属性 主要方法列表 Assert方法          断言参数(表达式)的真或假 Write方法 WriteLine方法      输出...
console对象方法汇总及特殊输出
锋利的绵羊的博客
09-09 839
1.简单输出 console.log(); // 信息 console.info(); // log的别名 console.warn(); // 警告 console.error(); // 错误 console.clear(); // 清空输出 2.分组输出 console.group(); // 配合groupEnd对输出分组 console...
关于VS中的调试信息输出
weixin_34056162的博客
03-26 568
有时候一些项目的调试信息不方便输出到界面中，比如ASP.NET或者WPF之类的 可以使用Debug.WriteLine()等方法输出到“输出”窗口，不过“输出”窗口的内容比较多 可以让调试的输出信息转到“即时”窗口，这样比较干净一下，这个选项在“工具-&gt;选项-&gt;调试”中： 勾选“将所有输出窗口文本重定向到即时窗口” 这样就可以在“即时”窗口中查看调试输出信息了。 如果找不...
C# 输出对象信息
weixin_33829657的博客
10-20 912
2019独角兽企业重金招聘Python工程师标准>>> ...
C# DEBUG 调试信息打印及输出详解
热门推荐
aaaaatiger--寻路
05-12 4万+
1.debug只在[debug模式下才执行](运行按钮后面的下拉框可选)   2.debug提供了许多调试指令，如断言         System.Diagnostics.Debug.Assert(false,"信息");         将出现一个对话框    3.debug可以自定义监听器     (下例将信息存入磁盘文件)     System.Diagnostics.TextWr
[AS3]Flash小型日志信息输出器（调试）
弃天笑的程序世界
02-01 7324
最近忙得一回家就睡觉.........放个小东西，平时自己也有的。主要是用来输出flash的打印信息的........目的是让flash脱离了IDE依然可以输出信息，网络应该也有不少人写，呵呵。（我不是故意又写的，只是整理一下自己以前用的），简单说明一下功能......增加了XML配置文件，可以设置接受flash信息的接受器（分flash，socket服务器，http服务器）可通过配置文件修改信息
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值