Deserializar JSON con C #

Estoy tratando de deserializar la llamada Graph API de un amigo de Facebook en una lista de objetos. El objeto JSON se ve así:

{"data":[{"id":"518523721","name":"ftyft"},
         {"id":"527032438","name":"ftyftyf"},
         {"id":"527572047","name":"ftgft"},
         {"id":"531141884","name":"ftftft"},
         {"id":"532652067","name"...

List<EFacebook> facebooks = new JavaScriptSerializer().Deserialize<List<EFacebook>>(result);

No funciona porque el objeto primitivo no es válido. ¿Cómo puedo deserializar esto?

Necesita crear una estructura como esta:

public class Friends
{

    public List<FacebookFriend> data {get; set;}
}

public class FacebookFriend
{

    public string id {get; set;}
    public string name {get; set;}
}

Entonces deberías poder hacer:

Friends facebookFriends = new JavaScriptSerializer().Deserialize<Friends>(result);

Los nombres de mis clases son solo un ejemplo. Debes usar nombres propios.

Agregar una prueba de muestra:

string json =
    @"{""data"":[{""id"":""518523721"",""name"":""ftyft""}, {""id"":""527032438"",""name"":""ftyftyf""}, {""id"":""527572047"",""name"":""ftgft""}, {""id"":""531141884"",""name"":""ftftft""}]}";

Friends facebookFriends = new System.Web.Script.Serialization.JavaScriptSerializer().Deserialize<Friends>(json);

foreach(var item in facebookFriends.data)
{
    Console.WriteLine("id: {0}, name: {1}", item.id, item.name);
}

Produce:

id: 518523721, name: ftyft
id: 527032438, name: ftyftyf
id: 527572047, name: ftgft
id: 531141884, name: ftftft

A veces prefiero los objetos dinámicos:

public JsonResult GetJson()
{
  string res;
  WebClient client = new WebClient();

  // Download string
  string value = client.DownloadString("https://api.instagram.com/v1/users/000000000/media/recent/?client_id=clientId");

  // Write values
  res = value;
  dynamic dyn = JsonConvert.DeserializeObject(res);
  var lstInstagramObjects = new List<InstagramModel>();

  foreach(var obj in dyn.data)
  {
    lstInstagramObjects.Add(new InstagramModel()
    {
      Link = (obj.link != null) ? obj.link.ToString() : "",
      VideoUrl = (obj.videos != null) ? obj.videos.standard_resolution.url.ToString() : "",
      CommentsCount = int.Parse(obj.comments.count.ToString()),
      LikesCount = int.Parse(obj.likes.count.ToString()),
      CreatedTime = new System.DateTime(1970, 1, 1, 0, 0, 0, 0).AddSeconds((double.Parse(obj.created_time.ToString()))),
      ImageUrl = (obj.images != null) ? obj.images.standard_resolution.url.ToString() : "",
      User = new InstagramModel.UserAccount()
             {
               username = obj.user.username,
               website = obj.user.website,
               profile_picture = obj.user.profile_picture,
               full_name = obj.user.full_name,
               bio = obj.user.bio,
               id = obj.user.id
             }
    });
  }

  return Json(lstInstagramObjects, JsonRequestBehavior.AllowGet);
}

Una excelente manera de generar automáticamente estas clases para usted es copiar su salida JSON y lanzarla aquí:

http://json2csharp.com/

Le proporcionará un punto de partida para retocar sus clases para la deserialización.

Muy fácilmente podemos analizar el contenido JSON con la ayuda del diccionario y JavaScriptSerializer. Aquí está el código de muestra mediante el cual analizo el contenido JSON de un archivo ashx.

var jss = new JavaScriptSerializer();
string json = new StreamReader(context.Request.InputStream).ReadToEnd();
Dictionary<string, string> sData = jss.Deserialize<Dictionary<string, string>>(json);
string _Name = sData["Name"].ToString();
string _Subject = sData["Subject"].ToString();
string _Email = sData["Email"].ToString();
string _Details = sData["Details"].ToString();

Newtonsoft.JSONEs una buena solución para este tipo de situaciones. También Newtonsof.JSONes más rápido que otros, como JavaScriptSerializer, DataContractJsonSerializer.

En esta muestra, puede hacer lo siguiente:

var jsonData = JObject.Parse("your JSON data here");

Luego puede enviar jsonData a JArray, y puede usar un forbucle para obtener datos en cada iteración.

Además, quiero agregar algo:

for (int i = 0; (JArray)jsonData["data"].Count; i++)
{
    var data = jsonData[i - 1];
}

Trabajar con objetos dinámicos y usar Newtonsoft serialize es una buena opción.

Estoy de acuerdo con Icarus (habría comentado si pudiera), pero en lugar de usar una clase CustomObject , usaría un Diccionario (en caso de que Facebook agregue algo).

private class MyFacebookClass
{
    public IList<IDictionary<string, string>> data { get; set; }
}

o

private class MyFacebookClass
{
    public IList<IDictionary<string, object>> data { get; set; }
}

Publicación por entregas:

// Convert an object to JSON string format
string jsonData = JsonConvert.SerializeObject(obj);

Response.Write(jsonData);

Deserialización :

Para deserializar un objeto dinámico

  string json = @"{
      'Name': 'name',
      'Description': 'des'
    }";

var res = JsonConvert.DeserializeObject< dynamic>(json);

Response.Write(res.Name);

Puedes usar estas extensiones

public static class JsonExtensions
{
   public static T ToObject<T>(this string jsonText)
   {
       return JsonConvert.DeserializeObject<T>(jsonText);
   }

   public static string ToJson<T>(this T obj)
   {
       return JsonConvert.SerializeObject(obj);
   }
}

Aquí hay otro sitio que lo ayudará con todo el código que necesita siempre que tenga disponible una cadena JSON formateada correctamente:

https://app.quicktype.io/

Si usa .NET Core 3.0, puede usar System.Text.Json (que ahora está incorporado) para deserializar JSON.

El primer paso es crear clases para modelar el JSON. Hay muchas herramientas que pueden ayudar con esto, y algunas de las respuestas aquí las enumeran.

Algunas opciones son http://json2csharp.com , http://app.quicktype.io , o use Visual Studio (menú Editar → Pegado especial → Pegar JSON como clases ).

public class Person
{
    public string Id { get; set; }
    public string Name { get; set; }
}

public class Response
{
    public List<Person> Data { get; set; }
}

Entonces puedes deserializar usando:

var people = JsonSerializer.Deserialize<Response>(json);

Si necesita agregar configuraciones, como el camelCasemanejo, pase la configuración del serializador al deserializador de esta manera:

var options = new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
var person = JsonSerializer.Deserialize<Response>(json, options);