just take the string and use the JavaScriptSerializer to deserialize it into a native object. For example, having this json:

string json = "[{Name:'John Simith',Age:35},{Name:'Pablo Perez',Age:34}]"; 

You'd need to create a C# class called, for example, Person defined as so:

public class Person
{
 public int Age {get;set;}
 public string Name {get;set;}
}

You can now deserialize the JSON string into an array of Person by doing:

JavaScriptSerializer js = new JavaScriptSerializer();
Person [] persons =  js.Deserialize<Person[]>(json);

Here's a link to JavaScriptSerializer documentation.

Note: my code above was not tested but that's the idea Tested it. Unless you are doing something "exotic", you should be fine using the JavascriptSerializer.

You need to access the inner array using a json_object * variable.

Try this:

struct json_object *med_obj, *medi_array, *medi_array_obj, *medi_array_obj_name;
int arraylen, i;
charname[10] = {0};
static const char filename[] = "xyz.txt";
med_obj = json_object_from_file(filename);
medi_array = json_object_object_get(med_obj, "medication");

// medi_array is an array of objects
arraylen = json_object_array_length(medi_array);

for (i = 0; i < arraylen; i++) {
  // get the i-th object in medi_array
  medi_array_obj = json_object_array_get_idx(medi_array, i);
  // get the name attribute in the i-th object
  medi_array_obj_name = json_object_object_get(medi_array_obj, "name");
  // print out the name attribute
  printf("name=%s\n", json_object_get_string(medi_array_obj_name));
}

Use Newtonsoft.Json to deserialize JSON to a specified .net type. You can deserialize to a class too, see below:

public class Person
{
 public int Id {get;set;}
 public string Name {get;set;}
 public string Address {get;set;}
 public string Country {get;set;}
 public string Phone {get;set;}
}

var details = JsonConvert.DeserializeObject<Person>(json);

The property names won't match as is, because you subjects class don't have the 'subject_' prefix the JSON object has. Easiest fix is to change your property names as shown in Ali's answer. Just in case you need to keep your property names as is, you can also use a JsonProperty attribute to alter the serialization names (perhaps there's a more generic way using some sort of converter, but didn't think the amount of properties needed it)

    class subjects
    {
        [JsonProperty("subject_id")]
        public int id { get; set; }
        [JsonProperty("subject_name")]
        public string name { get; set; }
        [JsonProperty("subject_class")]
        public int class_name { get; set; }
        [JsonProperty("subject_year")]
        public string year { get; set; }
        [JsonProperty("subject_code")]
        public string code { get; set; }
    }

If you never need the root subjects you can also skip it without dynamic or an extra class with something like:

subjects[] arr = JObject.Parse(result)["subjects"].ToObject<subjects[]>();

(JObject is part of the namespace Newtonsoft.Json.Linq )

var json_data = {"2013-01-21":1,"2013-01-22":7};
var result = [];

for(var i in json_data)
    result.push([i, json_data [i]]);


var data = new google.visualization.DataTable();
data.addColumn('string', 'Topping');
data.addColumn('number', 'Slices');
data.addRows(result);

http://jsfiddle.net/MV5rj/

Given that you are already using the ToObject, consider simplifying the code for readability and the advantage of not having to convert anything.

var contentJson = await SendRequest(request);
dynamic response = JsonConvert.DeserializeObject(contentJson); 
List<Organization> organizations = response.organizations.ToObject<List<Organization>>();

The actual response appears to be of no concern so using a dynamic simplifies things. Converting back to strongly typed objects by calling ToObject<T> was a good choice and should work out fine.

Use JSON.parse():

var json = '{"names":["Kreisler","Kreisler","Kreisler"]}';
data = JSON.parse(json);
console.log(data['names']); // ["Kreisler", "Kreisler", "Kreisler"]

Using NewtonSoft Json.NET library (https://www.newtonsoft.com/json), you can do as follows:

JObject result = JObject.Parse(jsonString);

But your Json string looks more like an array, so probably JArray.Parse is what you need to use instead. Documentation with examples here:

https://www.newtonsoft.com/json/help/html/ParseJsonArray.htm

If you want to parse the internal elements as objects, thhe accepted answer of this question should provide you enough hints:

C# Parsing JSON array of objects