Ik heb het grootste deel van twee dagen doorgebracht met “faffing” met codevoorbeelden en dergelijke, in een poging een zeer groot JSON-bestand in een array in c# te lezen, zodat ik het later kan opsplitsen in een 2D-array voor verwerking.
Het probleem dat ik had was dat ik geen voorbeelden kon vinden van mensen die deden wat ik probeerde te doen. Dit betekende dat ik de code een beetje aan het bewerken was en er maar het beste van hoopte.
Ik ben erin geslaagd iets werkend te krijgen dat:
- Lees het bestand Mis kopteksten en lees alleen waarden in de array.
- Plaats een bepaald aantal waarden op elke regel van een array. (Dus ik
zou het later kunnen splitsen en in een 2d-array plaatsen)
Dit is gedaan met de onderstaande code, maar het programma crasht na het invoeren van een paar regels in de array. Dit kan te maken hebben met de bestandsgrootte.
// If the file extension was a jave file the following
// load method will be use else it will move on to the
// next else if statement
if (fileExtension == ".json")
{
int count = 0;
int count2 = 0;
int inOrOut = 0;
int nRecords=1;
JsonTextReader reader = new JsonTextReader(new StreamReader(txtLoaction.Text));
string[] rawData = new string[5];
while (reader.Read())
{
if (reader.Value != null)
if (inOrOut == 1)
{
if (count == 6)
{
nRecords++;
Array.Resize(ref rawData, nRecords);
//textBox1.Text += "\r\n";
count = 0;
}
rawData[count2] += reader.Value + ","; //+"\r\n"
inOrOut = 0;
count++;
if (count2 == 500)
{
MessageBox.Show(rawData[499]);
}
}
else
{
inOrOut = 1;
}
}
}
Een fragment van de JSON waarmee ik werk is:
[
{ "millis": "1000",
"stamp": "1273010254",
"datetime": "2010/5/4 21:57:34",
"light": "333",
"temp": "78.32",
"vcc": "3.54" },
]
Ik heb de waarden van deze JSON nodig. Ik heb bijvoorbeeld “3.54” nodig, maar ik zou niet willen dat het de “vcc” afdrukt.
Ik hoop dat iemand me kan laten zien hoe ik een JSON-bestand kan inlezen en alleen de gegevens kan extraheren die ik nodig heb en deze in een array of iets anders kan plaatsen dat ik later in een array kan plaatsen.
Antwoord 1, autoriteit 100%
Wat dacht je ervan om alles gemakkelijker te maken met Json.NET?
public void LoadJson()
{
using (StreamReader r = new StreamReader("file.json"))
{
string json = r.ReadToEnd();
List<Item> items = JsonConvert.DeserializeObject<List<Item>>(json);
}
}
public class Item
{
public int millis;
public string stamp;
public DateTime datetime;
public string light;
public float temp;
public float vcc;
}
Je kunt de waarden zelfs dynamically krijgen zonder de klasse Item te declareren.
dynamic array = JsonConvert.DeserializeObject(json);
foreach(var item in array)
{
Console.WriteLine("{0} {1}", item.temp, item.vcc);
}
Antwoord 2, autoriteit 8%
Dit zelf doen is een slecht idee. Gebruik Json.NET. Het heeft het probleem al beter opgelost dan de meeste programmeurs zouden kunnen als ze maandenlang de tijd zouden krijgen om eraan te werken. Raadpleeg de documentatie voor uw specifieke behoeften, het ontleden in arrays en dergelijke, met name over JsonTextReader. Kortom, Json.NET verwerkt JSON-arrays native en ontleedt ze in strings, ints of wat dan ook, zonder dat u daarom vraagt. Hier is een directe link naar het basiscodegebruik voor zowel de lezer en de schrijver, zodat u dat in een reservevenster kunt openen terwijl u hiermee leert werken.
Dit is het beste: wees deze keer lui en gebruik een bibliotheek zodat je dit veelvoorkomende probleem voor altijd oplost.
Antwoord 3, autoriteit 4%
Dit kan ook op de volgende manier worden gedaan:
JObject data = JObject.Parse(File.ReadAllText(MyFilePath));
Antwoord 4, autoriteit 2%
Op basis van de oplossing van @L.B. is de (getypt als Object in plaats van Anonymous) VB-code
Dim oJson As Object = JsonConvert.DeserializeObject(File.ReadAllText(MyFilePath))
Ik moet vermelden dat dit snel en handig is voor het construeren van HTTP-aanroepinhoud waar het type niet vereist is. En het gebruik van Object in plaats van Anonymous betekent dat u Option Strict On kunt behouden in uw Visual Studio-omgeving – ik haat het om dat uit te schakelen.
Antwoord 5, autoriteit 2%
string jsonFilePath = @"C:\MyFolder\myFile.json";
string json = File.ReadAllText(jsonFilePath);
Dictionary<string, object> json_Dictionary = (new JavaScriptSerializer()).Deserialize<Dictionary<string, object>>(json);
foreach (var item in json_Dictionary)
{
// parse here
}
Antwoord 6
Gebruik voor elk van de JSON-parsen de website http://json2csharp.com/ (eenvoudigste manier) om converteer uw JSON naar C#-klasse om uw JSON te deserialiseren naar C#-object.
public class JSONClass
{
public string name { get; set; }
public string url { get; set; }
public bool visibility { get; set; }
public string idField { get; set; }
public bool defaultEvents { get; set; }
public string type { get; set; }
}
Gebruik vervolgens de JavaScriptSerializer (van System.Web.Script.Serialization), voor het geval u geen DLL van derden zoals newtonsoft wilt.
using (StreamReader r = new StreamReader("jsonfile.json"))
{
string json = r.ReadToEnd();
JavaScriptSerializer jss = new JavaScriptSerializer();
var Items = jss.Deserialize<JSONClass>(json);
}
Dan kunt u uw object krijgen met Items.name of Items.Url enz.
Antwoord 7
Voor het vinden van het juiste pad gebruik ik
var pathToJson = Path.Combine("my","path","config","default.Business.Area.json");
var r = new StreamReader(pathToJson);
var myJson = r.ReadToEnd();
// my/path/config/default.Business.Area.json
[...] do parsing here
Path.Combine gebruikt de Path.PathSeparator en controleert of het eerste pad al een scheidingsteken aan het einde heeft, zodat het de scheidingstekens niet dupliceert. Bovendien controleert het of de te combineren padelementen ongeldige tekens hebben.
Zie https://stackoverflow.com/a/32071002/4420355
Antwoord 8
Antwoord voor .NET Core
Je kunt gewoon het ingebouwde System.Text.Json gebruiken in plaats van het Json.NET van derden. Om hergebruik te bevorderen, hoort de JSON-functionaliteit voor het lezen van bestanden in zijn eigen klasse en moet deze generiek zijn in plaats van hard gecodeerd voor een bepaald type (Item). Hier is een volledig voorbeeld:
using System;
using System.IO;
using System.Text.Json;
using System.Threading.Tasks;
namespace Project
{
class Program
{
static async Task Main()
{
Item item = await JsonFileReader.ReadAsync<Item>(@"C:\myFile.json");
}
}
public static class JsonFileReader
{
public static async Task<T> ReadAsync<T>(string filePath)
{
using FileStream stream = File.OpenRead(filePath);
return await JsonSerializer.DeserializeAsync<T>(stream);
}
}
public class Item
{
public int millis;
public string stamp;
public DateTime datetime;
public string light;
public float temp;
public float vcc;
}
}
Of, als u de voorkeur geeft aan iets eenvoudiger/synchroon:
class Program
{
static void Main()
{
Item item = JsonFileReader.Read<Item>(@"C:\myFile.json");
}
}
public static class JsonFileReader
{
public static T Read<T>(string filePath)
{
string text = File.ReadAllText(filePath);
return JsonSerializer.Deserialize<T>(text);
}
}
Antwoord 9
Deze code kan u helpen:
string _filePath = Path.GetDirectoryName(System.AppDomain.CurrentDomain.BaseDirectory);
JObject data = JObject.Parse(_filePath );
Antwoord 10
Er is een snellere manier om json te ontleden dan Json.Net . Als u .net core 3.0 of hoger gebruikt, kunt u de System.Text.Json gebruiken nuget-pakket om te serialiseren of te deserialiseren.
je moet toevoegen:
using System.Text.Json
En dan kun je serialiseren als:
var jsonStr = JsonSerializer.Serialize(model);
En deserialiseren als:
var model = JsonSerializer.Deserialize(jsonStr);
Antwoord 11
Er is een eenvoudigere manier om JSON uit een bestand of van het web te halen:
Json.Net.Curl
Installatiepakket Json.Net.Curl
// get JObject from local file system
var json = Json.Net.Curl.Get(@"data\JObjectUnitTest1.json");
var json = await Json.Net.Curl.GetAsync(@"data\JObjectUnitTest1.json")
// get JObject from Server
var json = await Json.Net.Curl.GetAsync("http://myserver.com/data.json");