Fehler beim Deserialisieren von JSON - System.InvalidCastException

kafffee · 28. Dezember 2023, 13:56

Hallo miteinander

ich versuche gerade, einen JSON String zu deserialisieren und es kommt diese Fehlermeldung: Das Objekt des Typs "Newtonsoft.Json.Linq.JObject" kann nicht in Typ "Root" umgewandelt werden.

Ich habe mir die Datenklasse mit diesem Konverter aus dem JSON erstellen lassen: json2csharp.com

Herausgekommen ist Folgendes (ich hab die Klasse MusicBrainzAlbumData aussenrum gemacht):

Spoiler anzeigen

VB.NET-Quellcode

Public Class MusicBrainzAlbumData
Public Class Area
Public Property id As String
Public Property name As String
Public Property type As Object
'<JsonProperty("sort-name")>
Public Property sortname As String
Public Property disambiguation As String
'<JsonProperty("iso-3166-1-codes")>
Public Property iso31661codes As List(Of String)
'<JsonProperty("type-id")>
Public Property typeid As Object
End Class
Public Class CoverArtArchive
Public Property front As Boolean
Public Property count As Integer
Public Property artwork As Boolean
Public Property darkened As Boolean
Public Property back As Boolean
End Class
Public Class Disc
Public Property id As String
Public Property offsets As List(Of Integer)
Public Property sectors As Integer
'<JsonProperty("offset-count")>
Public Property offsetcount As Integer
End Class
Public Class Medium
Public Property discs As List(Of Disc)
Public Property format As String
'<JsonProperty("format-id")>
Public Property formatid As String
Public Property position As Integer
'<JsonProperty("track-count")>
Public Property trackcount As Integer
Public Property title As String
End Class
Public Class Release
'<JsonProperty("packaging-id")>
Public Property packagingid As String
'<JsonProperty("text-representation")>
Public Property textrepresentation As TextRepresentation
Public Property id As String
Public Property datum As String
Public Property disambiguation As String
Public Property quality As String
Public Property title As String
Public Property barcode As String
Public Property media As List(Of Medium)
Public Property status As String
Public Property asin As String
'<JsonProperty("status-id")>
Public Property statusid As String
Public Property packaging As String
'<JsonProperty("release-events")>
Public Property releaseevents As List(Of ReleaseEvent)
Public Property country As String
'<JsonProperty("cover-art-archive")>
Public Property coverartarchive As CoverArtArchive
End Class
Public Class ReleaseEvent
Public Property datum As String
Public Property area As Area
End Class
Public Class Root
Public Property sectors As Integer
Public Property offsets As List(Of Integer)
'<JsonProperty("offset-count")>
Public Property offsetcount As Integer
Public Property releases As List(Of Release)
Public Property id As String
End Class
Public Class TextRepresentation
Public Property script As String
Public Property language As String
End Class
End Class

Das Original-JSON sieht so aus:

Spoiler anzeigen

Jetzt sind ja einige der Properties nicht VB-konform und wurden daher vom Konverter abgeändert, z.B. die erste ist:

VB.NET-Quellcode

'<JsonProperty("sort-name")>
Public Property sortname As String

Also hab ich mir gedacht ich ersetze alle diese Propertynamen mit der korrigierten Version schon vor dem Deserialisieren im JSON-String mit dieser Funktion:

VB.NET-Quellcode

Private Function CorrectPropertyNames(argJSON As String) As String
Dim Result As String = argJSON
Result = Result.Replace("sort-name", "sortname")
Result = Result.Replace("iso-3166-1-codes", "iso31661codes")
Result = Result.Replace("type-id", "typeid")
Result = Result.Replace("offset-count", "offsetcount")
Result = Result.Replace("format-id", "formatid")
Result = Result.Replace("track-count", "trackcount")
Result = Result.Replace("packaging-id", "packagingid")
Result = Result.Replace("text-representation", "textrepresentation")
Result = Result.Replace("date", "datum")
Result = Result.Replace("status-id", "statusid")
Result = Result.Replace("release-events", "releaseevents")
Result = Result.Replace("cover-art-archive", "coverartarchive")
Return Result
End Function

Ich bekomme aber immer noch diesen Fehler.

Weiss jemand woran das liegt oder sieht einen offensichtlichen Fehler, bzw. kann man diese Korrektur dieser Propertynames irgendwie automatisieren?

Ich deserialisiere folgendermassen:

VB.NET-Quellcode

Dim ResultAlbumSearch As String = Klient.DownloadString(AlbumSearchURL)
ResultAlbumSearch = KorrigierePropertyNames(ResultAlbumSearch)
Dim AlbumObjekt As New MusicBrainzAlbumData.Root
AlbumObjekt = CType(JsonConvert.DeserializeObject(ResultAlbumSearch), MusicBrainzAlbumData.Root)

Grüsse, kafffee

siycah · 28. Dezember 2023, 15:34

Bevor du dir da jetzt den Kopf zerbrichst und versuchst, das auf Krampf in C# zu übersetzen: erstell eine C#-Klassenbibliothek und lade dort deine Klassen rein.
Die kannst du problemlos in deinem VB-Projekt referenzieren und verwenden.

EDIT:
Ich will nicht sagen, dass du dir die Mühe gar nicht machen sollst, aber manchmal ist es sinnvoller, den Einfachen Weg zu nehmen, bevor man sich unnötig den Kopf zerbricht :)

kafffee · 28. Dezember 2023, 15:37

Dat wär mal ne Idee

Wusste nicht dass das geht, C# DLL in VB einbinden. Bin mal gespannt obs daran liegt oder der Fehler woanders ist...

siycah · 28. Dezember 2023, 15:44

Im Hintergrund ist das alles MSIL. Die ganzen System-Libs die du verwendest, sind auch in C# geschrieben

kafffee · 28. Dezember 2023, 15:50

Wie steige ich denn da ein beim Erstellen der Klassenbibliothek?

Windows-Forms-Klasssenbibliothek?

Wie bekomme ich dann die Form1 aus dem Projekt?

Edit @siycah:
Gibts da überhaupt ein Template für Framework 4.8?

Edit2 @siycah
Ah habs hinbekommen. Leeres Projekt und dann in den Anwendungseigenschaften Ausgabetyp Klassenbibliothek...

Aber diese besagten Eigenschaften werden von IntelliSense trotzdem rot angestrichen. Lag wohl nicht daran, dass das nicht VB-konform ist

siycah · 28. Dezember 2023, 22:36

C#-Quellcode

public class Foo {
[JsonProperty("something_in_json")]
public int Bar { get; set; }
}

So wäre aber die valide Syntax in C#.

Fakiz · 29. Dezember 2023, 04:23

kann man diese Korrektur dieser Propertynames irgendwie automatisieren?

Dafür gibt es SerializationAttributes

kafffee · 29. Dezember 2023, 14:25

Okay ein Imports Newtonsoft.Json in meiner Datenklasse kann natürlich nicht schaden...

Ich dachte dass hier wäre nur eine Art Gedankenstütze für den Programmierer, sah mir nicht wie Syntax aus:

VB.NET-Quellcode

<JsonProperty("text-representation")>
Public Property textrepresentation As TextRepresentation

Jetzt scheint alles in Ordnung zu sein, ich bekomm aber immer noch diesen Fehler...

Da ist natürlich noch diese Property, die nicht gehen kann, weil date ein Schlüsselwort ist....

Public Property date As String

Ich hab beides versucht, einmal auskommentieren (diese Property brauche ich eigentlich nicht) und einmal im Original-JSON ersetzt:

Result = Result.Replace("date", "datum") und den Prooertynamen entsprechend geändert, funktioniert aber beides nicht...

Hat jemand ne Idee, wie ich anfangen kann das zu debuggen? Wichtig zu wissen wäre vielleicht noch, bevor wir uns hier einen abbrechen, dass ich nur die Property id As String aus der Class Release brauche, alles Andere ist erstmal für die Tonne...

@Fakiz
Hab deinen Link grad mal überflogen, scheint aber bloss Sinn zu machen, wenn ich die Daten auch Serialisiere. Leider hab ich bei meinem Problem keinen Einfluss auf den serialisierten JSON String, der ist so wie er ist, gegeben...

ErfinderDesRades · 29. Dezember 2023, 14:58

kafffee schrieb:

Da ist natürlich noch diese Property, die nicht gehen kann, weil date ein Schlüsselwort ist.

mach so:

VB.NET-Quellcode

Public Property [Date] As String

kafffee · 29. Dezember 2023, 15:07

@ErfinderDesRades

Hab jetzt [date] gemacht, weil im Original ist es auch kleingeschrieben...Ist das in deinem Sinne?

Immer noch der gleiche Fehler

aber gut zu wissen dieser Kniff

ErfinderDesRades schrieb:

Und Date ist kein Schlüsselwort, sondern ein Datentyp
/klugscheiss

Ja aber der Datentyp ist doch da an sich auch wieder ein Schlüselwort ?? /klugscheiss 2.0 :thumbsup:

siycah · 29. Dezember 2023, 15:24

kafffee schrieb:

Und Date ist kein Schlüsselwort, sondern ein Datentyp

Ich bin erschrocken. Das ist ja tatsächlich ein VB-Keyword

kafffee schrieb:

Ja aber der Datentyp ist doch da an sich auch wieder ein Schlüselwort ?? /klugscheiss 2.0

In MSIL-Sprachen ist sowieso alles ein Object. Also macht es keinen Unterschied - Datentyp = Object.

kafffee schrieb:

Hab jetzt [date] gemacht, weil im Original ist es auch kleingeschrieben...Ist das in deinem Sinne?

Lt. Microsoft Coding-Guideline sollen alle öffentlichen Eigenschaften großgeschrieben werden. Public Property [Date] As String wäre hier also richtig.

kafffee schrieb:

Hab deinen Link grad mal überflogen, scheint aber bloss Sinn zu machen, wenn ich die Daten auch Serialisiere.

Das ist für genau solche Fälle, wenn man sich an einen bestimmten Vertrag (API) halten muss. Völlig egal, ob du Daten serialisierst, oder deserialisierst.
Da würde ich auch nach wie vor nicht an dem JSON rumfuhrwerken und händisch was ändern, solange es nicht absolut zwingend notwendig ist.

ErfinderDesRades · 29. Dezember 2023, 18:38

kafffee schrieb:

Ja aber der Datentyp ist doch da an sich auch wieder ein Schlüselwort ?

Also wies mir aussieht, haben sie für viele Datentypen Extra-Schlüsselworte eingeführt:
learn.microsoft.com/en-us/dotn…guage-reference/keywords/

Der Grund wird sein, dass sie Verwirrung schaffen wollten, und verhindern, dass Vb.Net-Programmierer den Unterschied von Datentyp und Schlüsselwort verstehen.

siycah · 29. Dezember 2023, 18:40

ErfinderDesRades schrieb:

Der Grund wird sein, dass sie Verwirrung schaffen wollten, also verhindern, dass Vb.Net-Programmierer den Unterschied von Datentyp und Schlüsselwort verstehen.

Da kannst drauf wetten. Das ist ja maximal verwirrend, was die da angestellt haben. Die Sprache ist so umfassend geworden, dass sie komplexer ist, als C++, was Schlüsselwörter angeht.

kafffee · 30. Dezember 2023, 07:30

ErfinderDesRades schrieb:

Der Grund wird sein, dass sie Verwirrung schaffen wollten, und verhindern, dass Vb.Net-Programmierer den Unterschied von Datentyp und Schlüsselwort verstehen.

Ja, schon oft gedacht, nie ausgesprochen lol. Aber mal zurück zum Thema:

Was schlagt ihr vor, was ich jetzt mache?

Hab das Demoprojekt mal angehängt, vielleicht suchen wir an der falschen Stelle?? Evtl. müsst ihr den Verweis auf die bass.Net. Dll noch rausnehmen

siycah · 30. Dezember 2023, 13:07

Ich konnte das Projekt bei mir gar nicht bauen, weil ich dotnet 4 nicht installiert habe (und ich war jetzt ehrlich gesagt zu faul, das alles in ein neues Projekt zu basteln).

Es gibt ein cooles Tool, das heißt QuickType. Damit kannst du jegliches JSON in eine von vielen Sprachen übersetzen.
Daraus resultiert folgende Datei:

Spoiler anzeigen

C#-Quellcode

// <auto-generated />
//
// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do:
//
// using QuickType;
//
// var musicBrainz = MusicBrainz.FromJson(jsonString);
namespace QuickType
{
using System;
using System.Collections.Generic;
using System.Globalization;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
public partial class Media
{
[JsonProperty("format")]
public string Format { get; set; }
[JsonProperty("discs")]
public List<MusicBrainz> Discs { get; set; }
[JsonProperty("position")]
public long Position { get; set; }
[JsonProperty("format-id")]
public Guid FormatId { get; set; }
[JsonProperty("title")]
public string Title { get; set; }
[JsonProperty("track-count")]
public long TrackCount { get; set; }
}
public partial class Release
{
[JsonProperty("country")]
public string Country { get; set; }
[JsonProperty("quality")]
public string Quality { get; set; }
[JsonProperty("date")]
public Date DateObject { get; set; }
[JsonProperty("status-id")]
public Guid StatusId { get; set; }
[JsonProperty("barcode")]
public string Barcode { get; set; }
[JsonProperty("packaging")]
public string Packaging { get; set; }
[JsonProperty("id")]
public Guid Id { get; set; }
[JsonProperty("cover-art-archive")]
public CoverArtArchive CoverArtArchive { get; set; }
[JsonProperty("title")]
public string Title { get; set; }
[JsonProperty("asin")]
public string Asin { get; set; }
[JsonProperty("release-events")]
public List<ReleaseEvent> ReleaseEvents { get; set; }
[JsonProperty("status")]
public string Status { get; set; }
[JsonProperty("disambiguation")]
public string Disambiguation { get; set; }
[JsonProperty("media")]
public List<Media> Media { get; set; }
[JsonProperty("packaging-id")]
public Guid? PackagingId { get; set; }
[JsonProperty("text-representation")]
public TextRepresentation TextRepresentation { get; set; }
}
public partial class MusicBrainz
{
[JsonProperty("releases", NullValueHandling = NullValueHandling.Ignore)]
public List<Release> Releases { get; set; }
[JsonProperty("offsets")]
public List<long> Offsets { get; set; }
[JsonProperty("id")]
public string Id { get; set; }
[JsonProperty("sectors")]
public long Sectors { get; set; }
[JsonProperty("offset-count")]
public long OffsetCount { get; set; }
}
public partial class CoverArtArchive
{
[JsonProperty("front")]
public bool Front { get; set; }
[JsonProperty("artwork")]
public bool Artwork { get; set; }
[JsonProperty("count")]
public long Count { get; set; }
[JsonProperty("back")]
public bool Back { get; set; }
[JsonProperty("darkened")]
public bool Darkened { get; set; }
}
public partial class ReleaseEvent
{
[JsonProperty("date")]
public Date Date { get; set; }
[JsonProperty("area")]
public Area Area { get; set; }
}
public partial class Area
{
[JsonProperty("name")]
public string Name { get; set; }
[JsonProperty("id")]
public Guid Id { get; set; }
[JsonProperty("type")]
public object Type { get; set; }
[JsonProperty("sort-name")]
public string SortName { get; set; }
[JsonProperty("iso-3166-1-codes")]
public List<string> Iso31661Codes { get; set; }
[JsonProperty("disambiguation")]
public string Disambiguation { get; set; }
[JsonProperty("type-id")]
public object TypeId { get; set; }
}
public partial class TextRepresentation
{
[JsonProperty("language")]
public string Language { get; set; }
[JsonProperty("script")]
public string Script { get; set; }
}
public partial struct Date
{
public DateTimeOffset? DateTime;
public long? Integer;
public static implicit operator Date(DateTimeOffset DateTime) => new Date { DateTime = DateTime };
public static implicit operator Date(long Integer) => new Date { Integer = Integer };
}
public partial class MusicBrainz
{
public static MusicBrainz FromJson(string json) => JsonConvert.DeserializeObject<MusicBrainz>(json, QuickType.Converter.Settings);
}
public static class Serialize
{
public static string ToJson(this MusicBrainz self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings);
}
internal static class Converter
{
public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
{
MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
DateParseHandling = DateParseHandling.None,
Converters =
{
DateConverter.Singleton,
new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
},
};
}
internal class DateConverter : JsonConverter
{
public override bool CanConvert(Type t) => t == typeof(Date) || t == typeof(Date?);
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
{
switch (reader.TokenType)
{
case JsonToken.String:
case JsonToken.Date:
var stringValue = serializer.Deserialize<string>(reader);
DateTimeOffset dt;
if (DateTimeOffset.TryParse(stringValue, out dt))
{
return new Date { DateTime = dt };
}
long l;
if (Int64.TryParse(stringValue, out l))
{
return new Date { Integer = l };
}
break;
}
throw new Exception("Cannot unmarshal type Date");
}
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
{
var value = (Date)untypedValue;
if (value.DateTime != null)
{
serializer.Serialize(writer, value.DateTime.Value.ToString("o", System.Globalization.CultureInfo.InvariantCulture));
return;
}
if (value.Integer != null)
{
serializer.Serialize(writer, value.Integer.Value.ToString());
return;
}
throw new Exception("Cannot marshal type Date");
}
public static readonly DateConverter Singleton = new DateConverter();
}
}

Das übernimmt die Serialisierung und Deserialisierung für dich und wandelt auch gleich alle Namen entsprechend der Microsoft Coding Conventions.
Der verwendet auch einige komplexere Strukturen, die es scheinbar in VB nicht gibt.

Du kannst die Klasse nehmen, in eine Bibliothek einpacken und dann aus deinem Projekt referenzieren. Schau mal ob das klappt.

Falls du selber QuickType nutzen möchtest, kannst du das unter quicktype.io.

Edit: Ich habe das "Date" Property mal zu "DateObject" umbenannt, damit du in VB auch nicht unnötig fummeln musst.

kafffee · 31. Dezember 2023, 00:41

@siycah

Super danke für den Link habs erstmal hinbekommen. Sehr hilfreich.

Jetzt muss ich in diesem Fall noch eine zweite Query machen, mit dem Ergebnis der ersten in der Request URI. Hab ich auch hinbekommen, auch das Deserialisieren.

Bloss komm ich jetzt nach zwei Stunden überlegen und probieren nicht an die gewünschten Daten, hab da irgendwo nen Denkfehler drin. Ich bin mir aber fast sicher, dass ich nicht Dim AlbumContentObject As AlbumSearchContentData.Media machen muss, sondern Dim AlbumContentObject As List(Of AlbumSearchContentData.Media). Bloss da komm ich nicht dahinter, wie die Syntax ist, wenn man das Deserialisieren möchte.

Ich deserialisiere momentan so:

VB.NET-Quellcode

Dim AlbumContentObject As AlbumSearchContentData.Media = AlbumSearchContentData.Media.FromJson(ResultAlbumContentSearch)
For Each item In AlbumContentObject.Tracks
Console.WriteLine(item.Position & ". " & item.Title)
Next

Ich möchte, dass er mir die Tracknummern (.Position) und die Tracktitel (.Title) ausgibt. Leider ist AlbumContentObject.Tracks,.ount immer 0, was nicht sein kann. Irgendwas mach ich falsch.

So sieht das JSON aus (im Screenshot JSON.PNG sieht mans vielleicht etwas besser):

Spoiler anzeigen

So sieht meine Datenklasse(n) aus:

Spoiler anzeigen

C#-Quellcode

// <auto-generated />
//
// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do:
//
// using QuickType;
//
// var welcome = Welcome.FromJson(jsonString);
namespace AlbumSearchContentData
{
using System;
using System.Collections.Generic;
using System.Globalization;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
public partial class Welcome
{
[JsonProperty("date")]
public DateTimeOffset Date { get; set; }
[JsonProperty("packaging-id")]
public Guid PackagingId { get; set; }
[JsonProperty("release-events")]
public ReleaseEvent[] ReleaseEvents { get; set; }
[JsonProperty("quality")]
public string Quality { get; set; }
[JsonProperty("media")]
public Media[] Media { get; set; }
[JsonProperty("status")]
public string Status { get; set; }
[JsonProperty("country")]
public string Country { get; set; }
[JsonProperty("barcode")]
public string Barcode { get; set; }
[JsonProperty("id")]
public Guid Id { get; set; }
[JsonProperty("text-representation")]
public TextRepresentation TextRepresentation { get; set; }
[JsonProperty("asin")]
public string Asin { get; set; }
[JsonProperty("status-id")]
public Guid StatusId { get; set; }
[JsonProperty("title")]
public string Title { get; set; }
[JsonProperty("cover-art-archive")]
public CoverArtArchive CoverArtArchive { get; set; }
[JsonProperty("packaging")]
public string Packaging { get; set; }
[JsonProperty("disambiguation")]
public string Disambiguation { get; set; }
}
public partial class CoverArtArchive
{
[JsonProperty("back")]
public bool Back { get; set; }
[JsonProperty("count")]
public long Count { get; set; }
[JsonProperty("front")]
public bool Front { get; set; }
[JsonProperty("artwork")]
public bool Artwork { get; set; }
[JsonProperty("darkened")]
public bool Darkened { get; set; }
}
public partial class Media
{
[JsonProperty("track-count")]
public long TrackCount { get; set; }
[JsonProperty("tracks")]
public Track[] Tracks { get; set; }
[JsonProperty("track-offset")]
public long TrackOffset { get; set; }
[JsonProperty("format")]
public string Format { get; set; }
[JsonProperty("title")]
public string Title { get; set; }
[JsonProperty("position")]
public long Position { get; set; }
[JsonProperty("format-id")]
public Guid FormatId { get; set; }
}
public partial class Track
{
[JsonProperty("recording")]
public Recording Recording { get; set; }
[JsonProperty("length")]
public long Length { get; set; }
[JsonProperty("id")]
public Guid Id { get; set; }
[JsonProperty("title")]
public string Title { get; set; }
[JsonProperty("number")]
[JsonConverter(typeof(ParseStringConverter))]
public long Number { get; set; }
[JsonProperty("position")]
public long Position { get; set; }
}
public partial class Recording
{
[JsonProperty("first-release-date")]
public FirstReleaseDate FirstReleaseDate { get; set; }
[JsonProperty("disambiguation")]
public string Disambiguation { get; set; }
[JsonProperty("video")]
public bool Video { get; set; }
[JsonProperty("length")]
public long Length { get; set; }
[JsonProperty("id")]
public Guid Id { get; set; }
[JsonProperty("title")]
public string Title { get; set; }
}
public partial class ReleaseEvent
{
[JsonProperty("date")]
public DateTimeOffset Date { get; set; }
[JsonProperty("area")]
public Area Area { get; set; }
}
public partial class Area
{
[JsonProperty("sort-name")]
public string SortName { get; set; }
[JsonProperty("disambiguation")]
public string Disambiguation { get; set; }
[JsonProperty("type")]
public object Type { get; set; }
[JsonProperty("id")]
public Guid Id { get; set; }
[JsonProperty("name")]
public string Name { get; set; }
[JsonProperty("iso-3166-1-codes")]
public string[] Iso31661Codes { get; set; }
[JsonProperty("type-id")]
public object TypeId { get; set; }
}
public partial class TextRepresentation
{
[JsonProperty("language")]
public string Language { get; set; }
[JsonProperty("script")]
public string Script { get; set; }
}
public partial struct FirstReleaseDate
{
public DateTimeOffset? DateTime;
public long? Integer;
public static implicit operator FirstReleaseDate(DateTimeOffset DateTime) => new FirstReleaseDate { DateTime = DateTime };
public static implicit operator FirstReleaseDate(long Integer) => new FirstReleaseDate { Integer = Integer };
}
public partial class Media
{
public static Media FromJson(string json) => JsonConvert.DeserializeObject<Media>(json, AlbumSearchContentData.Converter.Settings);
}
public partial class Welcome
{
public static Welcome FromJson(string json) => JsonConvert.DeserializeObject<Welcome>(json, AlbumSearchData.Converter.Settings);
}
public static class Serialize
{
public static string ToJson(this Welcome self) => JsonConvert.SerializeObject(self, AlbumSearchData.Converter.Settings);
}
internal static class Converter
{
public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
{
MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
DateParseHandling = DateParseHandling.None,
Converters =
{
FirstReleaseDateConverter.Singleton,
new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
},
};
}
internal class ParseStringConverter : JsonConverter
{
public override bool CanConvert(Type t) => t == typeof(long) || t == typeof(long?);
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null) return null;
var value = serializer.Deserialize<string>(reader);
long l;
if (Int64.TryParse(value, out l))
{
return l;
}
throw new Exception("Cannot unmarshal type long");
}
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
{
if (untypedValue == null)
{
serializer.Serialize(writer, null);
return;
}
var value = (long)untypedValue;
serializer.Serialize(writer, value.ToString());
return;
}
public static readonly ParseStringConverter Singleton = new ParseStringConverter();
}
internal class FirstReleaseDateConverter : JsonConverter
{
public override bool CanConvert(Type t) => t == typeof(FirstReleaseDate) || t == typeof(FirstReleaseDate?);
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
{
switch (reader.TokenType)
{
case JsonToken.String:
case JsonToken.Date:
var stringValue = serializer.Deserialize<string>(reader);
DateTimeOffset dt;
if (DateTimeOffset.TryParse(stringValue, out dt))
{
return new FirstReleaseDate { DateTime = dt };
}
long l;
if (Int64.TryParse(stringValue, out l))
{
return new FirstReleaseDate { Integer = l };
}
break;
}
throw new Exception("Cannot unmarshal type FirstReleaseDate");
}
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
{
var value = (FirstReleaseDate)untypedValue;
if (value.DateTime != null)
{
serializer.Serialize(writer, value.DateTime.Value.ToString("o", System.Globalization.CultureInfo.InvariantCulture));
return;
}
if (value.Integer != null)
{
serializer.Serialize(writer, value.Integer.Value.ToString());
return;
}
throw new Exception("Cannot marshal type FirstReleaseDate");
}
public static readonly FirstReleaseDateConverter Singleton = new FirstReleaseDateConverter();
}
}

Edit @siycah

Okay Dummheit tut weh, ich glaub ich habs, hätte bloss mal den Kommentar in der automatisch generierten Datenklasse ganz oben lesen müssen.

Dim AlbumContentObject As AlbumSearchContentData.Welcome = AlbumSearchContentData.Welcome.FromJson(ResultAlbumContentSearch)

Noch kurz Datentypen FirstReleaseDates und Guid durch String ersetzt, jetzt kommt zumindest mal kein Fehler...

Jetzt gibt er mir zwar .Position aus, aber nicht .Title...

Edit2 @siycah:
Auch das hab ich hinbekommen:

VB.NET-Quellcode

For Each item In AlbumContentObject.Media(0).Tracks
Console.WriteLine(item.Position & ". " & item.Title)
Next

Edit3 @siycah
Doch ein Problem muss ich nachschieben: Jetzt sagt er:

Die Zeichenfolge wurde nicht als gültiges DateTime erkannt.

Einfach Typ in String umwandeln ist hier glaub nicht, in der Datenklassse ist z.B. das hier (unter leider sehr vielen Vorkommen, ich weiss nicht genau wo er das anmeckert):

C#-Quellcode

public partial struct FirstReleaseDate
{
public DateTimeOffset? DateTime;
public long? Integer;
public static implicit operator FirstReleaseDate(DateTimeOffset DateTime) => new FirstReleaseDate { DateTime = DateTime };
public static implicit operator FirstReleaseDate(long Integer) => new FirstReleaseDate { Integer = Integer };
}

Kann man da vielleicht irgendwas an der DateTime-Formatierung ändern, ich glaube das Problem liegt daran, dass im JSON das amerikanische Datumsformat ausgegeben wird... YYYY-MM-DD oder so...

siycah · 31. Dezember 2023, 12:32

kafffee schrieb:

Okay Dummheit tut weh

Willkommen in der Welt der Softwareentwicklung

Solche Hirnfurze haben wir alle mal.

kafffee schrieb:

Doch ein Problem muss ich nachschieben

Dafür sind wir da.

kafffee schrieb:

as amerikanische Datumsformat ausgegeben wird... YYYY-MM-DD oder so...

Das ist das japanische Datums-Format (und mMn sowieso das Format, was alle nutzen sollten).
Amerikanisch schaut folgendermaßen aus: MM-DD-YYYY

Du könntest das hier probieren:

C#-Quellcode

if (DateTime.TryParseExact("2015-12-25", "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out var timestamp)) {
// success
} else {
// Fehlermeldung?
}

kafffee · 31. Dezember 2023, 12:44

Okay da ham wir noch ein Bug in meinem Gehirn gefunden. Jetzt war ich 25 Jahre der festen Meinung, dass das das amerikanische Format ist haha

Versteh ich den Code richtig, der stellt also klassenweit/programmweit/systemweit(??) das benutzte Datumsformat auf AdjustToUniversal?

siycah · 31. Dezember 2023, 13:00

kafffee schrieb:

Jetzt war ich 25 Jahre der festen Meinung

Dann hast du noch nie etwas mit DateTimes zu tun gehabt, sowie mit Zeitzonen. Schätz dich glücklich. Es gibt nichts schlimmeres, als Daten und Uhrzeiten...

kafffee schrieb:

Versteh ich den Code richtig

Leider nein

kafffee schrieb:

der stellt also klassenweit/programmweit/systemweit(??) das benutzte Datumsformat auf AdjustToUniversal?

Nein, du übergibst der TryParseExact-Methode nur das eine Mal diese Parameter mit. Ich weiß ehrlich gesagt gar nicht, ob man das für die gesamte Applikation einstellen kann. Hab ich nie das Bedürfnis gehabt.

Was der Code macht, ist der versucht mit der Methode das exakte Datum zu parsen, mit einer variablen Culture (also Zeichen, die drin vorkommen) und danach justiert er das zu Universal Time, also UTC+0 (GMT = London Time ohne Sommerzeit).

Dann gibst noch out var timestamp, das ist die Output-Variable.
Man könnte den Code jetzt noch umschreiben, dass du irgendwo vorher die Variable definierst, aber das macht glaube ich weniger Sinn.

Im Prinzip musst du dir das out var vorstellen, als würdest du per Referenz eine Variable mitgeben. (Naja, so funktioniert es auch im Hintergrund, aber syntactic Sugar und so weiter)

kafffee · 1. Januar 2024, 10:46

Gutes Neues! Hoff du bist gut reingeschlittert

siycah schrieb:

Dann hast du noch nie etwas mit DateTimes zu tun gehabt, sowie mit Zeitzonen.

In der Tat, zumindest nicht programmatisch

siycah schrieb:

Leider nein

Wäre auch zu schön gewesen

Okay ich denke den Code hab ich verstanden. out wäre also das Äquivalent zu ByRef in VB?

Hab mir meine Datenklassen mal genauer angeschaut. Da gibts nicht mal eine Property As DateTime, nur:

public DateTimeOffset Date { get; set; }

Wie würdest du in dem Fall vorgehen?

Wenn das jetzt eine Property As DateTime gewesen wäre, hätte ich im Getter deinen Code platziert, aber wenn das kein DateTime ist??

Fehler beim Deserialisieren von JSON - System.InvalidCastException

Fehler beim Deserialisieren von JSON - System.InvalidCastException

VB.NET-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

C#-Quellcode

VB.NET-Quellcode

kafffee schrieb:

VB.NET-Quellcode

ErfinderDesRades schrieb:

kafffee schrieb:

kafffee schrieb:

kafffee schrieb:

kafffee schrieb:

kafffee schrieb:

ErfinderDesRades schrieb:

ErfinderDesRades schrieb:

C#-Quellcode

VB.NET-Quellcode

C#-Quellcode

VB.NET-Quellcode

C#-Quellcode

kafffee schrieb:

kafffee schrieb:

kafffee schrieb:

C#-Quellcode

kafffee schrieb:

kafffee schrieb:

kafffee schrieb:

siycah schrieb:

siycah schrieb:

Ähnliche Themen

6 Benutzer haben hier geschrieben