You can use json2csharp.com to Convert your json to object model

• Go to json2csharp.com
• Past your JSON in the Box.
• Clik on Generate.
• You will get C# Code for your object model
• Deserialize by var model = JsonConvert.DeserializeObject<RootObject>(json); using NewtonJson

Here, It will generate something like this:

public class MatrixModel
{
    public class Option
    {
        public string text { get; set; }
        public string selectedMarks { get; set; }
    }

    public class Model
    {
        public List<Option> options { get; set; }
        public int maxOptions { get; set; }
        public int minOptions { get; set; }
        public bool isAnswerRequired { get; set; }
        public string selectedOption { get; set; }
        public string answerText { get; set; }
        public bool isRangeType { get; set; }
        public string from { get; set; }
        public string to { get; set; }
        public string mins { get; set; }
        public string secs { get; set; }
    }

    public class Question
    {
        public int QuestionId { get; set; }
        public string QuestionText { get; set; }
        public int TypeId { get; set; }
        public string TypeName { get; set; }
        public Model Model { get; set; }
    }

    public class RootObject
    {
        public Question Question { get; set; }
        public string CheckType { get; set; }
        public string S1 { get; set; }
        public string S2 { get; set; }
        public string S3 { get; set; }
        public string S4 { get; set; }
        public string S5 { get; set; }
        public string S6 { get; set; }
        public string S7 { get; set; }
        public string S8 { get; set; }
        public string S9 { get; set; }
        public string S10 { get; set; }
        public string ScoreIfNoMatch { get; set; }
    }
}

Then you can deserialize as:

var model = JsonConvert.DeserializeObject<List<MatrixModel.RootObject>>(json);

As others have already pointed out, the reason you are not getting the results you expect is because your JSON does not match the class structure that you are trying to deserialize into. You either need to change your JSON or change your classes. Since others have already shown how to change the JSON, I will take the opposite approach here.

To match the JSON you posted in your question, your classes should be defined like those below. Notice I've made the following changes:

1. I added a Wrapper class corresponding to the outer object in your JSON.
2. I changed the Values property of the ValueSet class from a List<Value> to a Dictionary<string, Value> since the values property in your JSON contains an object, not an array.
3. I added some additional [JsonProperty] attributes to match the property names in your JSON objects.

Class definitions:

class Wrapper
{
    [JsonProperty("JsonValues")]
    public ValueSet ValueSet { get; set; }
}

class ValueSet
{
    [JsonProperty("id")]
    public string Id { get; set; }
    [JsonProperty("values")]
    public Dictionary<string, Value> Values { get; set; }
}

class Value
{
    [JsonProperty("id")]
    public string Id { get; set; }
    [JsonProperty("diaplayName")]
    public string DisplayName { get; set; }
}

You need to deserialize into the Wrapper class, not the ValueSet class. You can then get the ValueSet from the Wrapper.

var valueSet = JsonConvert.DeserializeObject<Wrapper>(jsonString).ValueSet;

Here is a working program to demonstrate:

class Program
{
    static void Main(string[] args)
    {
        string jsonString = @"
        {
            ""JsonValues"": {
                ""id"": ""MyID"",
                ""values"": {
                    ""value1"": {
                        ""id"": ""100"",
                        ""diaplayName"": ""MyValue1""
                    },
                    ""value2"": {
                        ""id"": ""200"",
                        ""diaplayName"": ""MyValue2""
                    }
                }
            }
        }";

        var valueSet = JsonConvert.DeserializeObject<Wrapper>(jsonString).ValueSet;

        Console.WriteLine("id: " + valueSet.Id);
        foreach (KeyValuePair<string, Value> kvp in valueSet.Values)
        {
            Console.WriteLine(kvp.Key + " id: " + kvp.Value.Id);
            Console.WriteLine(kvp.Key + " name: " + kvp.Value.DisplayName);
        }
    }
}

And here is the output:

id: MyID
value1 id: 100
value1 name: MyValue1
value2 id: 200
value2 name: MyValue2

No need to read item by item.

string json = File.ReadAllText("myobjects.json");
var playerList = JsonConvert.DeserializeObject<List<Player>>(json);

You can use this code to write your player list to file

File.WriteAllText("myobjects.json", JsonConvert.SerializeObject(playerList));

I've done something like before using the JavaScript serialization class:

using System.Web.Script.Serialization;

And:

JavaScriptSerializer jss = new JavaScriptSerializer();

string output = jss.Serialize(ListOfMyObject);
Response.Write(output);
Response.Flush();
Response.End();

Here's how to think about deserializing JSON.

There are two paths, and one is easier. The easier is to make a C# object graph that looks like the JSON object, then deserialize to it. The harder is to use the token parser or types like JObject to do the same thing with a little more effort. The harder paths are better if the JSON is really "weird" and requires special effort to get into sensible C# objects.

This isn't quite bad enough to need to use JArray. Obviously you can't make a C# object with a property named "1", "2", "3", and so on, but there's another way to go about this. Any JSON object is effectively a Dictionary<string, object>, so our first decision can be that this is our outer object.

The inner objects of this dictionary do have a well-defined type. They have four properties that are strings, though maybe for your logic "id" will be a number. So we can make an object to represent this and have a more specific Dictionary.

So I'd start with:

public class JsonTask
{
    public string Id { get; set; }
    public string Entrant { get; set; }
    public string Recipient { get; set; }
    public string Task { get; set; }
}

Then the code to get the dictionary is:

var dict = JsonConvert.DeserializeObject<Dictionary<string, JsonTask>>(json);

From there, getting an array could be:

var asArray = dict.Values.ToArray();

If order is super important, you might have to do something more complex. If you know all the properties are always sequential integers, a for loop over Keys is good enough. If they might not be ordered, you might try converting Keys to an array, sorting it, then using each key to fetch each value.

I don't think the other comment about deserializing to a list will work, generally you can only deserialize JSON arrays to lists, and this is more of an object being used as a dictionary.

Your c# class mapping doesn't match with json structure.

Solution :

class MovieCollection {
        public IEnumerable<Movie> movies { get; set; }
}

class Movie {
        public string title { get; set; }
}

class Program {
        static void Main(string[] args)
        {
                string jsonString = @"{""movies"":[{""id"":""1"",""title"":""Sherlock""},{""id"":""2"",""title"":""The Matrix""}]}";
                JavaScriptSerializer serializer = new JavaScriptSerializer();
                MovieCollection collection = serializer.Deserialize<MovieCollection>(jsonString);
        }
}