Click here to Skip to main content
Click here to Skip to main content
Go to top

fastJSON

, 4 Oct 2012
Rate this:
Please Sign up or sign in to vote.
Smallest, fastest polymorphic JSON serializer (with Silverlight4 support)
This is an old version of the currently published article.

Preface 

The code is now on CodePlex at http://fastjson.codeplex.com/ . I will do my best to keep this article and the source code on CodePlex in sync.

Introduction  

This is the smallest and fastest polymorphic JSON serializer, smallest because it's only 25kb when compiled, fastest because most of the time it is (see performance test section) and polymorphic because it can serialize and deserialize the following situation correctly at run-time with what ever object you throw at it:

class animal { public string Name { get; set;} }
class cat: animal { public int legs { get; set;} }
class dog : animal { public bool tail { get; set;} }
class zoo { public List<animal> animals { get; set;} }

var zoo1 = new zoo();

zoo1.animals = new List<animal>();
zoo1.animals.Add(new cat());
zoo1.animals.Add(new dog());

This is a very important point because it simplifies your coding immensely and is a cornerstone of object orientated programming, strangely few serializers handle this situation, even the  XmlSerializer in .NET  doesn't do this and you have to jump through hoops to get it to work. Also this is a must if you want to replace the BinaryFormatter serializer which what most transport protocols use in applications and can handle any .NET object structure (see my WCF Killer article).

The What and Why of JSON

JSON (Java Script Object Notation) is a text or human readable format invented by Douglas Crockford around 1999 primarily as a data exchange format for web applications (see www.JSON.org). The benefits of which are ( in regards to XML which was used before):

  • Structured data format like XML
  • High signal to noise ratio in other words it does away with extra characters which are not conclusive to the data ( angle brackets and slashes in XML)
  • Compact data format
  • Simple parsing rules which makes the processing of data easy and fast

So its good for the following scenarios:

  • Data exchange between same or different platforms like Java, .NET services over the wire.
  • Data storage: MongoDB (
Pros Cons
  • Can handle anything with a Serializable attribute on it
  • Pretty compact output
  • Version unfriendly : must be deserialized into the exact class that was serialized
  • Not good for storing of data because of the versioning problem
  • Not human readable
  • Not for communication outside of the same platform (e.g. both sides must be .NET)

Json.NET

The most referenced JSON serializer for the .NET framework is Json.NET from (http://JSON.codeplex.com/) and the blog site ( Pros Cons

  • Large dll size ~320kb
  • Slow in comparison to the rest in the list
  • Source code is hard to follow as it is large

LitJSON

I had to look around a lot to find this gem (http://litjson.sourceforge.NET/), which is still at version 0.5 since 2007. This was what I was using before my own implementation and it replaced the previous JSON serializer which was Json.NET. Admittedly I had to change the original to fit the requirements stated above.

Pros Cons
  • Can do all that Json.NET does (after my changes).
  • Small dll size ~57kb
  • Relatively fast
  • Didn't handle datasets in the original source code ( I wrote it my self afterwards in my own application)
  • The lexer class is difficult to follow
  • Requires .NET 3.5 ( Got around this limitation by implementing a Linqbridge class which works with .NET 2.0)

ServiceStack Serializer

An amazingly fast JSON serializer from Demis Bellot found at (http://www.servicestack.NET/mythz_blog/?p=344). The serializer speed is astonishing, although it does not support what is needed from the serializer. I have included it here as a measure of performance.

Pros     Cons  
  • Amazingly fast serializer
  • Pretty small dll size ~91kb  
  • Can't handle polymorphic object collections
  • Requires at least .NET 3.5
  • Fails on Nullable types
  • Fails on Datasets
  • Fails on other "exotic" types like dictionaries, hash tables etc.

Microsoft Json Serializer  (v1.7 update)

By popular demand and my previous ignorance about the Microsoft JSON implementation and thanks to everyone who pointed this out to me, I have added this here.

Pros      Cons
  • Included in the framework
  • Can serialize basic polymorphic objects
  • Can't deserialize polymorphic objects
  • Fails on Datasets
  • Fails on other "exotic" types like dictionaries, hash tables etc.
  • 4x slower that fastJSON in serialization

Using the code

To use the code do the following:

// to serialize an object to string
string jsonText = fastJSON.JSON.Instance.ToJSON(c);

// to deserialize a string to an object
var newobj = fastJSON.JSON.Instance.ToObject(jsonText);

The main class is JSON which is implemented as a singleton so it can cache type and property information for speed. 

Additions in v1.7.5

// you can set the defaults for the Instance which will be used for all calls
JSON.Instance.UseOptimizedDatasetSchema = true; // you can control the serializer dataset schema
JSON.Instance.UseFastGuid = true;               // enable disable fast GUID serialization
JSON.Instance.UseSerializerExtension = true;    // enable disable the $type and $map inn the output

// you can do the same as the above on a per call basis
public string ToJSON(object obj, bool enableSerializerExtensions)
public string ToJSON(object obj, bool enableSerializerExtensions, bool enableFastGuid)
public string ToJSON(object obj, bool enableSerializerExtensions, bool enableFastGuid, bool enableOptimizedDatasetSchema)

// Parse will give you a Dictionary<string,object> with ArrayList representation of the JSON input
public object Parse(string json)

// if you have disabled extensions or are getting JSON from other sources then you must specify
// the deserialization type in one of the following ways
public T ToObject<T>(string json)
public object ToObject(string json, Type type)

Additions v1.7.6

JSON.Instance.SerializeNullValues = true;    // enable disable null values to output

public string ToJSON(object obj, bool enableSerializerExtensions, bool enableFastGuid, bool enableOptimizedDatasetSchema, bool serializeNulls)
 

Additions v1.8

For all those who requested why there is no support for type "X", I have implemented a open closed principal extension to fastJSON which allows you to implement your own routines for types not supported without going through the code.

To allow this extension you must compile with CUSTOMTYPE compiler directive as there is a performance hit associated with it.

public void main()
{
     fastJSON.JSON.Instance.RegisterCustomType(typeof(TimeSpan), tsser, tsdes);
     // do some work as normal
}

private static string tsser(object data)
{
     return ((TimeSpan)data).Ticks.ToString();
}

private static object tsdes(string data)
{
     return new TimeSpan(long.Parse(data))
}

Performance Tests 

All test were run on the following computer:

  • AMD K625 1.5Ghz Processor
  • 4Gb Ram DDR2
  • Windows 7 Home Premium 64bit
  • Windows Rating of 3.9

The tests were conducted under three different .NET compilation versions

  • .NET 3.5
  • .NET 4 with processor type set to auto
  • .NET 4 with processor type set to x86

The Excel screen shots below are the results of these test with the following descriptions:

  • The numbers are elapsed time in milliseconds.
  • The more red the background the slower the times
  • The more green the background the faster the times.
  • 5 tests were conducted for each serializer.
  • The "AVG" column is the average for the last 4 tests excluding the first test which is basically the serializer setting up its internal caching structures, and the times are off.
  • The "min" row is the minimum numbers in the respective columns below.
  • The Json.NET serializer was tested with two version of 3.5r6 and 4.0r1 which is the current one.
  • "bin" is the BinaryFormatter tests which for reference.
  • The test structure is the code below which is a 5 time loop with an inner processing of 1000 objects.
  • Some data types were removed from the test data structure so all serializers could work.

The test code template

The following is the basic test code template, as you can see it is a loop of 5 tests of what we want to test each done count time (1000 times). The elapsed time is written out to the console with tab formatting so you can pipe it to a file for easier viewing in an Excel spreadsheet.

int count = 1000;
private static void fastjson_serialize()
{
	Console.WriteLine();
	Console.Write("fastjson serialize");
	for (int tests = 0; tests < 5; tests++)
	{
		DateTime st = DateTime.Now;
		colclass c;
		string jsonText = null;
		c = CreateObject();
		for (int i = 0; i < count; i++)
		{
			jsonText = fastJSON.JSON.Instance.ToJSON(c);
		}
		Console.Write("\t" + DateTime.Now.Subtract(st).TotalMilliseconds + "\t");
	}
}

The test data structure

The test data are the following classes which show the polymorphic nature we want to test. The "colclass" is a collection of these data structures. In the attached source files more exotic data structures like Hashtables, Dictionaries, Datasets etc. are included.

[Serializable()]
public class baseclass
{
    public string Name { get; set; }
    public string Code { get; set; }
}

[Serializable()]
public class class1 : baseclass
{
    public Guid guid { get; set; }
}

[Serializable()]
public class class2 : baseclass
{
    public string description { get; set; }
}

[Serializable()]
public class colclass
{
    public colclass()
    {
        items = new
List<baseclass>();
        date = DateTime.Now;
        multilineString = @"
        AJKLjaskljLA
   ahjksjkAHJKS
   AJKHSKJhaksjhAHSJKa
   AJKSHajkhsjkHKSJKash
   ASJKhasjkKASJKahsjk
        ";
        gggg = Guid.NewGuid();
        //hash = new Hashtable();
        isNew = true;
        done= true;
    }
    public bool done { get; set; }
    public DateTime date {get; set;}
    //public DataSet ds { get; set; }
    public string multilineString { get; set; }
    public List<baseclass> items { get; set; }
    public Guid gggg {get; set;}
    public decimal? dec {get; set;}
    public bool isNew { get; set; }
    //public Hashtable hash { get; set; }

}

.NET 3.5 Serialize

  • fastJSON is second place in this test by a margin of nearly 35% slower than Stacks.
  • fastJSON is nearly 2.9x faster than binary formatter.
  • Json.NET is nearly 1.9x slower in the new version 4.0r1 against its previous version of 3.5r6
  • Json.NET v3.5r6 is nearly 20% faster than binary formatter.

.NET 3.5 Deserialize

  • fastJSON is first place in this test to Stacks by a margin of 10%.
  • fastJSON is nearly 4x faster than nearest other JSON.
  • Json.NET is nearly 1.5x faster in version 4.0r1 than its previous version of 3.5r6

.NET 4 Auto Serialize

  • fastJSON is first place in this test by a margin of nearly 20% against Stacks.
  • fastJSON is nearly 4.9x faster than binary formatter.
  • Json.NET v3.5r6 is on par with binary formatter.

.NET 4 Auto Deserialize

  • fastJSON is first place by a margin of 11%.
  • fastJSON is 1.7x faster than binary formatter.
  • Json.NET v4 1.5x faster than its previous version.

.NET 4 x86 Serialize

  • fastJSON is first place in this test by a margin of nearly 21% against Stacks.
  • fastJSON is 4x faster than binary formatter.
  • Json.NET v3.5r6 1.7x faster than the previuos version.

.NET 4 x86 Deserialize

  • fastJSON is first place by a margin of 5% against Stacks.
  • fastJSON is 1.7x faster than binary formatter which is third.

Exotic data type tests

In this section we will see the performance results for exotic data types like datasets, hash tables, dictionaries, etc.. The comparison is between fastJSON and the BinaryFormatter as most of the other serializers can't handle these data types. These include the following:

  • Datasets
  • Nullable types
  • Hashtables
  • Dictionaries

fastJSON/exotic.png

  • fastJSON is 5x faster than BinaryFormatter in serialization
  • fastJSON is 20% faster than BinaryFormatter in deserialization
  • Datasets are performance killers by a factor of 10  

Performance Conclusions

  • fastJSON is faster in all test except the when running the serializer under .NET 3.5 for which Stacks is faster by only 35% (note must be made that Stacks is not polymorphic and can't handle all types so it is not outputting data correctly within the tests).
  • .NET 4 is faster than .NET 3.5 by around 15% in these test except for the fastJSON serializer which is 90% faster..
  • You can replace BinaryFormatter with fastJSON with a huge performance boost ( this lean way lends it self to compression techniques on the text output also).
  • Start up costs for fastJSON is on average 2x faster than Stacks and consistently faster than everyone else.   

Performance Conclusions v1.4

fastJSON/v1.4.png

As you can see from the above picture v1.4 is noticably faster. The speed boost make fastJSON faster than SerializerStack in all tests even on .net v3.5.

  • fastJSON serializer is 6.7x faster than binary with a dataset. 
  • fastJSON deserializer is 2.1x faster than binary with a dataset.
  • fastJSON serializer is 6.9x faster than binary without a dataset.
  • fastJSON deserializer is 1.6x faster than binary without a dataset.

Performance Conclusions v1.5

fastJSON/v1.5.png

  • The numbers speak for themselves fastJSON serializer 6.65x faster without dataset and 6.88x faster than binary, the deserializer is 2.7x faster than binary.
  • The difference in numbers in v1.5 which is slower than v1.4 is because of extra properties in the test for Enums etc.

Performance Conclusions v1.6

fastJSON/v1.6.png

  • Guid are 2x faster now with base64 encoding you can revert back to old style with the UseFastGuid = false on the JSON.Instance
  • Datasets are ~40% smaller and ~35% faster.
  • fastJSON serializer is now ~2.3x faster than deserializer and the limit seems to be 2x.

Performance Conclusions v1.7

fastJSON/v1.7.png

  • int, long parse are 4x faster.
  • unicode string optimizations, reading and writing non english strings are faster.
  • ChangeType method optimized 
  • Dictionary optimized  using TryGetValue

Points of Interest 

I did a lot of performance tuning with a profiler and here are my results:

  • Always use a StringBuilder and never strings concats.
  • Never do the following stringbuilder.append("string1 + "string2") because it kills performance, replace it with two stringbuilder appends. This point blew my mind and was 50% faster in my tests with the profiler.
  • Never give the stringbuilder a capacity value to start with e.g. var stringbuilder = new StringBuilder(4096); . Strange but it is faster without it.
  • I tried replacing the StringBuiler with a MemoryStream but it was too slow (100% slower).  
  • The simplest and the most direct way is probably the fastest as well, case in point reading values as opposed to lexer parser implementations.
  • Always use cached reflection properties on objects.

Appendix v1.9.8

Some reformatting was done to make the use of fastJSON easier in this release which will break some code but is ultimately better in the long run. To use the serializer in this version you can do the following :

// per call customization of the serializer
string str = fastJSON.JSON.Instance.ToJSON(obj, 
                 new fastJSON.JSONParamters { EnableAnonymousTypes = true }); // using the parameters

fastJSON.JSON.Instance.Parameters.UseExtensions = false; // set globally

This removes a lot of the ToJSON overloads and gives you more readable code.

Also in this release support for anonymous types has been added, this will give you a JSON string for the type, but deserialization is not possible at the moment since anonymous types are compiler generated.

DeepCopy has been added which allows you to create an exact copy of your objects which is useful for business application rollback/cancel semantics.

Appendix v2.0.0

Finally got round to adding Unit Tests to the project (mostly because of some embarrassing bugs that showed up in the changes), hopefully the tests cover the majority of use cases, and I will add more in the future. 

Also by popular demand you can now deseialize root level basic value types, Lists and Dictionaries. So you can use the following style code : 

var o = fastJSON.JSON.Instance.ToObject<List<Retclass>>(s); // return a generic list

var o = fastJSON.JSON.Instance.ToObject<Dictionary<Retstruct, Retclass>>(s); // return a dictionary

A breaking change in this version is the Parse() method now returns number formats as long and decimal not string values, this was necessary for array returns and compliance with the json format (keep the type information in the original json, and not loose it to strings).  So the following code is now working :

List<int> ls = new List<int>();
ls.AddRange(new int[] { 1, 2, 3, 4, 5, 10 }); 
var s = fastJSON.JSON.Instance.ToJSON(ls);
var o = fastJSON.JSON.Instance.ToObject(s); // long[] {1,2,3,4,5,10}

Be aware that if you do not supply the type information the return will be longs not ints.  To get what you expect use the following style code:

var o = fastJSON.JSON.Instance.ToObject<List<int>>(s); // you get List<int>

Check the unit test project for sample code regarding the above cases.

Appendix v2.0.3 -  Silverlight Support

Microsoft in their infinate wisdom has removed some functionality which was in Silverlight4 from Silverlight5. So fastJSON will not build or work on Silverlight5.

History   

  • Initial Release : 2011/02/20  
  • Update v1.1 : 26% performance boost on dataset deserialization, corrected ServiceStack name
  • Update v1.2 : System.DBNull serialized to null, CultureInfo fix for numbers, Readonly properties handled correctly
  • Update v1.3 : Removed unused code (lines now at 780), Property comma fix
  • Update v1.4 : Heavy optimizations (serializer 3% faster, deserializer  50% faster, dataset serializer 46% faster, dataset deserializer 26% faster) [ now officially faster than the serializer ServiceStack in all test even on .net 3.5]
  • Update v1.5 : Heavy optimizations (deserializer ~50% faster than v1.4), Enum fix, Max Depth property for serializer. Special thanks and credits to Simon Hewitt for optimizations in this version. 
  • Update v1.6 :
    • value type arrays handled 
    • guid 2x faster
    • datasets ~40% smaller
    • serializer ~2% to 11% faster
    • deserializer ~6% to 38% faster
  • Update v1.7 :
    • added microsoft json evaluation
    • added consoletest project to downloads for testing newer exotic types
    • bug fix dictionary deserialize
    • special case handles List<object[]> 
    • int and long parse 4x faster
    • unicode string optimize
    • changetype optimize
    • dictionary optimize
    • deserialize embeded class e.g. Sales.Customer
    • safedictionary check before add
    • handles object ReturnEntity = new object[] { object1, object2 }
    • handles object ReturnEntity = Guid, Dataset, valuetype
  • Update v1.7.5 :
    • ability to serialize without extensions
    • overloaded methods for serialize and deserialize
    • the deserializer will do its best to deserialize the input with or without extensions with no gaurantee on polymorphism 
  • Update v1.7.6 :
    • XmlIgnore handled : thanks to Patrik Oscarsson for the idea
    • special case optimized output for dictionary of string,string
    • bug fix year 1 date output as 0000 string
    • override serialize nulls to output : thanks again to Patrik
  • Update v1.7.7 :
    • Indented output
    • Datatable support
    • bug fix
  • Update v1.7.7 Silverlight4 : 4th June 2011
    • A new project added for silverlight4, currently in testing phase will add to main zip when all ok.
    • Silverlight lacks arraylist, dataset, datatable, hashtable support
    • #if statements in source files for silverlight4 support. 
  • Update v1.8 :  9th June 2011
    • Silverlight code merged into the project
    • Seperate Silverlight project 
    • RegisterCustomType extension for user defined serialization routines
    • CUSTOMTYPE compiler directive
  • Update v1.9 : 28th June 2011
    • added support for public fields
  • Update v1.9.1 : 30th June 2011
    • fixed a shameful bug when SerializeNullValues = false, special thanks to Grant Birchmeier for testing 
  • Update v1.9.2 : 10th July 2011
    • fixed to fullname instead of name when searching for types in property cache (namespace1.myclass , namespace2.myclass are now different) thanks to alex211b
  • Update v1.9.3 : 31st July 2011
    • UTC datetime handling via UseUTCDateTime = true property thanks to mrkappa
    • added support for enum as key in dictionary thanks to Grant Birchmeier
  • Update v1.9.4 : 23rd September 2011
    • ShowReadOnlyProperties added for exporting readonly properties (default = false)
    • if datetime value ends in "Z" then automatic UTC time calculated
    • if using UTC datetime the output end in a "Z" (standards compliant)
  • Update v1.9.6 : 26th November 2011
    • bug fix datatable schema serialize & deserialize
    • added a $types extension for global type definitions which reduce the size of the output json thanks to Marc Bayé for the idea
    • added UsingGlobalTypes config for controling the above (default = true)
    • bug fix datatable commas between arrays and table definitions (less lint complaining)
    • string key dictionaries are serialized optimally now (not K V format)
  • Update v1.9.7 : 10th May 2012 
    • bug fix SilverLight version to support GlobalTypes
    • removed indent logic from serializer
    • added Beautify(json) method to JSON credits to Mark http://stackoverflow.com/users/65387/mark
    • added locks on SafeDictionary
    • added FillObject(obj,json) for filling an existing object
  • Update v1.9.8 : 17th May 2012
    • added DeepCopy(obj) and DeepCopy<T>(obj)
    • refactored code to JSONParameters and removed the JSON overloads
    • added support to serialize anonymous types (deserialize is not possible at the moment) 
    • bug fix $types output with non object root
  • Update v1.9.9 : 24th July 2012
    • spelling mistake on JSONParameters
    • bug fix Parameter initialization
    • bug fix char and string ToString
    • refactored reflection code into Reflection class
    • added support for top level struct object serialize/deserialize
  • Update v2.0.0 : 4th August 2012
    • bug fix reflection code
    • added unit tests
    • deserialize root level arrays (int[] etc.)
    • deserialize root level value types (int,long,decimal,string)
    • deserialize ToObject< Dictionary<T,V> > 
    • deserialize ToObject< List<T> >
    • * breaking change in Parse , numbers are returned as decimals and longs not strings
  • Update v2.0.1 : 10th August 2012
    • bug fix preserve internal objects when FillObject called
    • changed ArrayList to List<object> and consolidated silverlight code
    • added more tests
    • speed increase when using global types ($types)
  • Update v2.0.2 : 16th August 2012
    • bug fix $types and arrays
  • Update v2.0.3 : 27th August 2012
    • readonly property checking on deserialize (thanks to Slava Pocheptsov)
    • bug fix deserialize nested types with unit test (thanks to Slava Pocheptsov)
    • fix the silverlight4 project build (silverlight5 is not supported)
  • Update v2.0.4 : 7th September 2012
    • fixed null objects -> returns "null"
    • added sealed keyword to classes
    • bug fix SerializeNullValues=false and an extra comma at the end
    • UseExtensions=false will disable global types also  (thanks to qio94, donat.hutter, softwarejaeger)
    • fixed parameters setting for Parse()
  • Update v2.0.5 : 17th September 2012 
    • fixed number parsing for invariant format
    • added a test for German locale number testing (,. problems)
  • Update v2.0.6 : 19th September 2012  
    • singleton uses [ThreadStatic] for concurrency (thanks to Philip Jander)
    • bug fix extra comma in the output when only 1 property in the object (thanks to Philip Jander)
  • Update v2.0.7 : 5th October 2012  
    • bug fix missing comma with single property and extensions enabled

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Mehdi Gholam
Architect
United Kingdom United Kingdom
Mehdi first started programming when he was 8 on BBC+128k machine in 6512 processor language, after various hardware and software changes he eventually came across .net and c# which he has been using since v1.0.
He is formally educated as a system analyst Industrial engineer, but his programming passion continues.
 
* Mehdi is the 5th person to get 6 out of 7 Platinums on CodeProject (13th Jan'12)

Comments and Discussions


Discussions posted for the Published version of this article. Posting a message here will take you to the publicly available article in order to continue your conversation in public.
 
GeneralRe: Add binary option to fastJSON PinmemberPelle Penna8-Apr-14 4:06 
QuestionJSON.cs code not thread-safe Pinmemberdjmarcus4-Apr-14 17:07 
AnswerRe: JSON.cs code not thread-safe PinmvpMehdi Gholam5-Apr-14 2:07 
GeneralRe: JSON.cs code not thread-safe Pinmemberdjmarcus5-Apr-14 3:18 
AnswerRe: JSON.cs code not thread-safe PinmemberAnton Afanasyev6-Apr-14 12:11 
GeneralRe: JSON.cs code not thread-safe Pinmemberdjmarcus6-Apr-14 15:13 
SuggestionExpose Max Depth as a Parameter PinmemberMartin Thwaites4-Apr-14 1:33 
GeneralRe: Expose Max Depth as a Parameter PinmvpMehdi Gholam4-Apr-14 1:50 
GeneralRe: Expose Max Depth as a Parameter PinmemberMartin Thwaites4-Apr-14 2:23 
GeneralRe: Expose Max Depth as a Parameter PinmemberMartin Thwaites4-Apr-14 3:25 
GeneralRe: Expose Max Depth as a Parameter PinmvpMehdi Gholam4-Apr-14 3:43 
GeneralRe: Expose Max Depth as a Parameter PinmvpMehdi Gholam5-Apr-14 4:56 
GeneralRe: Expose Max Depth as a Parameter PinmvpMehdi Gholam6-Apr-14 22:21 
BugBug or per design - Predefined values PinmemberPelle Penna24-Mar-14 19:59 
GeneralRe: Bug or per design - Predefined values PinmvpMehdi Gholam24-Mar-14 20:40 
GeneralRe: Bug or per design - Predefined values PinmemberPelle Penna24-Mar-14 21:09 
GeneralRe: Bug or per design - Predefined values PinmemberPelle Penna27-Mar-14 3:43 
GeneralRe: Bug or per design - Predefined values PinmvpMehdi Gholam27-Mar-14 6:19 
QuestionCOM wrapper? Pinmemberaikimark17-Mar-14 7:00 
AnswerRe: COM wrapper? PinmvpMehdi Gholam17-Mar-14 9:43 
QuestionJIL Pinmemberaikimark17-Mar-14 5:40 
AnswerRe: JIL PinmvpMehdi Gholam17-Mar-14 6:24 
GeneralRe: JIL Pinmemberaikimark17-Mar-14 6:56 
QuestionCan't convert List<Dictionary<string, string>> (in a simple way) PinmemberElsePopelse12-Mar-14 2:30 
AnswerRe: Can't convert List<Dictionary<string, string>> (in a simple way) PinmvpMehdi Gholam12-Mar-14 3:20 
GeneralRe: Can't convert List<Dictionary<string, string>> (in a simple way) PinmemberMember 1069958125-Mar-14 20:01 
GeneralRe: Can't convert List<Dictionary<string, string>> (in a simple way) PinmvpMehdi Gholam27-Mar-14 6:18 
SuggestionCustom ignore attributes. Replace [XmlIgnore] with my own or none. PinmemberJaredThirsk9-Mar-14 4:34 
GeneralRe: Custom ignore attributes. Replace [XmlIgnore] with my own or none. PinmvpMehdi Gholam9-Mar-14 21:37 
GeneralRe: Custom ignore attributes. Replace [XmlIgnore] with my own or none. PinmemberJaredThirsk10-Mar-14 3:50 
GeneralRe: Custom ignore attributes. Replace [XmlIgnore] with my own or none. PinmvpMehdi Gholam10-Mar-14 4:14 
BugGetting error during conversion of Nullable Types PinmemberSanjay K. Gupta4-Mar-14 19:58 
GeneralRe: Getting error during conversion of Nullable Types PinmvpMehdi Gholam4-Mar-14 21:37 
QuestionNot serializing the entire object PinmemberALI_TN2-Mar-14 23:44 
AnswerRe: Not serializing the entire object PinmvpMehdi Gholam3-Mar-14 1:06 
QuestionKVStyleStringDictionary does not apply to derived classes Pinmemberpaag18-Feb-14 2:28 
AnswerRe: KVStyleStringDictionary does not apply to derived classes PinmvpMehdi Gholam18-Feb-14 3:32 
QuestionHuman readable $type, and tag renaming [modified] PinmemberRainer Gustin11-Feb-14 18:04 
AnswerRe: Human readable $type, and tag renaming PinmvpMehdi Gholam11-Feb-14 18:54 
QuestionDateTimeOffset type PinmemberMabakay6-Feb-14 22:51 
AnswerRe: DateTimeOffset type PinmvpMehdi Gholam6-Feb-14 23:21 
QuestionLimitations Pinmemberkspeakman2-Feb-14 14:11 
AnswerRe: Limitations PinmvpMehdi Gholam2-Feb-14 16:24 
AnswerRe: Limitations PinmvpMehdi Gholam21-Mar-14 6:52 
GeneralMy vote of 5 PinmemberNitinSingh20-Jan-14 18:55 
QuestionEnums Serialization problem Pinmemberudi_m6-Jan-14 23:11 
AnswerRe: Enums Serialization problem PinmvpMehdi Gholam6-Jan-14 23:28 
AnswerRe: Enums Serialization problem PinmvpMehdi Gholam8-Jan-14 6:21 
GeneralRe: Enums Serialization problem PinmemberJaredThirsk8-Jan-14 7:59 
GeneralRe: Enums Serialization problem Pinmemberudi_m12-Jan-14 3:45 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

About Article
| Advertise | Privacy | Mobile
Web04 | 2.8.140922.1 | Last Updated 5 Oct 2012
Article Copyright 2011 by Mehdi Gholam
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid