private async void BroadcastMessage(Message message) { JsonElement jsonElement = (JsonElement)message.Content; switch (message.Type) { case MessageType.START_GAME: CanStartGame = jsonElement.GetBoolean(); break; case MessageType.PLAYER_MOVE: BoardCell playerCell = (BoardCell)Enum.Parse(typeof(BoardCell), jsonElement.GetProperty("playerCell").ToString()); int index = jsonElement.GetProperty("index").GetInt32(); GameManager.ExecuteMove(playerCell, index); HandleGameFinish(index); break; case MessageType.DISCONNECT_GAME: IsInterrupted = jsonElement.GetBoolean(); await DisconnectAsync(); break; default: break; } StateHasChanged(); }
private static object ParseJson(JsonElement element) { switch (element.ValueKind) { case JsonValueKind.Number: return(element.GetInt32()); case JsonValueKind.True: case JsonValueKind.False: return(element.GetBoolean()); case JsonValueKind.String: return(element.GetString()); case JsonValueKind.Array: var array = new List <object>(); foreach (var item in element.EnumerateArray()) { array.Add(ParseJson(item)); } return(array); case JsonValueKind.Object: var obj = new Dictionary <string, object>(); foreach (var prop in element.EnumerateObject()) { obj.Add(prop.Name, ParseJson(prop.Value)); } return(obj); default: return(null); } }
private object GetValue(JsonElement enumValue) { switch (enumValue.ValueKind) { case JsonValueKind.String: return(enumValue.GetString()); case JsonValueKind.Number: if (enumValue.TryGetInt32(out Int32 intValue)) { return(enumValue.GetInt32()); } if (enumValue.TryGetInt64(out Int64 LongValue)) { return(enumValue.GetInt64()); } return(enumValue.GetDouble()); case JsonValueKind.True: case JsonValueKind.False: return(enumValue.GetBoolean()); case JsonValueKind.Null: return(null); default: return(enumValue.ToString()); } }
private static object WrapResultObject(JsonElement value) { switch (value.ValueKind) { case JsonValueKind.Array: return(value.EnumerateArray() .Select(x => WrapResultObject(x)) .ToList()); case JsonValueKind.Object: return(new DynamicJsonObject(value)); case JsonValueKind.False: case JsonValueKind.True: return(value.GetBoolean()); case JsonValueKind.String: return(value.GetString()); case JsonValueKind.Number: return(value.GetInt64()); case JsonValueKind.Null: case JsonValueKind.Undefined: return(null); default: return(value); } }
protected object GetValue(JsonElement elm) { object value = null; switch (elm.ValueKind) { case JsonValueKind.String: value = elm.GetString(); break; case JsonValueKind.Number: value = elm.GetInt32(); break; case JsonValueKind.True: value = elm.GetBoolean(); break; case JsonValueKind.Array: var values = new List <object>(); var enumerateArray = elm.EnumerateArray(); while (enumerateArray.MoveNext()) { values.Add(GetValue(enumerateArray.Current)); } value = values; break; } return(value); }
private static bool TryGetPrimitiveFromJsonElement(JsonElement jsonElement, out object elementValue) { elementValue = null; if (jsonElement.ValueKind == JsonValueKind.True || jsonElement.ValueKind == JsonValueKind.False) { elementValue = jsonElement.GetBoolean(); } else if (jsonElement.ValueKind == JsonValueKind.Number) { if (jsonElement.TryGetInt32(out var vali)) { elementValue = vali; } if (jsonElement.TryGetInt64(out var vall)) { elementValue = vall; } if (jsonElement.TryGetDouble(out var val)) { elementValue = val; } } else if (jsonElement.ValueKind == JsonValueKind.String) { elementValue = jsonElement.GetString(); } else if (jsonElement.ValueKind == JsonValueKind.Undefined) { elementValue = ""; } return(elementValue != null); }
static object GetPropertyValue(JsonElement jsonElement) { switch (jsonElement.ValueKind) { case JsonValueKind.String: return(jsonElement.GetString()); case JsonValueKind.Number: int integerOutput; if (jsonElement.TryGetInt32(out integerOutput)) { return(integerOutput); } else { return(jsonElement.GetDecimal()); } case JsonValueKind.True: case JsonValueKind.False: return(jsonElement.GetBoolean()); case JsonValueKind.Null: return(null); case JsonValueKind.Object: case JsonValueKind.Array: return(ParseJsonElement(jsonElement)); } throw new ArgumentException(); }
private string GetStringValue(JsonElement value) { var valueKind = value.ValueKind; if (valueKind == JsonValueKind.Array) { return(string.Empty); } if (valueKind == JsonValueKind.False || valueKind == JsonValueKind.True) { return(value.GetBoolean().ToString()); } if (valueKind == JsonValueKind.Number) { return(value.GetDecimal().ToString()); } if (valueKind == JsonValueKind.String) { return(value.GetString()); } return(default);
public bool ConnectionIsValid() { if (RestDriverErrorState != RestDriverErrorState.NoError) { return(false); } try { string rawJson = webClient.DownloadString("/startup/validate"); JsonDocument jsonDocument = JsonDocument.Parse(rawJson); JsonElement isValid = jsonDocument.RootElement.GetProperty("isValid"); return(isValid.GetBoolean()); } catch (WebException web) { Console.WriteLine(web.Status); if (web.Status == WebExceptionStatus.ProtocolError) { HttpWebResponse hwr = (HttpWebResponse)web.Response; if (hwr.StatusCode == HttpStatusCode.Unauthorized) { Console.WriteLine("Die Lizenznummer \"{0}\" wurde abgelehnt.", this.license); } else { Console.WriteLine(hwr.StatusDescription); } } return(false); } }
public static void SetValueFromJson(this PropertyInfo property, Object obj, JsonElement value, string dateTimeFormat = null) { TypeCode typeCode = Type.GetTypeCode(property.PropertyType); switch (typeCode) { case TypeCode.Int32: int int32Value = value.GetInt32(); property.SetValue(obj, int32Value); break; case TypeCode.Int64: long int64Value = value.GetInt64(); property.SetValue(obj, int64Value); break; case TypeCode.Double: double doubleValue = value.GetDouble(); property.SetValue(obj, doubleValue); break; case TypeCode.Decimal: decimal decimalValue = value.GetDecimal(); property.SetValue(obj, decimalValue); break; case TypeCode.Boolean: bool boolValue = value.GetBoolean(); property.SetValue(obj, boolValue); break; case TypeCode.DateTime: DateTime dateTimeValue; if (value.ValueKind == JsonValueKind.Null) { dateTimeValue = DateTime.MinValue; } else if (!string.IsNullOrEmpty(dateTimeFormat)) { var stringDateTimeValue = value.GetString(); dateTimeValue = DateTime.ParseExact(stringDateTimeValue, dateTimeFormat, CultureInfo.InvariantCulture); } else { dateTimeValue = value.GetDateTime(); } property.SetValue(obj, dateTimeValue); break; case TypeCode.String: string stringValue = value.GetString(); property.SetValue(obj, stringValue); break; default: //ThrowNotImplementedException(type); TODO: Сделать исключение. break; } }
public static dynamic ParseValue(this JsonElement el) { switch (el.ValueKind) { case JsonValueKind.Object: return(el.CreateDictionary()); case JsonValueKind.Array: var list = new List <dynamic>(); foreach (var item in el.EnumerateArray()) { list.Add(item.ParseValue()); } return(list.ToArray()); case JsonValueKind.Number: return(el.GetDouble()); case JsonValueKind.String: return(el.GetString()); case JsonValueKind.False: case JsonValueKind.True: return(el.GetBoolean()); case JsonValueKind.Null: case JsonValueKind.Undefined: default: return(null); } }
private object GetSettingValue(string name, JsonElement jsonElement) { switch (jsonElement.ValueKind) { case JsonValueKind.Number: return(jsonElement.GetDouble()); case JsonValueKind.String: return(jsonElement.GetString()); case JsonValueKind.True: case JsonValueKind.False: return(jsonElement.GetBoolean()); case JsonValueKind.Object: Dictionary <string, object> dict = new Dictionary <string, object>(); foreach (var item in jsonElement.EnumerateObject()) { dict[item.Name] = GetSettingValue(name, item.Value); } return(dict); default: throw logger.Error(new SettingException(name, jsonElement, "Unsupported type")); } }
public static object GetValue(this JsonElement json, Type type) { switch (Type.GetTypeCode(type)) { case TypeCode.Boolean: return(json.GetBoolean()); case TypeCode.SByte: return(json.GetSByte()); case TypeCode.Int16: return(json.GetInt16()); case TypeCode.Int32: return(json.GetInt32()); case TypeCode.Int64: return(json.GetInt64()); case TypeCode.Byte: return(json.GetByte()); case TypeCode.UInt16: return(json.GetUInt16()); case TypeCode.UInt32: return(json.GetUInt32()); case TypeCode.UInt64: return(json.GetUInt64()); case TypeCode.Single: return(json.GetSingle()); case TypeCode.Double: return(json.GetDouble()); case TypeCode.Decimal: return(json.GetDecimal()); case TypeCode.String: return(json.GetString()); case TypeCode.DateTime: return(json.GetDateTime()); } return(Convert.ChangeType(json.GetRawText(), type)); }
public static bool?GetNullableBool(this JsonElement jsonElement) { if (jsonElement.ValueKind == JsonValueKind.Null) { return(null); } return(jsonElement.GetBoolean()); }
public static void ExpandoObject() { ExpandoObject expando = JsonSerializer.Deserialize <ExpandoObject>(Json); Assert.Equal(8, ((IDictionary <string, object>)expando).Keys.Count); dynamic obj = expando; VerifyPrimitives(); VerifyObject(); VerifyArray(); // Re-serialize string json = JsonSerializer.Serialize <ExpandoObject>(obj); JsonTestHelper.AssertJsonEqual(Json, json); json = JsonSerializer.Serialize <dynamic>(obj); JsonTestHelper.AssertJsonEqual(Json, json); json = JsonSerializer.Serialize(obj); JsonTestHelper.AssertJsonEqual(Json, json); void VerifyPrimitives() { JsonElement jsonElement = obj.MyString; Assert.Equal("Hello", jsonElement.GetString()); jsonElement = obj.MyBoolean; Assert.True(jsonElement.GetBoolean()); jsonElement = obj.MyInt; Assert.Equal(42, jsonElement.GetInt32()); jsonElement = obj.MyDateTime; Assert.Equal(MyDateTime, jsonElement.GetDateTime()); jsonElement = obj.MyGuid; Assert.Equal(MyGuid, jsonElement.GetGuid()); } void VerifyObject() { JsonElement jsonElement = obj.MyObject; // Here we access a property on a nested object and must use JsonElement (not a dynamic property). Assert.Equal("World", jsonElement.GetProperty("MyString").GetString()); } void VerifyArray() { JsonElement jsonElement = obj.MyArray; Assert.Equal(2, jsonElement.EnumerateArray().Count()); } }
public async Task TestActorSettings() { var actorType = typeof(TestActor); var options = new ActorRuntimeOptions(); options.Actors.RegisterActor <TestActor>(); options.ActorIdleTimeout = TimeSpan.FromSeconds(33); options.ActorScanInterval = TimeSpan.FromSeconds(44); options.DrainOngoingCallTimeout = TimeSpan.FromSeconds(55); options.DrainRebalancedActors = true; var runtime = new ActorRuntime(options, loggerFactory, activatorFactory, proxyFactory); Assert.Contains(actorType.Name, runtime.RegisteredActors.Select(a => a.Type.ActorTypeName), StringComparer.InvariantCulture); ArrayBufferWriter <byte> writer = new ArrayBufferWriter <byte>(); await runtime.SerializeSettingsAndRegisteredTypes(writer); // read back the serialized json var array = writer.WrittenSpan.ToArray(); string s = Encoding.UTF8.GetString(array, 0, array.Length); JsonDocument document = JsonDocument.Parse(s); JsonElement root = document.RootElement; // parse out the entities array JsonElement element = root.GetProperty("entities"); Assert.Equal(1, element.GetArrayLength()); JsonElement arrayElement = element[0]; string actor = arrayElement.GetString(); Assert.Equal("TestActor", actor); // validate the other properties have expected values element = root.GetProperty("actorIdleTimeout"); Assert.Equal(TimeSpan.FromSeconds(33), ConverterUtils.ConvertTimeSpanFromDaprFormat(element.GetString())); element = root.GetProperty("actorScanInterval"); Assert.Equal(TimeSpan.FromSeconds(44), ConverterUtils.ConvertTimeSpanFromDaprFormat(element.GetString())); element = root.GetProperty("drainOngoingCallTimeout"); Assert.Equal(TimeSpan.FromSeconds(55), ConverterUtils.ConvertTimeSpanFromDaprFormat(element.GetString())); element = root.GetProperty("drainRebalancedActors"); Assert.True(element.GetBoolean()); bool found = root.TryGetProperty("remindersStoragePartitions", out element); Assert.False(found, "remindersStoragePartitions should not be serialized"); JsonElement jsonValue; Assert.False(root.GetProperty("reentrancy").TryGetProperty("maxStackDepth", out jsonValue)); }
/// <summary> /// JsonElement の値を真偽値に変換します。 /// </summary> /// <param name="prop">JsonElement。</param> /// <returns>真偽値に変換された JsonElement。</returns> public static bool ToBoolean(JsonElement prop) { if (prop.ValueKind == JsonValueKind.True || prop.ValueKind == JsonValueKind.False) { return(prop.GetBoolean()); } throw new ArgumentException(); }
public override void SerializePrimitive <T>(ref T val) { switch (val) { case bool: Unsafe.As <T, bool>(ref val) = currentNode.GetBoolean(); break; case int: Unsafe.As <T, int>(ref val) = currentNode.GetInt32(); break; case uint: Unsafe.As <T, uint>(ref val) = currentNode.GetUInt32(); break; case float: Unsafe.As <T, float>(ref val) = currentNode.GetSingle(); break; case double: Unsafe.As <T, double>(ref val) = currentNode.GetDouble(); break; case long: Unsafe.As <T, long>(ref val) = currentNode.GetInt64(); break; case ulong: Unsafe.As <T, ulong>(ref val) = currentNode.GetUInt64(); break; case short: Unsafe.As <T, short>(ref val) = currentNode.GetInt16(); break; case ushort: Unsafe.As <T, ushort>(ref val) = currentNode.GetUInt16(); break; case char: Unsafe.As <T, char>(ref val) = (char)currentNode.GetUInt16(); break; case sbyte: Unsafe.As <T, sbyte>(ref val) = currentNode.GetSByte(); break; case byte: Unsafe.As <T, byte>(ref val) = currentNode.GetByte(); break; case decimal: Unsafe.As <T, decimal>(ref val) = currentNode.GetDecimal(); break; } }
private static bool IsMatchingType(Type type, JsonElement jsonElement, JsonSerializerOptions jsonSerializerOptions, out object value) { if (IsMatchingBoolean(type, jsonElement)) { value = jsonElement.GetBoolean(); return(true); } if (IsMatchingInteger(type, jsonElement)) { value = jsonElement.GetInt32(); return(true); } if (IsMatchingDouble(type, jsonElement)) { value = jsonElement.GetDouble(); return(true); } if (IsMatchingString(type, jsonElement)) { value = jsonElement.GetString(); return(true); } if (IsMatchingObject(type, jsonElement)) { try { value = JsonSerializer.Deserialize(jsonElement.GetRawText(), type, jsonSerializerOptions); return(true); } catch (JsonException) { // Ignore if there is an error deserializing into this object type } } if (IsMatchingArray(type, jsonElement)) { try { value = JsonSerializer.Deserialize(jsonElement.GetRawText(), type, jsonSerializerOptions); return(true); } catch (JsonException) { // Ignore if there is an error deserializing into this array type } } value = null; return(false); }
/// <inheritdoc/> protected override bool TryConvert(JsonElement source, out object?result) { if (source.ValueKind != JsonValueKind.True && source.ValueKind != JsonValueKind.False) { result = null; return(false); } result = source.GetBoolean(); return(true); }
public static bool?ParseAsBoolean(this JsonElement element, JsonParserContext context) { if (element.ValueKind == JsonValueKind.True || element.ValueKind == JsonValueKind.False) { return(element.GetBoolean()); } context.ReportError(EdmErrorCode.UnexpectedValueKind, Strings.CsdlJsonParser_UnexpectedJsonValueKind(element.ValueKind, context.Path, "Boolean")); return(null); }
public static object ToObject(this JsonElement element, ColumnType columnType) { return(columnType switch { ColumnType.Boolean => element.GetBoolean(), ColumnType.Decimal => element.GetDecimal(), ColumnType.Integer => element.GetInt64(), ColumnType.String => element.GetString(), ColumnType.DateTime => element.GetDateTime(), _ => throw new ArgumentException($"Unsupported columnType conversion [{columnType}]", nameof(columnType)) });
public void TestActorSettings() { var actorType = typeof(TestActor); var actorRuntime = new ActorRuntime(); Assert.Empty(actorRuntime.RegisteredActorTypes); actorRuntime.ConfigureActorSettings(a => { a.ActorIdleTimeout = TimeSpan.FromSeconds(33); a.ActorScanInterval = TimeSpan.FromSeconds(44); a.DrainOngoingCallTimeout = TimeSpan.FromSeconds(55); a.DrainRebalancedActors = true; }); actorRuntime.RegisterActor <TestActor>(); Assert.Contains(actorType.Name, actorRuntime.RegisteredActorTypes, StringComparer.InvariantCulture); ArrayBufferWriter <byte> writer = new ArrayBufferWriter <byte>(); actorRuntime.SerializeSettingsAndRegisteredTypes(writer).GetAwaiter().GetResult(); // read back the serialized json var array = writer.WrittenSpan.ToArray(); string s = Encoding.UTF8.GetString(array, 0, array.Length); JsonDocument document = JsonDocument.Parse(s); JsonElement root = document.RootElement; // parse out the entities array JsonElement element = root.GetProperty("entities"); Assert.Equal(1, element.GetArrayLength()); JsonElement arrayElement = element[0]; string actor = arrayElement.GetString(); Assert.Equal("TestActor", actor); // validate the other properties have expected values element = root.GetProperty("actorIdleTimeout"); Assert.Equal(TimeSpan.FromSeconds(33), ConverterUtils.ConvertTimeSpanFromDaprFormat(element.GetString())); element = root.GetProperty("actorScanInterval"); Assert.Equal(TimeSpan.FromSeconds(44), ConverterUtils.ConvertTimeSpanFromDaprFormat(element.GetString())); element = root.GetProperty("drainOngoingCallTimeout"); Assert.Equal(TimeSpan.FromSeconds(55), ConverterUtils.ConvertTimeSpanFromDaprFormat(element.GetString())); element = root.GetProperty("drainRebalancedActors"); Assert.True(element.GetBoolean()); }
public object UpdateObj(JsonElement o, JsonElement t) { switch (t.ValueKind) { case JsonValueKind.True: case JsonValueKind.False: if (o.ValueKind == JsonValueKind.True || o.ValueKind == JsonValueKind.False) { return(o.GetBoolean()); } return(t.GetBoolean()); case JsonValueKind.Number: if (o.ValueKind == JsonValueKind.Number) { return(o.GetDouble()); } return(t.GetDouble()); case JsonValueKind.String: if (o.ValueKind == JsonValueKind.String) { return(o.GetString()); } return(t.GetString()); case JsonValueKind.Null: return(null); case JsonValueKind.Object: Dictionary <string, object> dic = new Dictionary <string, object>(); if (o.ValueKind == JsonValueKind.Object) { foreach (var item in t.EnumerateObject()) { try { var oprop = o.GetProperty(item.Name); dic.Add(item.Name, UpdateObj(oprop, item.Value)); } catch { dic.Add(item.Name, item.Value); } } } else { foreach (var item in t.EnumerateObject()) { dic.Add(item.Name, UpdateObj(default, item.Value)); } }
private static IOpenApiAny CreateFromJsonElement(JsonElement jsonElement) { if (jsonElement.ValueKind == JsonValueKind.Null) { return(new OpenApiNull()); } if (jsonElement.ValueKind == JsonValueKind.True || jsonElement.ValueKind == JsonValueKind.False) { return(new OpenApiBoolean(jsonElement.GetBoolean())); } if (jsonElement.ValueKind == JsonValueKind.Number) { if (jsonElement.TryGetInt32(out int intValue)) { return(new OpenApiInteger(intValue)); } if (jsonElement.TryGetInt64(out long longValue)) { return(new OpenApiLong(longValue)); } if (jsonElement.TryGetSingle(out float floatValue) && !float.IsInfinity(floatValue)) { return(new OpenApiFloat(floatValue)); } if (jsonElement.TryGetDouble(out double doubleValue)) { return(new OpenApiDouble(doubleValue)); } } if (jsonElement.ValueKind == JsonValueKind.String) { return(new OpenApiString(jsonElement.ToString())); } if (jsonElement.ValueKind == JsonValueKind.Array) { return(CreateOpenApiArray(jsonElement)); } if (jsonElement.ValueKind == JsonValueKind.Object) { return(CreateOpenApiObject(jsonElement)); } throw new System.ArgumentException($"Unsupported value kind {jsonElement.ValueKind}"); }
public static object GetValueFromJsonElement(JsonElement val) { switch (val.ValueKind) { case JsonValueKind.String: return(val.GetString()); case JsonValueKind.True: return(val.GetBoolean()); case JsonValueKind.False: return(val.GetBoolean()); case JsonValueKind.Number: var oki = val.TryGetInt32(out var vali); if (oki) { return(vali); } var okl = val.TryGetInt64(out var vall); if (okl) { return(vall); } var okd = val.TryGetDouble(out var vald); if (okd) { return(vald); } throw new Exception("Unexpected JSON value type"); default: throw new Exception("Unexpected JSON value type"); } }
internal static object CastFromJsValue(object obj) { #if OPENSILVER if (!Interop.IsRunningInTheSimulator_WorkAround) { if (obj != null && (obj is string || obj.GetType().IsPrimitive)) { return(obj); } JsonElement jsonElement = (JsonElement)obj; object res; switch (jsonElement.ValueKind) { case JsonValueKind.Object: case JsonValueKind.Array: res = obj; break; case JsonValueKind.String: res = jsonElement.GetString(); break; case JsonValueKind.Number: res = jsonElement.GetSingle(); break; case JsonValueKind.True: case JsonValueKind.False: res = jsonElement.GetBoolean(); break; case JsonValueKind.Undefined: case JsonValueKind.Null: res = null; break; default: res = null; break; } return(res); } else #endif { return(DotNetForHtml5.Core.INTERNAL_Simulator.ConvertBrowserResult(obj)); } }
/// <summary> /// Read setting value from JSON value according to type name. JSON value will be treated as string or string array if type name cannot be recognized. /// </summary> /// <param name="jsonValue">JSON value.</param> /// <param name="typeName">Type name.</param> /// <returns>Read setting value.</returns> protected object ReadJsonValue(JsonElement jsonValue, string typeName) { return(typeName switch { BooleanType => jsonValue.ValueKind switch { JsonValueKind.Array => new bool[jsonValue.GetArrayLength()].Also((array) => { var index = 0; foreach (var e in jsonValue.EnumerateArray()) { array[index++] = (bool)this.ReadJsonValue(e, typeName); } }), _ => jsonValue.GetBoolean(), },
private object?SerializeJson(string ctx, JsonElement element) { switch (element.ValueKind) { case JsonValueKind.Undefined: case JsonValueKind.Null: return(null); case JsonValueKind.String: return(element.GetString()); case JsonValueKind.Number: return(element.GetDouble()); case JsonValueKind.True: case JsonValueKind.False: return(element.GetBoolean()); case JsonValueKind.Array: { var result = ImmutableArray.CreateBuilder <object?>(); var index = 0; foreach (var child in element.EnumerateArray()) { result.Add(SerializeJson($"{ctx}[{index}]", child)); index++; } return(result.ToImmutable()); } case JsonValueKind.Object: { var result = ImmutableDictionary.CreateBuilder <string, object?>(); foreach (var x in element.EnumerateObject()) { result[x.Name] = SerializeJson($"{ctx}.{x.Name}", x.Value); } return(result.ToImmutable()); } default: throw new InvalidOperationException($"Unknown {nameof(JsonElement)}.{nameof(JsonElement.ValueKind)}: {element.ValueKind}"); } }
public static void ParseUntyped() { object obj = JsonSerializer.Parse <object>(@"""hello"""); Assert.IsType <JsonElement>(obj); JsonElement element = (JsonElement)obj; Assert.Equal(JsonValueType.String, element.Type); Assert.Equal("hello", element.GetString()); obj = JsonSerializer.Parse <object>(@"true"); element = (JsonElement)obj; Assert.Equal(JsonValueType.True, element.Type); Assert.Equal(true, element.GetBoolean()); obj = JsonSerializer.Parse <object>(@"null"); Assert.Null(obj); }