[opensourcedex]

Dumpify is a free, open source monitoring & observability project written in C# and released under MIT. It has 1,176 GitHub stars, 47 forks and 10 open issues, and was last pushed 4 months ago. On this registry it ranks #211 of 271 tracked projects in Monitoring & Observability, with 5 head-to-head comparisons available.

What is Dumpify?

Dumpify is an MIT-licensed C# library published on NuGet that adds .Dump() extension methods to console applications, giving .NET developers colourised, structured object output in the style of LINQPad for debugging, instrumentation and log-inspection work.

What it is

Dumpify is a .NET library that supplies .Dump() as an extension method on any object. A single call serialises the object into a structured, colourful representation and writes it to a chosen output target: the Console, Trace, Debug, plain Text, or a custom output the caller defines. It understands properties, fields and non-public members, follows nested objects, and renders arrays, dictionaries, collections, jagged and multidimensional arrays such as int[,].

The concrete problem it replaces is hand-written inspection code. In a console application there is no watch window, so developers routinely write Console.WriteLine statements, hand-rolled ToString() overrides, or temporary serialisers just to see what an object graph actually contains. Dumpify replaces that with one extension call that handles the formatting, the nesting, the circular references and the truncation of large collections, so the inspection code does not have to be written at all, and does not have to be deleted afterwards.

Key capabilities

  • .Dump() extension method callable on any object, including anonymous types, arrays, dictionaries and collections.
  • Selectable output targets: Console, Trace, Debug, Text and custom output sinks.
  • Member selection through MembersConfig, with IncludeFields and IncludeNonPublicMembers flags to surface private fields and private properties.
  • Circular reference and deep-nesting support, with depth control via the maxDepth parameter, for example moaid.Dump(maxDepth: 2).
  • Collection truncation through TruncationConfig, setting MaxCollectionCount and TruncationMode.Head, TruncationMode.Tail or TruncationMode.HeadAndTail, rendering markers such as [... 5 more].
  • Styling and customisation options, described in the README as highly configurable.
  • Performance described as fast, with rendering for multidimensional arrays and dictionaries.

Who uses it and how

  • Console application developers working in .NET who need to inspect object state without attaching a debugger or breaking execution.
  • Debugging workflows where a temporary Dump() call is added to a method and removed once the object graph has been understood.
  • Instrumentation and trace-listener setups, where .Dump() writes into Trace or Debug events and any listener attached to them picks the output up.
  • Developers who want LINQPad-style object rendering inside a plain console host rather than inside LINQPad itself.
  • Work on object graphs that contain cycles, such as a Person whose Spouse points back at it, where naive serialisation would recurse indefinitely.

Getting started

Install the Dumpify package from NuGet, either with dotnet add package Dumpify, Install-Package Dumpify, or the Visual Studio NuGet Package Manager. No server, service or container is required.

How it compares

The README positions Dumpify directly against LINQPad's .Dump() feature, and LINQPad is the only comparable tool named in the supplied facts. LINQPad is a standalone query and scratchpad environment with its own editor and runtime, whereas Dumpify is a MIT-licensed NuGet dependency that drops the same style of output into an ordinary console application that already exists.

When to use it — and when not to

Dumpify is a library, so a self-hoster operates nothing: there is no database, object store, SMTP server or daemon to run, only a package reference. It should not be chosen by teams that need durable, queryable, structured production logging, because its output targets are the console, Trace, Debug, text and custom sinks rather than a log store. The available documentation is the README and the project homepage, and the facts supplied here include only a partial README, so anyone needing exhaustive, versioned release notes should check the repository directly before adopting it.

project readme (upstream, from github) — read inline

Dumpify

drawing

Github version example workflow Publish Nuget Nuget Downloads GitHub Repo stars GitHub License

Improve productivity and debuggability by adding .Dump() extension methods to Console Applications. Dump any object in a structured and colorful way into the Console, Trace, Debug events or your own custom output.

How to Install

The library is published as a Nuget

Either run dotnet add package Dumpify, Install-Package Dumpify or use Visual Studio's NuGet Package Manager

Overview Video

An overview video hosted on the Open at Microsoft show


https://www.youtube.com/watch?v=ERWAMSgz-vc

Features

  • Dump any object in a structured, colorful way to Console, Debug, Trace or any other custom output
  • Support Properties, Fields and non-public members
  • Support max nesting levels
  • Support circular dependencies and references
  • Support styling and customizations
  • Highly Configurable
  • Support for different output targets: Console, Trace, Debug, Text, Custom
  • Fast!

Examples:

Anonymous types

new { Name = "Dumpify", Description = "Dump any object to Console" }.Dump();

image

Support nesting and circular references

var moaid = new Person { FirstName = "Moaid", LastName = "Hathot", Profession = Profession.Software };
var haneeni = new Person { FirstName = "Haneeni", LastName = "Shibli", Profession = Profession.Health };

moaid.Spouse = haneeni;
haneeni.Spouse = moaid;

moaid.Dump();
//You can define max depth as well, e.g `moaid.Dump(maxDepth: 2)`

image

Support for Arrays, Dictionaries and Collections

var arr = new[] { 1, 2, 3, 4 }.Dump();

image

var arr2d = new int[,] { {1, 2}, {3, 4} }.Dump();

image

new Dictionary<string, string>
{
   ["Moaid"] = "Hathot",
   ["Haneeni"] = "Shibli",
   ["Eren"] = "Yeager",
   ["Mikasa"] = "Ackerman",
}.Dump();

image

You can ensure that arrays, dictionaries and collections don't output too much by allowing results to be truncated. Do this by setting the MaxCollectionCount property in the TruncationConfig.

int[] arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// Outputs only the first 5 elements with a truncation marker
arr.Dump(truncationConfig: new TruncationConfig { MaxCollectionCount = 5 });
// Shows: 1, 2, 3, 4, 5, [... 5 more]

// You can also truncate from the tail (last N elements)
arr.Dump(truncationConfig: new TruncationConfig { MaxCollectionCount = 5, Mode = TruncationMode.Tail });
// Shows: [... 5 more], 6, 7, 8, 9, 10

// Or show both head and tail with truncation in the middle
arr.Dump(truncationConfig: new TruncationConfig { MaxCollectionCount = 6, Mode = TruncationMode.HeadAndTail });
// Shows: 1, 2, 3, [... 4 more], 9, 10

You can turn on or off fields and private members

public class AdditionValue
{
    private readonly int _a;
    private readonly int _b;

    public AdditionValue(int a, int b)
    {
        _a = a;
        _b = b;
    }

    private int Value => _a + _b;
}


new AdditionValue(1, 2).Dump(members: new MembersConfig { IncludeFields = true, IncludeNonPublicMembers = true });

image

You can provide a custom filter to determine if members should be included or not

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

    [JsonIgnore]
    public string SensitiveData { get; set; }
}

// Filter by attribute - exclude members with [JsonIgnore]
new Person()
{
    Name = "Moaid",
    SensitiveData = "We don't want this to show up"
}.Dump(members: new MembersConfig { MemberFilter = ctx => !ctx.Member.Info.CustomAttributes.Any(a => a.AttributeType == typeof(JsonIgnoreAttribute)) });

// Filter by value - exclude null or empty values (NEW!)
new Person()
{
    Name = "Moaid",
    SensitiveData = null
}.Dump(members: new MembersConfig { MemberFilter = ctx => ctx.Value is not null });

// Filter by depth - only show top-level properties (NEW!)
myNestedObject.Dump(members: new MembersConfig { MemberFilter = ctx => ctx.Depth == 0 });

The MemberFilter receives a MemberFilterContext which provides:

  • ctx.Member - Access to member metadata (Name, Type, Attributes)
  • ctx.Value - The actual value of the member (lazily evaluated)
  • ctx.Source - The parent object containing the member
  • ctx.Depth - The current nesting depth during rendering

### You can turn on or off row separators and a type column
```csharp
//globally
DumpConfig.Default.TableConfig.ShowMemberTypes = true;
DumpConfig.Default.TableConfig.ShowRowSeparators = true;

new { Name = "Dumpify", Description = "Dump any object to Console" }.Dump();

//or Per dump
new { Name = "Dumpify", Description = "Dump any object to Console" }.Dump(tableConfig: new TableConfig { ShowRowSeparators = true, ShowMemberTypes = true });

image

Customize table border style

If tables look garbled in your terminal (VS Code, Windows Terminal, etc.), you can change the border style:

// Use ASCII borders for maximum compatibility
DumpConfig.Default.TableConfig.BorderStyle = TableBorderStyle.Ascii;

// Or use Square borders (simpler Unicode characters)
DumpConfig.Default.TableConfig.BorderStyle = TableBorderStyle.Square;

// Available styles: Rounded (default), Square, Ascii, None, Heavy, Double, Minimal, Markdown

You can set custom labels or auto-labels

new { Description = "You can manually specify labels to objects" }.Dump("Manual label");

//Set auto-label globally for all dumps if a custom label wasn't provider
DumpConfig.Default.UseAutoLabels = true;
new { Description = "Or set labels automatically with auto-labels" }.Dump();

image

You can customize colors

var package = new { Name = "Dumpify", Description = "Dump any object to Console" };
package.Dump(colors: ColorConfig.NoColors);
package.Dump(colors: new ColorConfig { PropertyValueColor = new DumpColor(Color.RoyalBlue)});

image

You can turn on or off type names, headers, lables and much more

var moaid = new Person { FirstName = "Moaid", LastName = "Hathot", Profession = Profession.Software };
var haneeni = new Person { FirstName = "Haneeni", LastName = "Shibli", Profession = Profession.Health };
moaid.Spouse = haneeni;
haneeni.Spouse = moaid;

moaid.Dump(typeNames: new TypeNamingConfig { ShowTypeNames = false }, tableConfig: new TableConfig { ShowTableHeaders = false });

image

There are multiple output options (Console, Trace, Debug, Text) or provide your own

var package = new { Name = "Dumpify", Description = "Dump any object to Console" };
package.Dump(); //Similar to `package.DumpConsole()` and `package.Dump(output: Outputs.Console))`
package.DumpDebug(); //Dump to Visual Studio's Debug source
package.DumpTrace(); //Dump to Trace 
var text = package.DumpText(); //The table in a text format

using var writer = new StringWriter();
package.Dump(output: new DumpOutput(writer)); //Custom output

Custom Type Handlers

You can register custom handlers to control how specif

readme truncated — read the full docs on github

Frequently asked questions

Is Dumpify free to use?

Dumpify is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Dumpify do?

Adding `.Dump()` extension methods to Console Applications, similar to LinqPad's.

What is Dumpify written in?

Dumpify is primarily written in C#. Its source is publicly available at https://github.com/MoaidHathot/Dumpify, and it has 1,176 GitHub stars.