Jsonconvert deserializeobject error

Hi

I’m using this code to deserialize my json data to list of objects as follow :

public static List<T> DeserializeListFromTempData<T>(HttpContext context, string strName)
        {
            List<T> lstResult = null;

            var iTempData = HelperMethods.GetTempData(context);
            var tmp = iTempData.Peek(strName);
            if (tmp != null)
            {
                lstResult = JsonConvert.DeserializeObject<List<T>>(tmp.ToString(), new JsonSerializerSettings { PreserveReferencesHandling = PreserveReferencesHandling.Objects });
            }

            return lstResult;
        }

And usage :

List<DefaultVisitProductDetails> lstPackageDetails = HelperMethods.DeserializeListFromTempData<DefaultVisitProductDetails>(this.HttpContext, "_lstPackageDetails");

The above codes works correctly. However, when i use it inside another generic method as follow :

public static void AttachDetailsListToDbContext<T, TDetails, TField>(HttpContext context, string strName, DbContext dbContext, object masterObjectGraph, Expression<Func<T, TDetails>> details, Expression<Func<T, TField>> field, TField value, InternalHelperAction action) where T : class
        {
List<TDetails> lstPackageDetails = HelperMethods.DeserializeListFromTempData<TDetails>(context, strName);
...
}

i’m facing the following problem :

Cannot deserialize the current JSON object (e.g. {«name»:»value»}) into type ‘System.Collections.Generic.ICollection`1[EFCoreTest.Models.DefaultVisitProductDetails]’ because the type requires
a JSON array (e.g. [1,2,3]) to deserialize correctly.
To fix this error either change the JSON to a JSON array (e.g. [1,2,3]) or change the deserialized type so that it is a normal .NET type (e.g. not a primitive type like integer, not a collection type like an array
or List<T>) that can be deserialized from a JSON object. JsonObjectAttribute can also be added to the type to force it to deserialize from a JSON object.

Where is the problem & how to solve it?

Thanks in advance

http://www.codeproject.com/KB/codegen/DatabaseHelper.aspx

Json.NET supports error handling during serialization and deserialization. Error handling lets
you catch an error and choose whether to handle it and continue with serialization or let the error
bubble up and be thrown in your application.

Error handling is defined through two methods:
the Error event on JsonSerializer and the OnErrorAttribute.

Error Event

The Error event is an event handler found on JsonSerializer. The error event is raised whenever an
exception is thrown while serializing or deserialing JSON. Like all settings found on JsonSerializer
it can also be set on JsonSerializerSettings and passed to the serialization methods on JsonConvert.

List<string> errors = new List<string>();

List<DateTime> c = JsonConvert.DeserializeObject<List<DateTime>>(@"[

  ""2009-09-09T00:00:00Z"",

  ""I am not a date and will error!"",

  [

    1

  ],

  ""1977-02-20T00:00:00Z"",

  null,

  ""2000-12-01T00:00:00Z""

]",

  new JsonSerializerSettings

    {

      Error = delegate(object sender, ErrorEventArgs args)

        {

          errors.Add(args.ErrorContext.Error.Message);

          args.ErrorContext.Handled = true;

        },

      Converters = { new IsoDateTimeConverter() }

    });

// 2009-09-09T00:00:00Z

// 1977-02-20T00:00:00Z

// 2000-12-01T00:00:00Z

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

// Unexpected token parsing date. Expected String, got StartArray.

// Cannot convert null value to System.DateTime.

In this example we are deserializing a JSON array to a collection of DateTimes. On the JsonSerializerSettings
a handler has been assigned to the Error event which will log the error message and mark the error as handled.

The result of deserializing the JSON is three successfully deserialized dates and three error messages:
one for the badly formatted string, «I am not a date and will error!», one for the nested JSON array and one
for the null value since the list doesn’t allow nullable DateTimes. The event handler has logged these messages
and Json.NET has continued on deserializing the JSON because the errors were marked as handled.

One thing to note with error handling in Json.NET is that an unhandled error will bubble up and raise the event
on each of its parents, e.g. an unhandled error when serializing a collection of objects will be raised twice,
once against the object and then again on the collection. This will let you handle an error either where it
occurred or on one of its parents.

JsonSerializer serializer = new JsonSerializer();

serializer.Error += delegate(object sender, ErrorEventArgs args)

  {

    // only log an error once

    if (args.CurrentObject == args.ErrorContext.OriginalObject)

      errors.Add(args.ErrorContext.Error.Message);

  };

If you aren’t immediately handling an error and only want to perform an action against it once then
you can check to see whether the ErrorEventArg’s CurrentObject is equal to the OriginalObject.
OriginalObject is the object that threw the error and CurrentObject is the object that the event is being raised
against. They will only equal the first time the event is raised against the OriginalObject.

OnErrorAttribute

The OnErrorAttribute works much like the other .NET serialization attributes that Json.NET supports.
To use it you simply place the attribute on a method which takes the correct parameters: a StreamingContext and a ErrorContext.
The name of the method doesn’t matter.

public class PersonError

{

  private List<string> _roles;

  public string Name { get; set; }

  public int Age { get; set; }

  public List<string> Roles

  {

    get

    {

      if (_roles == null)

        throw new Exception("Roles not loaded!");

      return _roles;

    }

    set { _roles = value; }

  }

  public string Title { get; set; }

  [OnError]

  internal void OnError(StreamingContext context, ErrorContext errorContext)

  {

    errorContext.Handled = true;

  }

}

In this example accessing the the Roles property will throw an exception when no roles have
been set. The HandleError method will set the error when serializing Roles as handled and allow Json.NET to continue
serializing the class.

PersonError person = new PersonError

  {

    Name = "George Michael Bluth",

    Age = 16,

    Roles = null,

    Title = "Mister Manager"

  };

string json = JsonConvert.SerializeObject(person, Formatting.Indented);

Console.WriteLine(json);

//{

//  "Name": "George Michael Bluth",

//  "Age": 16,

//  "Title": "Mister Manager"

//}