omarelabd / objectexporter

Object Exporter lets you export out an object while debugging in Visual Studio, the object can be serialized in either C#, JSON or XML.

Object Exporter

Object Exporter lets you export out an object while debugging in Visual Studio. Currently supported output formats are: C# Object Initialization Code, JSON and XML.

Release Notes

[1.7.0] (https://raw.githubusercontent.com/OmarElabd/ObjectExporter/master/ObjectExporter.VsPackage/Documentation/Release%20Notes.txt)

Use Cases

1. Persisting an object state for debugging comparisons.

2. Searching for information within objects.

3. Generating C# object initialization code for unit testing.

Output

The currently supported output formats are: C# Object Initialization Code, JSON and XML.

Instructions

Object Exporter is accessed through the tools menu and is only visible when you are debugging and stopped at a breakpoint.

Once the menu option is selected a dialog is shown with settings for the Object Export.

Object exporter has two modes for selecting objects to export, one is by selecting from a checklist which is populated with your locals.

The other mode is by writing a custom expression as you would in the watch window.

Once an object is written or selected, object exporter will attempt to calculate it's depth in the background. This depth will give you an indication of what cutoff would need to be specified to export the entire object. Note some objects may contain circular references.

Once your objects and settings are selected, you may export them in your desired format. A dialog will be displayed with the generated ouput for each of your objects.

C#:

JSON:

XML:

Settings

Object exporter settings is access through Tools -> Options -> Object Exporter

Powered By

Object Exporter is powered by RayGun.

objectexporter's Issues

Add depth solver to see object depths

It would be nice to have a preview of the object depths to better select an appropriate Maximum Object Depth.

FormatException: The string was not recognized as a valid DateTime. There is an unknown word starting at index 0.

Raygun report https://app.raygun.io/dashboard/cdlp9s/errors/752695690 has more details about the error

Add support for base properties

Convert UI to Visual Studio Window

Support for F#

Add support for F#

Add preprocessing for Expression COM Objects to be copied into new Type

Pros:

1. Errors can be detected earlier on
2. Cleaner Code
   a. Can move all the static methods into new Expression class
   b. Can now use foreach loops etc...
   c. Can now write some unit tests (Most important). And can use object exporter to export the project to test.

Cons:

1. Potentially longer execution time

Note: we are to some extent doing this already in the t4 templates.

Object initializer missing property assignemnt

Using VS2015 and C#6

Code generated:

var response = new Xyz.DomainObjects.OrderResponse
{
    new Xyz.DomainObjects.OrderDetails
    {
    ...

Should be:

var response = new Xyz.DomainObjects.OrderResponse
{
    OrderDetails = new Xyz.DomainObjects.OrderDetails
    {
    ...

Support for VS 2010

In progress.

Note: Version of VS 2010, will not have support for the async await that is utilized in the vs 2012 and 2013 versions. Background worker or synchronous methods will be used instead.

Base class properties

Please add (option) for base class properies

Generate usings for created Object

Convert UI to WPF (Remove WinForms Dependencies)

Do not set values for private fields

Private objects are included even if "Exclude Private" is selected

Example of what is produced:
AcquiredImageData = new System.Collections.Generic.List<MedAvail.Data.Messages.Dispense.AcquiredImageData>
{
},
BarCodeSummary = new System.Collections.Generic.List<MedAvail.Data.Messages.Dispense.BarCodeData>
{
},

...
_AcquiredImageData = new System.Collections.Generic.List<MedAvail.Data.Messages.Dispense.AcquiredImageData>
{
},
_BarCodeSummary = new System.Collections.Generic.List<MedAvail.Data.Messages.Dispense.BarCodeData>
{
}
...

Replace usage of EnvDTE.Expression with IDebugProperty

EnvDTE.Expressions provides limited information which is required by some of the new Object Exporter features.

Ignore known cruft such as Entity Framework proxies

OutOfMemoryException: Exception of type 'System.OutOfMemoryException' was thrown.

Raygun report https://app.raygun.io/dashboard/cdlp9s/errors/759164413 has more details about the error

Issue with Scaling on Image Buttons

Add Support for Nullables

Performance issues when exporting object

Reported performance issues when exporting large objects even under depth of 2.

Intellisense for exporting Custom Expressions

Intellisense similar to what is available in the immediate or watch window.

Display object depths for selected (or all items)

This should help determine an appropriate object depth. Can display infinity if a recursive graph is discovered.

DateTime with month twice

I've seen output with the month twice for DateTimes.

I think this line of code might be questionable:

https://github.com/OmarElabd/ObjectExporter/search?utf8=%E2%9C%93&q=%22dateTime.Month%2C+dateTime.Month%22

Add Support for Nullable Guids

Reported by @pawciut:

In version 1.2.4 nullable Guids are incorrect. They are present at C# code as
"new System.Guid?{ }" without property name to be assigned to.

example:

TypeCode = null,
new System.Guid?
{
},
TypeName = null,
Version = null,

or something like this:

Description = "Status główny",
DocumentId
Id
new System.Guid?
{
},
new System.Guid?
{
},

Properties with only getters are also generated for C#

Some properties are getters only. When I generate my C# Object from and paste it into my code, that code doesn't work because these are not allowed.

(BTW, awesome project, a real time saver for unit testing!)

Add support for setting objects with reserved property/field names

Example:

class = new List<string>
{
}

should be:

@class = new List<string>
{
}

Replace .Parse() calls with object creation

Export Specific Properties of an Object

Let user chose which properties they wish to export through a nested checkbox list.

Add support for System.Collections.Hashtable

If an object has a property of type Hashtable, the exported output is empty for that property:

new System.Collections.Hashtable
{
},

Debugger Values appearing in Variables

Depending on how the code was executed, the value of a variable may be a warning message from the compiler.

List:

1. A type or generic instantiation needed to evaluate this expression does not exist in the process being debugged

Issues when exporting a collection of objects (typeof object) with different types

Given some collection of type object, the collection members may be a different type other than object. However the code generated is not accurate.

Example:

items = new object[]
{
    new object {Some.Type}
    {
    }
}

when it should be:

items = new object[]
{
    new Some.Type
    {
    }
}

*Note: There are some special considerations for exporting value types within an object collection

 object[] obj = new object[]
            {
                new Form(),
                "Hello",
                2,
                DateTime.Now,
                22.24f,
                1.0m
            };

Add elapsed time to progress bar

Add option to ignore Entity Framework Proxy objects

EF generates child members with types of System.Data.Entity.DynamicProxies
.Blog_5E43C6C196972BF0754973E48C9C941092D86818CD94005E9A759B70BF6E48E6, these properties have some change tracking properties for efficiency. This doesn't make for a pleasant type, so we'll ignore this derived object and use the parent object instead.

Will detect types with "System.Data.Entity.DynamicProxies" then use the parent.

Issues with High DPI Scaling

Enum's should have there Class name included

Example:
Activity = Idle,
MovementType = Place

...should be:
Activity = MedCenter.Idle,
MovementType = MovementType.Place
etc.
Thanks!

Add Horizontal Scrolling to the Export UI for long variable names

This is a Telerik issue which I reported here:

http://feedback.telerik.com/Project/154/Feedback/Details/155730-fix-radcheckedlistbox-when-the-allowarbitraryitemwidth-property-is-set-to-true

Once it has been fixed I will incorporate it into Object Exporter

Add support for YAML as output

requested by a user on extension site

Add Support for Enums

For Xml and JSON this may involve getting the int value of the Enum.

For C#: This will involve setting the Enum value, which will require testing the property to determine if it is an Enum. This information can not be retrieved or deduced from the Expression, hence it will have to be determined from the Type.

Testing for enums may result in performance degradation.

Support for VB.NET

Add serialization support for VB.NET

Class with inheritence from List<T> not generating C# code

The inherited list class is empty when generating C# code for this class:

public class MyListClass : List<SomeTypicalClass>
{
}

Add support for exporting a Mock Object

Add setting to disable depth solver

this would be on the settings page and would be a parent to the max time and max depth options, if this is deselected they would both need to be grayed out.

Add support for C# 6.0 Initializers

This will need to be an option in the settings page to enable/disable. It's probably a good idea to enable it in VS 2015 by default and disable (by default) in earlier versions.

C# 6.0 Dictionary Initializer:

Dictionary<string, Customer> cList = new Dictionary<string, Customer>()
{
  ["A123"] = new Customer("A123"),
  ["B246"] = new Customer("B246")
};

Pre 6.0:

Dictionary<string, Customer> cList = new Dictionary<string, Customer>()
{
  {"A123", new Customer("A123")},
  {"B246", new Customer("B246")}
};

Add Send Error report on Failure

Not handling nullable DataTime correctly

DateTime looks good:

public class ObjectWithDate
{
    public DateTime ADateTime { get; set; }
}


        var objectWithDate = new ObjectWithDate
        {
            ADateTime = new DateTime(2015, 5, 29, 11, 45, 0),
        };

The export yields this (except the month issue, it looks good):
var objectWithDate = new MyNameSpace.ObjectWithDate
{
ADateTime = new DateTime(2015, 5, 5, 29, 11, 45, 0)
};

However if I change the type to nullable like so:

public class ObjectWithDate
{
    public DateTime? ADateTime { get; set; }
}

I get this:

var objectWithDate = new MyNameSpace.ObjectWithDate
{
new System.DateTime?
{
Date = new DateTime(2015, 5, 5, 29, 0, 0, 0),
Day = 29,
DayOfWeek = Friday,
DayOfYear = 149,
Hour = 11,
Kind = Unspecified,
Millisecond = 0,
Minute = 45,
Month = 5,
Second = 0,
Ticks = 635684967000000000,
TimeOfDay = new TimeSpan(0, 11, 45, 0, 0),
Year = 2015
}
};

Otherwise this is a great tool, keep up the good work.
Cheers,
Rob

Visual Studio 2015 - List Traversal broken

Object Exporter in VS2015 seems to be broken when it hits generic lists. It will not traverse down them. I tested the same code in 2013 and it worked perfectly. Here's my test case

namespace TestObjectExporter
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var test = new Data1
            {
                Name = "Data1",
                DataTwos = new List<Data2>
                {
                    new Data2
                    {
                        Name = "Data2",
                        DataThrees = new List<Data3>
                        {
                            new Data3
                            {
                                Name = "Data3"
                            },
                            new Data3
                            {
                                Name = "Data3"
                            },
                            new Data3
                            {
                                Name = "Data3"
                            }
                        }
                    },
                    new Data2
                    {
                        Name = "Data2",
                        DataThrees = new List<Data3>
                        {
                            new Data3
                            {
                                Name = "Data3"
                            },
                            new Data3
                            {
                                Name = "Data3"
                            },
                            new Data3
                            {
                                Name = "Data3"
                            }
                        }
                    },
                    new Data2
                    {
                        Name = "Data2",
                        DataThrees = new List<Data3>
                        {
                            new Data3
                            {
                                Name = "Data3"
                            },
                            new Data3
                            {
                                Name = "Data3"
                            },
                            new Data3
                            {
                                Name = "Data3"
                            }
                        }
                    }
                }
            };

            var count = test.DataTwos.Count;
            //breakpoint here
        }
    }

    public class Data1
    {
        public string Name { get; set; }
        public List<Data2> DataTwos { get; set; }
    }

    public class Data2
    {
        public string Name { get; set; }
        public List<Data3> DataThrees { get; set; }
    }

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

When I do an export with Max Object Depth = 7
Exclude private properties and fields = Checked

var test = new TestObjectExporter.Data1
{
    DataTwos = new System.Collections.Generic.List<TestObjectExporter.Data2>
    {
        Capacity = 4,
        Count = 3,
        System.Collections.Generic.ICollection<TestObjectExporter.Data2>.IsReadOnly = false,
        System.Collections.ICollection.IsSynchronized = false,
        System.Collections.ICollection.SyncRoot = {object},
        System.Collections.IList.IsFixedSize = false,
        System.Collections.IList.IsReadOnly = false,
        _items = new TestObjectExporter.Data2[]
        {
        },
        _size = 3,
        _syncRoot = {object},
        _version = 3
    },
    Name = "Data1"
};

Add Getting Started Guide

Resolve Recursions with Multiple Exported Objects in C# Generator

At the moment recursive objects are exported as is to a depth. In the C# generator we may be able to resolve recursive object references by generating these objects. This would require a change to the depth solver (and would probably require a C# depth solver and a JSON/XML depth solver).

We likely would not be able to do the same for XML/JSON since we output object values but can't link to another XML or JSON object.

Please consider adding explicit license to ObjectExporter

Would you consider adding a license file to this project? This would be consistent with good community practices and would allow others to build upon your work with a clear set of rules for what is acceptable.

For maximum compatibility with other free software projects, please consider using MIT license, such as expressed here:

https://github.com/intel352/vagrant-shell-scripts/blob/master/LICENSE.md

(replace the copyright statement with your copyright, of course)

Add support for visual studio theme awareness

Add JSON and XML support for Dictionaries

currently outputs:

    "Dict": 
    [
        [
            "Key": "a",
            "Value": "apple"
        ], 
        [
            "Key": "b",
            "Value": "bear"
        ], 
        [
            "Key": "c",
            "Value": "couch"
        ] 
    ], 

should output:

   "Dict": 
   {  
      "a":"apple",
      "b":"bear",
      "c":"couch"
   },