/// <inheritdoc/> protected override void Dispose(bool disposing) { if (this.IsDisposed) { return; } if (disposing) { _jdoc.Dispose(); } base.Dispose(disposing); }
public void Dispose() { if (json != null) { json.Dispose(); } }
private void TestRequestZipCodeDefault(string json) { JsonDocument jsonDocument = JsonDocument.Parse(json); JsonElement jsonElement = jsonDocument.RootElement; var cep = jsonElement.GetProperty("cep").GetString(); var logradouro = jsonElement.GetProperty("logradouro").GetString(); var complemento = jsonElement.GetProperty("complemento").GetString(); var bairro = jsonElement.GetProperty("bairro").GetString(); var localidade = jsonElement.GetProperty("localidade").GetString(); var uf = jsonElement.GetProperty("uf").GetString(); var siafi = jsonElement.GetProperty("siafi").GetString(); var ibge = jsonElement.GetProperty("ibge").GetString(); var gia = jsonElement.GetProperty("gia").GetString(); var ddd = jsonElement.GetProperty("ddd").GetString(); Assert.IsTrue(!string.IsNullOrEmpty(json)); Assert.IsInstanceOfType(jsonDocument.GetType(), typeof(JsonDocument).GetType()); Assert.IsInstanceOfType(jsonElement.GetType(), typeof(JsonElement).GetType()); Assert.AreEqual("01001-000", cep); //Assert.AreEqual("Praça da Sé", logradouro); //Assert.AreEqual("lado ímpar", complemento); //Assert.AreEqual("Sé", bairro); //Assert.AreEqual("São Paulo", localidade); Assert.AreEqual("SP", uf); Assert.AreEqual("7107", siafi); Assert.AreEqual("11", ddd); Assert.AreEqual("3550308", ibge); Assert.AreEqual("1004", gia); jsonDocument.Dispose(); }
public void Dispose() { if (!disposed) { document.Dispose(); disposed = true; } }
/// <summary> /// Simple demonstration of Parse() method /// </summary> public static void JsonDocument_Parse(JsonDocumentOptions options) { // Example usage Console.WriteLine("JsonDocument.Parse(string)"); // Read in the json file. string path = "Data/users.json"; string jsonString = string.Empty; using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { using (StreamReader streamReader = new StreamReader(fs, Encoding.UTF8)) { jsonString = streamReader.ReadToEnd(); } } JsonDocument jsonDocument = JsonDocument.Parse(jsonString, options); JsonElement rootElement = jsonDocument.RootElement; Console.WriteLine("Root Element ({1}): {0}", rootElement, rootElement.ValueKind); // // Enumerate the object // JsonElement.ObjectEnumerator objectEnumerator = rootElement.EnumerateObject(); // foreach (JsonProperty property in objectEnumerator) // { // Console.WriteLine("Element: {0}: {1}", property.Name, property.Value); // } jsonDocument.Dispose(); // Example usage Console.WriteLine("JsonDocument.Parse(Stream)"); using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { jsonDocument = JsonDocument.Parse(fs); } rootElement = jsonDocument.RootElement; Console.WriteLine("Root Element ({1}): {0}", rootElement, rootElement.ValueKind); jsonDocument.Dispose(); }
/// <summary> /// Look for the deserializer for this json string in the lookup dictionary, and return the object. /// </summary> /// <param name="jsonString"> A json string with a Type property inside the root object </param> /// <returns> The deserialized object </returns> public TBaseObject Deserialize(string jsonString) { JsonDocument jDoc = JsonManager.GetJsonDocument(jsonString); string type = jDoc.RootElement.GetProperty(TypeProperty).GetString(); jDoc.Dispose(); deserializerLookup.TryGetValue(type, out Func <string, TBaseObject> deserializer); return(deserializer(jsonString)); }
public override async Task <List <StreamInfo> > GetVideoList(string url) { List <StreamInfo> videoList = new List <StreamInfo>(); string videoId = url.Split('/')[5]; string title = $"@{url.Split('/')[3]} Twitter video"; using (HttpClient client = new HttpClient()) { //Get javascript player url string pageSource = await client.GetStringAsync("https://twitter.com/i/videos/tweet/" + videoId).ConfigureAwait(false); string jsPlayerUrl = ""; foreach (var line in pageSource.Split('\n')) { if (line.Contains("script")) { jsPlayerUrl = line.Substring(line.IndexOf('"') + 1); jsPlayerUrl = jsPlayerUrl.Remove(jsPlayerUrl.IndexOf('"')); break; } } //Get bearer token pageSource = await client.GetStringAsync(jsPlayerUrl).ConfigureAwait(false); string token = pageSource.Substring(pageSource.IndexOf("Bearer") + 7); token = token.Remove(token.IndexOf('"')); //Get guest_token client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token); HttpResponseMessage response = await client.PostAsync("https://api.twitter.com/1.1/guest/activate.json", null).ConfigureAwait(false); JsonDocument document = JsonDocument.Parse(await response.Content.ReadAsStringAsync().ConfigureAwait(false)); string guestToken = document.RootElement.GetProperty("guest_token").GetString(); //Get m3u8 file client.DefaultRequestHeaders.Add("x-guest-token", guestToken); string jsResponse = await client.GetStringAsync($"https://api.twitter.com/1.1/videos/tweet/config/{videoId}.json").ConfigureAwait(false); document = JsonDocument.Parse(jsResponse); string playbackUrl = document.RootElement.GetProperty("track").GetProperty("playbackUrl").GetString(); string m3u8Content = await client.GetStringAsync(playbackUrl).ConfigureAwait(false); //Get m3u8 playlists foreach (var(relativeUrl, label) in GetPlaylists(m3u8Content)) { videoList.Add(new StreamInfo($"https://video.twimg.com{relativeUrl}", false, title, label, "", 0)); } document.Dispose(); } return(videoList); }
private void TestRequestAddressCodeDefault(string json) { JsonDocument jsonDocument = JsonDocument.Parse(json); JsonElement jsonElement = jsonDocument.RootElement; ArrayEnumerator enumerateArray = jsonElement.EnumerateArray(); Assert.IsTrue(!string.IsNullOrEmpty(json)); Assert.IsTrue(jsonElement.ValueKind == JsonValueKind.Array); Assert.IsTrue(jsonElement.GetArrayLength() > 0); Assert.IsInstanceOfType(jsonDocument.GetType(), typeof(JsonDocument).GetType()); Assert.IsInstanceOfType(jsonElement.GetType(), typeof(JsonElement).GetType()); Assert.IsInstanceOfType(enumerateArray.GetType(), typeof(ArrayEnumerator).GetType()); jsonDocument.Dispose(); }
public async Task Create([Remainder] string rawJsonInput = "") { byte[] byteArray = Encoding.UTF8.GetBytes(rawJsonInput); MemoryStream stream = new MemoryStream(byteArray); try { JsonDocument json = await JsonDocument.ParseAsync(stream); var embed = await _service.BuildAsync(json); await ReplyAsync(embed : embed); await stream.DisposeAsync(); await Task.Run(() => json.Dispose()); } catch (Exception ex) { await _log.Log(new LogMessage(LogSeverity.Error, "input", ex.Message, ex)); } }
public void Dispose() { json.Dispose(); }
public void CleanUp() { _document.Dispose(); }
async public Task handleRequest(HttpContext httpContext) { if (Introspection && httpContext.Request.Path == "/ast.json" && httpContext.Request.Method.ToUpperInvariant() == "GET") { await httpContext.Response.WriteAsync(Api.GetAstJson()); return; } Context? context = null; JsonDocument?bodyDocument = null; var stopWatch = new Stopwatch(); stopWatch.Start(); try { StringValues origin; if (DynamicCorsOrigin && httpContext.Request.Headers.TryGetValue("origin", out origin)) { httpContext.Response.Headers.Add("Access-Control-Allow-Origin", origin); httpContext.Response.Headers.Add("Vary", "Origin"); } string method = httpContext.Request.Method.ToUpperInvariant(); foreach (var header in Headers) { if (method == "OPTIONS" && !header.Key.ToLowerInvariant().StartsWith("access-control-")) { continue; } httpContext.Response.Headers.Add(header.Key, header.Value); } if (method == "OPTIONS") { return; } httpContext.Response.Headers.Add("Content-Type", "application/json; charset=utf-8"); if (method == "HEAD") { return; } if (method == "GET") { if (httpContext.Request.Path.Value != "/") { httpContext.Response.StatusCode = 404; return; } var ok = false; try { ok = await OnHealthCheck(); } catch (Exception) { } httpContext.Response.StatusCode = ok ? 200 : 500; await httpContext.Response.WriteAsync(ok? "{\"ok\":true}" : "{\"ok\":false}"); return; } if (method != "POST") { httpContext.Response.StatusCode = 404; return; } bodyDocument = await JsonDocument.ParseAsync(httpContext.Request.Body); context = ContextParser.DecodeContext(bodyDocument.RootElement, "body"); context.Headers = httpContext.Request.Headers; // TODO: X-Forwarded-For with trusted proxies context.Ip = httpContext.Connection.RemoteIpAddress.ToString(); var duration = stopWatch.Elapsed.TotalSeconds; var bufferWriter = new ArrayBufferWriter <byte>(); using (var resultWriter = new Utf8JsonWriter(bufferWriter)) { resultWriter.WriteStartObject(); resultWriter.WritePropertyName("result"); await Api.ExecuteFunction(context, resultWriter); resultWriter.WriteNull("error"); resultWriter.WriteNumber("duration", duration); resultWriter.WriteString("host", Dns.GetHostName()); resultWriter.WriteEndObject(); } Console.WriteLine($"{context.Id} [{duration.ToString("0.000000")}s] {context.Name}() -> OK"); await httpContext.Response.WriteAsync(Encoding.UTF8.GetString(bufferWriter.WrittenSpan)); } catch (Exception error) { Console.WriteLine(error.ToString()); SdkgenException sdkgenError; if (error is SdkgenException) { sdkgenError = (error as SdkgenException) !; } else { sdkgenError = new SdkgenException("Fatal", error.Message, error); } var duration = stopWatch.Elapsed.TotalSeconds; if (OnRequestError != null && context != null) { OnRequestError.Invoke(context, sdkgenError); Console.WriteLine($"{context.Id} [{duration.ToString("0.000000")}s] {context.Name}() -> {sdkgenError.Type}"); } httpContext.Response.StatusCode = sdkgenError.Type == "Fatal" ? 500 : 400; using (var resultWriter = new Utf8JsonWriter(httpContext.Response.Body)) { resultWriter.WriteStartObject(); resultWriter.WriteNull("result"); resultWriter.WriteStartObject("error"); resultWriter.WriteString("type", sdkgenError.Type); resultWriter.WriteString("message", sdkgenError.Message); resultWriter.WriteEndObject(); resultWriter.WriteNumber("duration", duration); resultWriter.WriteString("host", Dns.GetHostName()); resultWriter.WriteEndObject(); } } finally { bodyDocument?.Dispose(); } }
public void Dispose() { _value.Dispose(); _ownedValueMemory?.Dispose(); }
public void Dispose() { _config.Dispose(); _config = null; }
public void Dispose() { _assetManifestManifestDom.Dispose(); }
public void Dispose() { _appendHyperSchema.Dispose(); _deleteStreamHyperSchema.Dispose(); }
public void Dispose() => _wrapped.Dispose();
public void LoadAsTexture(string fileLocation, string resourceName) { if (_SDL_Renderer == IntPtr.Zero) { Debug.Log("ResourceManager.LoadAsTexture()", "SDL Renderer not yet initialized, waiting for init."); Debug.Log("ResourceManager.LoadAsTexture()", "Warning! Call 'GameEngine.Start()' first before loading game resources."); Debug.Log("ResourceManager.LoadAsTexture()", "Otherwise, this will be an endless loop."); while (_SDL_Renderer == IntPtr.Zero) { SDL_Delay(100); } Debug.Log("ResourceManager.LoadAsTexture()", "SDL Renderer initialized."); //throw new ResourceException($"SDL Renderer not yet initialized, try calling GameEngine.InitGraphics() first", fileLocation); } if (_Textures.Contains(resourceName)) { throw new ResourceException($"A resource with the same name '{resourceName}' already exists.", fileLocation); } if (!File.Exists(fileLocation)) { throw new ResourceException($"Error loading resource '{resourceName}'. File not found.", fileLocation); } ZipArchive archive; try { archive = ZipFile.OpenRead(fileLocation); } catch { throw new ResourceException($"Error loading resource '{resourceName}'.", fileLocation); } bool loadedMetadata = false; List <string> files = new List <string>(); Size spriteSize = new Size(), sheetSize = new Size(); bool isSheet = false; foreach (ZipArchiveEntry entry in archive.Entries) { if (entry.Name == "metadata") { loadedMetadata = true; using (Stream ms = entry.Open()) { try { StreamReader reader = new StreamReader(ms); string json = reader.ReadToEnd(); reader.Close(); JsonDocument doc = JsonDocument.Parse(json); var meta = doc.RootElement; isSheet = meta.GetProperty("IsSheet").GetBoolean(); spriteSize.W = meta.GetProperty("SpriteSize.W").GetInt32(); spriteSize.H = meta.GetProperty("SpriteSize.H").GetInt32(); sheetSize.W = meta.GetProperty("SheetSize.W").GetInt32(); sheetSize.H = meta.GetProperty("SheetSize.H").GetInt32(); doc.Dispose(); } catch { throw new ResourceException($"Error parsing metadata for '{resourceName}'.", fileLocation); } } } else { files.Add(entry.Name); } } if (!loadedMetadata && !FLAG_ALLOW_MISSING_METADATA) { archive.Dispose(); throw new ResourceException($"Error loading resource '{resourceName}'. Metadata not found.", fileLocation); } List <IntPtr> surfaces = new List <IntPtr>(); List <IntPtr> textures = new List <IntPtr>(); /* Load resource here */ SDL_GetError(); foreach (string file in files) { try { ZipArchiveEntry data = archive.GetEntry(file); Stream s = data.Open(); byte[] buffer = new byte[data.Length]; //GCHandle handle = GCHandle.Alloc(byteData, GCHandleType.Pinned); IntPtr ptrArray = Marshal.AllocHGlobal(buffer.Length); s.Read(buffer, 0, buffer.Length); Marshal.Copy(buffer, 0, ptrArray, buffer.Length); Debug.Log("ResourceManager.LoadAsTexture()", $"Read texture data from {file}#{resourceName} @ {buffer.Length} byte(s)."); IntPtr rwops = SDL_RWFromMem(ptrArray, buffer.Length); IntPtr surface; surface = IMG_Load_RW(rwops, 0); string sE1 = SDL_GetError(); if (surface == IntPtr.Zero || rwops == IntPtr.Zero) { Debug.Log("ResourceManager.LoadAsTexture()", $"Error reading texture data {file}#{resourceName}. {sE1}"); continue; } Debug.Log("ResourceManager.LoadAsTexture()", $"Loaded texture data as surface from {file}#{resourceName}."); IntPtr texture; while (_SDL_Renderer == IntPtr.Zero) { SDL_Delay(100); } try { if (!FLAG_USE_ALTERNATE_TEXTURE_STRAT) { //SDL_Renderc texture = SDL_CreateTextureFromSurface(_SDL_Renderer, surface); //texture = CreateTexture(_SDL_Renderer, surface); } else { #pragma warning disable CS0162 // Unreachable code detected texture = IMG_LoadTexture_RW(_SDL_Renderer, rwops, 0); #pragma warning restore CS0162 // Unreachable code detected } } catch (Exception e) { Debug.Log("ResourceManager.LoadAsTexture()", $"Error creating texture data {file}#{resourceName}. {e.Message}"); continue; } string sE2 = SDL_GetError(); if (texture == IntPtr.Zero) { Debug.Log("ResourceManager.LoadAsTexture()", $"Error creating texture data {file}#{resourceName}. {sE2}"); continue; } surfaces.Add(surface); textures.Add(texture); Debug.Log("ResourceManager.LoadAsTexture()", $"Created texture from surface {file}#{resourceName}."); //SDL_FreeSurface(surface); Marshal.FreeHGlobal(ptrArray); SDL_RWclose(rwops); } catch { Debug.Log("ResourceManager.LoadAsTexture()", $"Error loading texture {file}#{resourceName}. Skipped file."); } } archive.Dispose(); TextureResource res = new TextureResource() { IsSpriteSheet = isSheet, SheetSize = sheetSize, SpriteSize = spriteSize, DataPtr = surfaces.ToArray(), Textures = textures.ToArray(), ResourceName = resourceName }; _Textures.Add(res); Debug.Log("ResourceManager.LoadAsTexture()", $"Successfully added texture {resourceName} to resources."); }
private HubMessage ParseMessage(ReadOnlySequence <byte> input, IInvocationBinder binder) { try { // We parse using the Utf8JsonReader directly but this has a problem. Some of our properties are dependent on other properties // and since reading the json might be unordered, we need to store the parsed content as JsonDocument to re-parse when true types are known. // if we're lucky and the state we need to directly parse is available, then we'll use it. int? type = null; string invocationId = null; string target = null; string error = null; var hasItem = false; object item = null; var hasResult = false; object result = null; var hasArguments = false; object[] arguments = null; string[] streamIds = null; JsonDocument argumentsToken = null; JsonDocument itemsToken = null; JsonDocument resultToken = null; ExceptionDispatchInfo argumentBindingException = null; Dictionary <string, string> headers = null; var completed = false; var reader = new Utf8JsonReader(input, isFinalBlock: true, state: default); reader.CheckRead(); // We're always parsing a JSON object reader.EnsureObjectStart(); do { switch (reader.TokenType) { case JsonTokenType.PropertyName: if (reader.TextEquals(TypePropertyNameBytes.EncodedUtf8Bytes)) { type = reader.ReadAsInt32(TypePropertyName); if (type == null) { throw new InvalidDataException($"Expected '{TypePropertyName}' to be of type {JsonTokenType.Number}."); } } else if (reader.TextEquals(InvocationIdPropertyNameBytes.EncodedUtf8Bytes)) { invocationId = reader.ReadAsString(InvocationIdPropertyName); } else if (reader.TextEquals(StreamIdsPropertyNameBytes.EncodedUtf8Bytes)) { reader.CheckRead(); if (reader.TokenType != JsonTokenType.StartArray) { throw new InvalidDataException( $"Expected '{StreamIdsPropertyName}' to be of type {SystemTextJsonExtensions.GetTokenString(JsonTokenType.StartArray)}."); } var newStreamIds = new List <string>(); reader.Read(); while (reader.TokenType != JsonTokenType.EndArray) { newStreamIds.Add(reader.GetString()); reader.Read(); } streamIds = newStreamIds.ToArray(); } else if (reader.TextEquals(TargetPropertyNameBytes.EncodedUtf8Bytes)) { target = reader.ReadAsString(TargetPropertyName); } else if (reader.TextEquals(ErrorPropertyNameBytes.EncodedUtf8Bytes)) { error = reader.ReadAsString(ErrorPropertyName); } else if (reader.TextEquals(ResultPropertyNameBytes.EncodedUtf8Bytes)) { hasResult = true; reader.CheckRead(); if (string.IsNullOrEmpty(invocationId)) { // If we don't have an invocation id then we need to store it as a JsonDocument so we can parse it later resultToken = JsonDocument.ParseValue(ref reader); } else { // If we have an invocation id already we can parse the end result var returnType = binder.GetReturnType(invocationId); using var token = JsonDocument.ParseValue(ref reader); result = BindType(token.RootElement, returnType); } } else if (reader.TextEquals(ItemPropertyNameBytes.EncodedUtf8Bytes)) { reader.CheckRead(); hasItem = true; string id = null; if (!string.IsNullOrEmpty(invocationId)) { id = invocationId; } else { // If we don't have an id yet then we need to store it as a JsonDocument to parse later itemsToken = JsonDocument.ParseValue(ref reader); continue; } try { var itemType = binder.GetStreamItemType(id); using var token = JsonDocument.ParseValue(ref reader); item = BindType(token.RootElement, itemType); } catch (Exception ex) { return(new StreamBindingFailureMessage(id, ExceptionDispatchInfo.Capture(ex))); } } else if (reader.TextEquals(ArgumentsPropertyNameBytes.EncodedUtf8Bytes)) { reader.CheckRead(); int initialDepth = reader.CurrentDepth; if (reader.TokenType != JsonTokenType.StartArray) { throw new InvalidDataException($"Expected '{ArgumentsPropertyName}' to be of type {SystemTextJsonExtensions.GetTokenString(JsonTokenType.StartArray)}."); } hasArguments = true; if (string.IsNullOrEmpty(target)) { // We don't know the method name yet so just store the array in JsonDocument argumentsToken = JsonDocument.ParseValue(ref reader); } else { try { var paramTypes = binder.GetParameterTypes(target); using var token = JsonDocument.ParseValue(ref reader); arguments = BindTypes(token.RootElement, paramTypes); } catch (Exception ex) { argumentBindingException = ExceptionDispatchInfo.Capture(ex); // Could be at any point in argument array JSON when an error is thrown // Read until the end of the argument JSON array while (reader.CurrentDepth == initialDepth && reader.TokenType == JsonTokenType.StartArray || reader.CurrentDepth > initialDepth) { reader.CheckRead(); } } } } else if (reader.TextEquals(HeadersPropertyNameBytes.EncodedUtf8Bytes)) { reader.CheckRead(); headers = ReadHeaders(ref reader); } else { reader.CheckRead(); reader.Skip(); } break; case JsonTokenType.EndObject: completed = true; break; } }while (!completed && reader.CheckRead()); HubMessage message; switch (type) { case HubProtocolConstants.InvocationMessageType: { if (argumentsToken != null) { // We weren't able to bind the arguments because they came before the 'target', so try to bind now that we've read everything. try { var paramTypes = binder.GetParameterTypes(target); arguments = BindTypes(argumentsToken.RootElement, paramTypes); } catch (Exception ex) { argumentBindingException = ExceptionDispatchInfo.Capture(ex); } finally { argumentsToken.Dispose(); } } message = argumentBindingException != null ? new InvocationBindingFailureMessage(invocationId, target, argumentBindingException) : BindInvocationMessage(invocationId, target, arguments, hasArguments, streamIds, binder); } break; case HubProtocolConstants.StreamInvocationMessageType: { if (argumentsToken != null) { // We weren't able to bind the arguments because they came before the 'target', so try to bind now that we've read everything. try { var paramTypes = binder.GetParameterTypes(target); arguments = BindTypes(argumentsToken.RootElement, paramTypes); } catch (Exception ex) { argumentBindingException = ExceptionDispatchInfo.Capture(ex); } finally { argumentsToken.Dispose(); } } message = argumentBindingException != null ? new InvocationBindingFailureMessage(invocationId, target, argumentBindingException) : BindStreamInvocationMessage(invocationId, target, arguments, hasArguments, streamIds, binder); } break; case HubProtocolConstants.StreamItemMessageType: if (itemsToken != null) { try { var returnType = binder.GetStreamItemType(invocationId); item = BindType(itemsToken.RootElement, returnType); } catch (JsonException ex) { message = new StreamBindingFailureMessage(invocationId, ExceptionDispatchInfo.Capture(ex)); break; } finally { itemsToken.Dispose(); } } message = BindStreamItemMessage(invocationId, item, hasItem, binder); break; case HubProtocolConstants.CompletionMessageType: if (resultToken != null) { try { var returnType = binder.GetReturnType(invocationId); result = BindType(resultToken.RootElement, returnType); } finally { resultToken.Dispose(); } } message = BindCompletionMessage(invocationId, error, result, hasResult, binder); break; case HubProtocolConstants.CancelInvocationMessageType: message = BindCancelInvocationMessage(invocationId); break; case HubProtocolConstants.PingMessageType: return(PingMessage.Instance); case HubProtocolConstants.CloseMessageType: return(BindCloseMessage(error)); case null: throw new InvalidDataException($"Missing required property '{TypePropertyName}'."); default: // Future protocol changes can add message types, old clients can ignore them return(null); } return(ApplyHeaders(message, headers)); } catch (JsonException jrex) { throw new InvalidDataException("Error reading JSON.", jrex); } }
/// <inheritdoc /> public void Dispose() { _manifest?.Dispose(); HttpClient?.Dispose(); }
public void Dispose() { _decodedToken.Dispose(); }
public void Dispose() => _setStreamMetadata.Dispose();