Dumpify

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

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();

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)`

Support for Arrays, Dictionaries and Collections

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

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

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

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 tableConfig.

int[] arr = [1, 2, 3, 4];

// Outputs only the first two elements and a message that says: ... truncated 2 items
arr.Dump(tableConfig: new () { MaxCollectionCount = 2 });

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 });

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; }
}

new Person()
{
    Name = "Moaid",
    SensitiveData = "We don't want this to show up"
}.Dump(members: new MembersConfig { MemberFilter = member => !member.Info.CustomAttributes.Any(a => a.AttributeType == typeof(JsonIgnoreAttribute)) });

You can turn on or off row separators and a type column

//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 });

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();

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)});

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 });

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

Every configuration can be defined per-Dump or globally for all Dumps, e.g:

DumpConfig.Default.TypeNamingConfig.UseAliases = true;
DumpConfig.Default.TypeNamingConfig.ShowTypeNames = false;
DumpConfig.Default.ColorConfig.TypeNameColor = Color.Gold;
DumpConfig.Default.MaxDepth = 3;
//Much more...

Features for the future 0.7.0 release

Add configuration for formatting Anonymous Objects type names
Text renderer
Better rendering of Delegates
Write the Count values of dictionaries and IEnumerables in the name, e.g Dictionary<string, string>(3)
Add an option to limit how many elements to render for collections and arrays.
consider changing the default color scheme to VSCode's
Documentation
Consider changing the style/view of ObjectDescriptors without properties (currently empty table)
Fix simplified type names with Collection expressions (IEnumearble col = [1, 2, 3]);

To do

Live outputs
Add custom rendering for more types:
- Exceptions, AggregateExceptions, etc...
Rethink Generators caching keys
Ditch ObjectIdGenerator and create a custom, modern implementation
Consider using Max Depth for Descriptors
Refactor Renderers and make it better extendable
Add more renderers
- Text Renderers
- re-introduce Json
- CSharp Renderer
Consider Decoupling from Spectre.Console
Tests
- More tests
- Visual (Render) Tests - consider acceptance tests
- Tests for Nesting
More sync between Custom Descriptors and Custom Renderers
- Think how we can mark type's descriptor as needing special rendering.
- The current CustomDescriptorGenerator must generate a value
- Consider ValueTuple
Refactor SpectureTableRenderer to share customization code

MoaidHathot/Dumpify