public ApiRunner(System.Text.Json.JsonDocument input) { this.input = input; this.context = new DadeAfzaMongoDbContext(); this.context.OpenDatabase("Db_1"); Parse(); }
public ParamValues DeSerialize(string fluxstring, ParamValues retour = null) { try { if (retour == null) { retour = new ParamValues(); } System.Text.Json.JsonDocument jsondoc = System.Text.Json.JsonDocument.Parse(fluxstring); if (jsondoc.RootElement.ValueKind != JsonValueKind.Object) { throw new Exception("Invalid Json : Object Root Type Required"); } //Newtonsoft.Json.Linq.JObject jobject = Newtonsoft.Json.Linq.JObject.Parse(fluxstring); foreach (var joitem in jsondoc.RootElement.EnumerateObject().ToList()) { FromJsonSub(retour, joitem, "/param/"); } retour.AcceptChanges(); // on retire les marqueurs de changements return(retour); } catch (Exception ex) { throw new Exception("FromFluxJson " + ex.Message, ex); } }
public KeyValues DeSerialize(string fluxstring) { if (string.IsNullOrWhiteSpace(fluxstring)) { return(new KeyValues()); } System.Text.Json.JsonDocument jsondoc = System.Text.Json.JsonDocument.Parse(fluxstring); if (jsondoc.RootElement.ValueKind != JsonValueKind.Object) { throw new Exception("Invalid Json : Object Root Type Required"); } KeyValues keyValues = new KeyValues(); var vals = jsondoc.RootElement.EnumerateObject().ToList().SelectMany(elem => DeSerializeOne(elem)).ToList(); keyValues.AddRange(vals); return(keyValues); }
private void ReadTipranksNewsItems(List <NewsItem> p_foundNewsItems, string p_ticker, string webpageData) { try { // var jsonOptions = new System.Text.Json.JsonSerializerOptions // { // AllowTrailingCommas = true // }; // NewsItem jsonObject = System.Text.Json.JsonSerializer.Deserialize<NewsItem>(webpageData, jsonOptions); System.Text.Json.JsonDocument document = System.Text.Json.JsonDocument.Parse(webpageData); JsonElement root = document.RootElement; JsonElement newssElement = root.GetProperty("news"); foreach (JsonElement news in newssElement.EnumerateArray()) { NewsItem newsItem = new NewsItem(); newsItem.Ticker = p_ticker; newsItem.LinkUrl = news.GetProperty("url").GetRawText().Trim('"'); newsItem.Title = news.GetProperty("title").GetRawText().Trim('"'); newsItem.Summary = " "; newsItem.Sentiment = news.GetProperty("sentiment").GetRawText().Trim('"'); DateTime date; if (DateTime.TryParse(news.GetProperty("articleTimestamp").GetRawText().Trim('"'), out date)) { newsItem.PublishDate = date; } newsItem.DownloadTime = DateTime.Now; newsItem.Source = NewsSource.TipRanks.ToString(); if (AddNewsToMemory(p_ticker, newsItem)) { p_foundNewsItems.Add(newsItem); } } } catch (Exception) { DateTime.Today.AddDays(1); } }
private static bool TryParseValue(ref Utf8JsonReader reader, out JsonDocument document, bool shouldThrow) { JsonReaderState state = reader.CurrentState; CheckSupportedOptions(state.Options, nameof(reader)); // Value copy to overwrite the ref on an exception and undo the destructive reads. Utf8JsonReader restore = reader; ReadOnlySpan <byte> valueSpan = default; ReadOnlySequence <byte> valueSequence = default; try { switch (reader.TokenType) { // A new reader was created and has never been read, // so we need to move to the first token. // (or a reader has terminated and we're about to throw) case JsonTokenType.None: // Using a reader loop the caller has identified a property they wish to // hydrate into a JsonDocument. Move to the value first. case JsonTokenType.PropertyName: { if (!reader.Read()) { if (shouldThrow) { ThrowHelper.ThrowJsonReaderException( ref reader, ExceptionResource.ExpectedJsonTokens); } reader = restore; document = null; return(false); } break; } } switch (reader.TokenType) { // Any of the "value start" states are acceptable. case JsonTokenType.StartObject: case JsonTokenType.StartArray: { long startingOffset = reader.TokenStartIndex; // Placeholder until reader.Skip() is written (#33295) { int depth = reader.CurrentDepth; // CurrentDepth rises late and falls fast, // a payload of "[ 1, 2, 3, 4 ]" will report post-Read() // CurrentDepth values of { 0, 1, 1, 1, 1, 0 }, // Since we're logically at 0 ([), Read() once and keep // reading until we've come back down to 0 (]). do { if (!reader.Read()) { if (shouldThrow) { ThrowHelper.ThrowJsonReaderException( ref reader, ExceptionResource.ExpectedJsonTokens); } reader = restore; document = null; return(false); } } while (reader.CurrentDepth > depth); } long totalLength = reader.BytesConsumed - startingOffset; ReadOnlySequence <byte> sequence = reader.OriginalSequence; if (sequence.IsEmpty) { valueSpan = reader.OriginalSpan.Slice( checked ((int)startingOffset), checked ((int)totalLength)); } else { valueSequence = sequence.Slice(startingOffset, totalLength); } Debug.Assert( reader.TokenType == JsonTokenType.EndObject || reader.TokenType == JsonTokenType.EndArray); break; } // Single-token values case JsonTokenType.Number: case JsonTokenType.True: case JsonTokenType.False: case JsonTokenType.Null: { if (reader.HasValueSequence) { valueSequence = reader.ValueSequence; } else { valueSpan = reader.ValueSpan; } break; } // String's ValueSequence/ValueSpan omits the quotes, we need them back. case JsonTokenType.String: { ReadOnlySequence <byte> sequence = reader.OriginalSequence; if (sequence.IsEmpty) { // Since the quoted string fit in a ReadOnlySpan originally // the contents length plus the two quotes can't overflow. int payloadLength = reader.ValueSpan.Length + 2; Debug.Assert(payloadLength > 1); ReadOnlySpan <byte> readerSpan = reader.OriginalSpan; Debug.Assert( readerSpan[(int)reader.TokenStartIndex] == (byte)'"', $"Calculated span starts with {readerSpan[(int)reader.TokenStartIndex]}"); Debug.Assert( readerSpan[(int)reader.TokenStartIndex + payloadLength - 1] == (byte)'"', $"Calculated span ends with {readerSpan[(int)reader.TokenStartIndex + payloadLength - 1]}"); valueSpan = readerSpan.Slice((int)reader.TokenStartIndex, payloadLength); } else { long payloadLength = 2; if (reader.HasValueSequence) { payloadLength += reader.ValueSequence.Length; } else { payloadLength += reader.ValueSpan.Length; } valueSequence = sequence.Slice(reader.TokenStartIndex, payloadLength); Debug.Assert( valueSequence.First.Span[0] == (byte)'"', $"Calculated sequence starts with {valueSequence.First.Span[0]}"); Debug.Assert( valueSequence.ToArray()[payloadLength - 1] == (byte)'"', $"Calculated sequence ends with {valueSequence.ToArray()[payloadLength - 1]}"); } break; } default: { if (shouldThrow) { byte displayByte; if (reader.HasValueSequence) { displayByte = reader.ValueSequence.First.Span[0]; } else { displayByte = reader.ValueSpan[0]; } ThrowHelper.ThrowJsonReaderException( ref reader, ExceptionResource.ExpectedStartOfValueNotFound, displayByte); } reader = restore; document = null; return(false); } } } catch { reader = restore; throw; } int length = valueSpan.IsEmpty ? checked ((int)valueSequence.Length) : valueSpan.Length; byte[] rented = ArrayPool <byte> .Shared.Rent(length); Span <byte> rentedSpan = rented.AsSpan(0, length); try { if (valueSpan.IsEmpty) { valueSequence.CopyTo(rentedSpan); } else { valueSpan.CopyTo(rentedSpan); } document = Parse(rented.AsMemory(0, length), state.Options, rented); return(true); } catch { // This really shouldn't happen since the document was already checked // for consistency by Skip. But if data mutations happened just after // the calls to Read then the copy may not be valid. rentedSpan.Clear(); ArrayPool <byte> .Shared.Return(rented); throw; } }
/// <summary> /// Attempts to parse one JSON value (including objects or arrays) from the provided reader. /// </summary> /// <param name="reader">The reader to read.</param> /// <param name="document">Receives the parsed document.</param> /// <returns> /// <see langword="true"/> if a value was read and parsed into a JsonDocument, /// <see langword="false"/> if the reader ran out of data while parsing. /// All other situations result in an exception being thrown. /// </returns> /// <remarks> /// <para> /// If the <see cref="Utf8JsonReader.TokenType"/> property of <paramref name="reader"/> /// is <see cref="JsonTokenType.PropertyName"/> or <see cref="JsonTokenType.None"/>, the /// reader will be advanced by one call to <see cref="Utf8JsonReader.Read"/> to determine /// the start of the value. /// </para> /// /// <para> /// Upon completion of this method <paramref name="reader"/> will be positioned at the /// final token in the JSON value. If an exception is thrown, or <see langword="false"/> /// is returned, the reader is reset to the state it was in when the method was called. /// </para> /// /// <para> /// This method makes a copy of the data the reader acted on, so there is no caller /// requirement to maintain data integrity beyond the return of this method. /// </para> /// </remarks> /// <exception cref="ArgumentException"> /// <paramref name="reader"/> is using unsupported options. /// </exception> /// <exception cref="ArgumentException"> /// The current <paramref name="reader"/> token does not start or represent a value. /// </exception> /// <exception cref="JsonReaderException"> /// A value could not be read from the reader. /// </exception> public static bool TryParseValue(ref Utf8JsonReader reader, out JsonDocument document) { return(TryParseValue(ref reader, out document, shouldThrow: false)); }
internal static JsonElement ParseValue(string json, JsonDocumentOptions options) { JsonDocument document = JsonDocument.ParseValue(json, options); return(document.RootElement); }
internal static JsonElement ParseValue(ReadOnlySpan <byte> utf8Json, JsonDocumentOptions options) { JsonDocument document = JsonDocument.ParseValue(utf8Json, options); return(document.RootElement); }
internal static JsonElement ParseValue(Stream utf8Json, JsonDocumentOptions options) { JsonDocument document = JsonDocument.ParseValue(utf8Json, options); return(document.RootElement); }
public static Object DeepClone(System.Text.Json.JsonDocument doc) { return(DeepClone(doc.RootElement)); }