¿Cuál es la mejor manera de convertir un JArray del tipo Tipo en una matriz de tipos?

Question

Tengo un JArray que representa la subcadena json [1,2,3]. Me gustaría convertirlo en un int[] en su lugar.

¿Cuál es la forma correcta de hacerlo? La mejor manera que he encontrado hasta ahora es hacer lo siguiente:

int[] items = new int[myJArray.Count]; 

int i = 0; 
foreach (int item in myJArray) 
{ 
    items[i++] = item; 
} 

Answer 1

int[] items = myJArray.Select(jv => (int)jv).ToArray(); 

Answer 2

int[] items = new int[myJArray.Count]; 

for (int i=0; i < myJArray.Count;i++) 
{ 
    items[i] = (int)myJArray[i] 
} 

Ésta es la solución con mayor crecimiento que puede hacer. El clásico for es un poco más rápido que el ForEach a medida que accede el artículo por el índice (el foreach detrás de la escena utiliza la interfaz IEnumerator)

o si lo prefiere:

JsonArray arr = JsonConvert.Import("[1,2,3,4]"); 
int[] nums = (int[]) arr.ToArray(typeof(int)); 

Answer 3

Este es bastante débil porque tienes que volver a convertir en una cadena, pero si estás haciendo algo rápido y sucio, donde el rendimiento no importa, utilizo el siguiente método. Me gusta porque no tengo que escribir ningún código para mapear propiedades entre json/JObject y mi POCO.

public static class JsonExtensions { 
    public static T As<T>(this JObject jobj) { 
     return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(jobj)); 
    } 

    public static List<T> ToList<T>(this JArray jarray) { 
     return JsonConvert.DeserializeObject<List<T>>(JsonConvert.SerializeObject(jarray)); 
    } 
} 


    [Test] 
    public void TestDeserializeRootObject() { 
     var json = @"{ id: 1, name: ""Dwight"" }"; 
     var jfoo = JsonConvert.DeserializeObject(json); 

     var foo = (jfoo as JObject).As<Foo>(); 
     Assert.AreEqual(1, foo.Id); 
     Assert.AreEqual("Dwight", foo.Name); 
    } 

    [Test] 
    public void TestDeserializeArray() { 
     var json = @"[ 
      { id: 1, name: ""Dwight"" } 
      , { id: 2, name: ""Pam"" } 
     ]"; 

     var foosArr = JsonConvert.DeserializeObject(json); 
     Assert.IsInstanceOf<JArray>(foosArr); 
     Assert.AreEqual(2, (foosArr as JArray).Count); 

     var foos = (foosArr as JArray).ToList<Foo>(); 
     Assert.AreEqual(2, foos.Count); 
     var foosDict = foos.ToDictionary(f => f.Name, f => f); 

     Assert.IsTrue(foosDict.ContainsKey("Dwight")); 
     var dwight = foosDict["Dwight"]; 
     Assert.AreEqual(1, dwight.Id); 
     Assert.AreEqual("Dwight", dwight.Name); 

     Assert.IsTrue(foosDict.ContainsKey("Pam")); 
     var pam = foosDict["Pam"]; 
     Assert.AreEqual(2, pam.Id); 
     Assert.AreEqual("Pam", pam.Name); 
    } 

Answer 4

un elenco necesario primero para mí:

((Newtonsoft.Json.Linq.JArray)myJArray).Select(item => (int)item).ToArray() 

Answer 5

myJArray.ToObject<int[]>(); 

También puede especificar HashSet, etc. Lista

La respuesta aceptada se basa en la conversión de .NET - esta técnica utiliza JSON .NET además de lo que .NET puede proporcionar, por lo que funciona con más escenarios.