Il modo migliore per trasformare un JArray di tipo Type in una matrice di Tipi?

Question

Ho uno JArray che rappresenta la sottostringa JSON [1,2,3]. Mi piacerebbe trasformarlo in un int[] invece.

Qual è il modo corretto di farlo? Il modo migliore che ho trovato finora è quello di effettuare le seguenti operazioni:

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] 
} 

questa è la soluzione di rapido si può fare. Il classico for è un po 'più veloce rispetto al ForEach come si accede alla voce per l'indice (il foreach dietro le quinte utilizza l'interfaccia IEnumerator)

o se si preferisce:

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

Answer 3

Questo è abbastanza debole perché devi convertire nuovamente in una stringa, ma se stai facendo qualcosa di veloce e sporco, in cui il successo in termini di prestazioni non è importante, io uso il metodo seguente. Mi piace perché non devo scrivere alcun codice per mappare le proprietà tra json/JObject e i miei 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 cast necessaria prima volta per me:

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

Answer 5

myJArray.ToObject<int[]>(); 

è anche possibile specificare HashSet, Lista ecc

La risposta accettata si basa sulla conversione di NET - questa tecnica utilizza JSON Lo stesso di .NET oltre a ciò che .NET può fornire, quindi funziona con più scenari.