/// <summary> /// (Serialize)JSON 序列化 /// </summary> /// <param name="implType"></param> /// <param name="value"></param> /// <param name="inputType"></param> /// <param name="writeIndented"></param> /// <param name="ignoreNullValues"></param> /// <returns></returns> public static string SJSON(JsonImplType implType, object?value, Type?inputType = null, bool writeIndented = false, bool ignoreNullValues = false) { switch (implType) { case JsonImplType.SystemTextJson: var options = new SJsonSerializerOptions { Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping, WriteIndented = writeIndented, //IgnoreNullValues = ignoreNullValues }; if (ignoreNullValues) { options.DefaultIgnoreCondition = SJsonIgnoreCondition.WhenWritingNull; } return(SJsonSerializer.Serialize(value, inputType ?? value?.GetType() ?? typeof(object), options)); default: #if NOT_NJSON throw new NotSupportedException(); #else var formatting = writeIndented ? Formatting.Indented : Formatting.None; var settings = ignoreNullValues ? new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore } : null; return(SerializeObject(value, inputType, formatting, settings)); #endif } }
public BeaconBlock SignBlock(BeaconBlock block, BlsPublicKey blsPublicKey) { var fork = _beaconChain.Fork; var epoch = ComputeEpochAtSlot(block.Slot); ForkVersion forkVersion; if (epoch < fork.Epoch) { forkVersion = fork.PreviousVersion; } else { forkVersion = fork.CurrentVersion; } var domainType = _signatureDomainOptions.CurrentValue.BeaconProposer; var proposerDomain = ComputeDomain(domainType, forkVersion); JsonSerializerOptions options = new System.Text.Json.JsonSerializerOptions { WriteIndented = true }; options.ConfigureNethermindCore2(); string blockJson = System.Text.Json.JsonSerializer.Serialize(block, options); var signingRoot = _cryptographyService.SigningRoot(block); var signature = _validatorKeyProvider.SignHashWithDomain(blsPublicKey, signingRoot, proposerDomain); block.SetSignature(signature); return(block); }
public async Task GenesisHead() { // Arrange IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true); BeaconState state = TestState.PrepareTestState(testServiceProvider); MiscellaneousParameters miscellaneousParameters = testServiceProvider.GetService <IOptions <MiscellaneousParameters> >().Value; TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value; StateListLengths stateListLengths = testServiceProvider.GetService <IOptions <StateListLengths> >().Value; MaxOperationsPerBlock maxOperationsPerBlock = testServiceProvider.GetService <IOptions <MaxOperationsPerBlock> >().Value; JsonSerializerOptions options = new System.Text.Json.JsonSerializerOptions { WriteIndented = true }; options.ConfigureNethermindCore2(); string debugState = System.Text.Json.JsonSerializer.Serialize(state, options); // Initialization ICryptographyService cryptographyService = testServiceProvider.GetService <ICryptographyService>(); ForkChoice forkChoice = testServiceProvider.GetService <ForkChoice>(); IStore store = forkChoice.GetGenesisStore(state); // Act Hash32 headRoot = await forkChoice.GetHeadAsync(store); // Assert Hash32 stateRoot = cryptographyService.HashTreeRoot(state); BeaconBlock genesisBlock = new BeaconBlock(stateRoot); Hash32 expectedRoot = cryptographyService.SigningRoot(genesisBlock); headRoot.ShouldBe(expectedRoot); }
public async Task GenesisHead() { // Arrange IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider(useStore: true); BeaconState state = TestState.PrepareTestState(testServiceProvider); JsonSerializerOptions options = new System.Text.Json.JsonSerializerOptions { WriteIndented = true }; options.ConfigureNethermindCore2(); string debugState = System.Text.Json.JsonSerializer.Serialize(state, options); // Initialization IBeaconChainUtility beaconChainUtility = testServiceProvider.GetService <IBeaconChainUtility>(); ICryptographyService cryptographyService = testServiceProvider.GetService <ICryptographyService>(); IForkChoice forkChoice = testServiceProvider.GetService <IForkChoice>(); IStore store = testServiceProvider.GetService <IStore>(); await forkChoice.InitializeForkChoiceStoreAsync(store, state); // Act Root headRoot = await forkChoice.GetHeadAsync(store); // Assert Root stateRoot = cryptographyService.HashTreeRoot(state); BeaconBlock genesisBlock = new BeaconBlock(Slot.Zero, Root.Zero, stateRoot, BeaconBlockBody.Zero); Root expectedRoot = cryptographyService.HashTreeRoot(genesisBlock); headRoot.ShouldBe(expectedRoot); }
public async Task InvokeAsync(HttpContext context) { try { await _next(context); } catch (Exception ex) { _logger.LogError(ex, ex.Message); context.Response.ContentType = "application/json"; context.Response.StatusCode = (int)HttpStatusCode.InternalServerError; var response = _env.IsDevelopment() ? new ApiException(context.Response.StatusCode, ex.Message, ex.StackTrace?.ToString()) : new ApiException(context.Response.StatusCode, "Internal Server Error"); var options = new System.Text.Json.JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }; var json = JsonSerializer.Serialize(response, options); await context.Response.WriteAsync(json); } }
public GeneralLedgerModule(EventStoreClient eventStore, IMessageTypeMapper messageTypeMapper, JsonSerializerOptions serializerOptions) { Build <OpenGeneralLedger>() .Log() .UnitOfWork(eventStore, messageTypeMapper, serializerOptions) .Handle((_, ct) => { var(unitOfWork, command) = _; var handlers = new GeneralLedgerHandlers( new GeneralLedgerEventStoreRepository(eventStore, messageTypeMapper, unitOfWork), new GeneralLedgerEntryEventStoreRepository(eventStore, messageTypeMapper, unitOfWork), new ChartOfAccountsEventStoreRepository(eventStore, messageTypeMapper, unitOfWork)); return(handlers.Handle(command, ct)); }); Build <BeginClosingAccountingPeriod>() .Log() .UnitOfWork(eventStore, messageTypeMapper, serializerOptions) .Handle((_, ct) => { var(unitOfWork, command) = _; var handlers = new GeneralLedgerHandlers( new GeneralLedgerEventStoreRepository(eventStore, messageTypeMapper, unitOfWork), new GeneralLedgerEntryEventStoreRepository(eventStore, messageTypeMapper, unitOfWork), new ChartOfAccountsEventStoreRepository(eventStore, messageTypeMapper, unitOfWork)); return(handlers.Handle(command, ct)); }); }
/// <inheritdoc cref="ToJson{TEntity}(TEntity, JsonNet.JsonSerializerSettings)"/> public static string ToJson <TEntity>(this TEntity entity, TextJson.JsonSerializerOptions options) where TEntity : class { _ = entity ?? throw new ArgumentNullException(nameof(entity)); _ = options ?? throw new ArgumentNullException(nameof(options)); return(TextJson.JsonSerializer.Serialize(entity, options)); }
/// <inheritdoc cref="JsonEquals{TEntity}(TEntity, TEntity, JsonNet.JsonSerializerSettings)"/> public static bool JsonEquals <TEntity>(this TEntity left, TEntity right, TextJson.JsonSerializerOptions options) where TEntity : class { _ = options ?? throw new ArgumentNullException(nameof(options)); var equalityComparer = new JsonEqualityComparer <TEntity>(options); return(equalityComparer.Equals(left, right)); }
public static System.Text.Json.JsonSerializerOptions GetSimpleOptions() { var options = new System.Text.Json.JsonSerializerOptions { Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping, }; return(options); }
private JsonSerializerOptions GetJsonSerializerSettings() { var settings = new System.Text.Json.JsonSerializerOptions(); settings.Converters.Add(new PlayerCardJsonConverter()); settings.Converters.Add(new PlayingCardJsonConverter()); settings.PropertyNameCaseInsensitive = true; return(settings); }
/// <inheritdoc cref="JsonClone{TEntity}(TEntity, JsonNet.JsonSerializerSettings)"/> public static TEntity JsonClone <TEntity>(this TEntity item, TextJson.JsonSerializerOptions options) where TEntity : class { _ = item ?? throw new ArgumentNullException(nameof(item)); _ = options ?? throw new ArgumentNullException(nameof(options)); var json = TextJson.JsonSerializer.Serialize(item, options); return(TextJson.JsonSerializer.Deserialize <TEntity>(json, options)); }
public static void SaveSettings() { var options = new JsonSerializerOptions { WriteIndented = true }; var jsonUtf8Bytes = JsonSerializer.SerializeToUtf8Bytes(AppData.settings, options); File.WriteAllBytes(pathToSettings, jsonUtf8Bytes); }
public static System.Text.Json.JsonSerializerOptions GetOptions() { var options = new System.Text.Json.JsonSerializerOptions { Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping, }; options.Converters.Add(new DateTimeConverter()); options.Converters.Add(new UserIdConverter()); return(options); }
private string ToDebuggerDisplay() { if (_Content == null) { return(null); } var options = new JSONOPTIONS(); options.WriteIndented = true; return(ToJson(options)); }
/// <summary> /// 数据对象 To Json CoreWebView2WebResourceResponse /// </summary> /// <param name="data">返回数据对象</param> /// <param name="statusCode">HttpStatusCode</param> /// <param name="jsonSerializerOptions">jsonSerializerOptions</param> /// <returns>CoreWebView2WebResourceResponse</returns> protected CoreWebView2WebResourceResponse Json(object data, HttpStatusCode statusCode = HttpStatusCode.OK, System.Text.Json.JsonSerializerOptions jsonSerializerOptions = null) { var json = System.Text.Json.JsonSerializer.Serialize(data, jsonSerializerOptions); var buffer = Encoding.UTF8.GetBytes(json); var stream = new MemoryStream(buffer); var response = AppRuntime.RunTime.WebView2Environment.CreateWebResourceResponse(stream, (int)statusCode, nameof(statusCode), null); response.Headers.AppendHeader("Content-Type", "application/json"); response.Headers.AppendHeader("access-control-allow-origin", "*"); return(response); }
public BaseServices(System.Net.Http.HttpClient http) : base() { JsonOptions = new System.Text.Json.JsonSerializerOptions { PropertyNameCaseInsensitive = true, }; Http = http; //Client.DefaultRequestHeaders BaseUrl = "https://localhost:44380"; RequestUri = $"{ BaseUrl }/{ GetApiUrl() }"; }
public override ObjectId Read(ref Utf8JsonReader reader, Type typeToConvert, System.Text.Json.JsonSerializerOptions options) { var objectIdString = reader.GetString(); if (ObjectId.TryParse(objectIdString, out var objectId)) { return(objectId); } return(ObjectId.Empty); throw new FormatException($"Read string cannot be converted to type '{typeof(ObjectId)}'."); }
/// <summary> /// 数据对象 To Json CoreWebView2WebResourceResponse /// </summary> /// <param name="data">返回数据对象</param> /// <param name="statusCode">HttpStatusCode</param> /// <param name="jsonSerializerOptions">jsonSerializerOptions</param> /// <returns>CoreWebView2WebResourceResponse</returns> protected WebResponse Json(object data, HttpStatusCode statusCode = HttpStatusCode.OK, System.Text.Json.JsonSerializerOptions jsonSerializerOptions = null) { var json = System.Text.Json.JsonSerializer.Serialize(data, jsonSerializerOptions); var buffer = Encoding.UTF8.GetBytes(json); var stream = new MemoryStream(buffer); var contentType = CONTENT_TYPE_APPLICATION_JSON; var response = new WebResponse { ContentStream = stream, HttpStatus = statusCode, MimeType = contentType }; response.Headers.Add("Content-Type", contentType); response.Headers.Add("access-control-allow-origin", "*"); return(response); }
/// <summary> /// Creates the default json configuration for Caravel applications. /// </summary> /// <returns></returns> public static System.Text.Json.JsonSerializerOptions CamelCase() { { var options = new System.Text.Json.JsonSerializerOptions() { IgnoreNullValues = true, PropertyNamingPolicy = JsonNamingPolicy.CamelCase }; options.Converters.Add(new JsonStringEnumConverter(JsonNamingPolicy.CamelCase)); options.Converters.Add(new JsonDateTimeConverter()); return(options); } }
/// <inheritdoc cref="ToJsonStreamAsync{TEntity}(TEntity, JsonNet.JsonSerializerSettings, CancellationToken)"/> public static async Task <Stream> ToJsonStreamAsync <TEntity>( this TEntity entity, TextJson.JsonSerializerOptions options, CancellationToken cancellationToken = default) where TEntity : class { _ = entity ?? throw new ArgumentNullException(nameof(entity)); _ = options ?? throw new ArgumentNullException(nameof(options)); var stream = new MemoryStream(); await TextJson.JsonSerializer.SerializeAsync(stream, entity, options, cancellationToken); stream.Position = 0; return(stream); }
private string ToDebuggerDisplay() { if (_Content == null) { return(null); } var options = new JSONOPTIONS(); options.WriteIndented = true; #pragma warning disable IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code return(ToJson(options)); #pragma warning restore IL2026 // Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code }
/// <summary> /// Gets the json for a <see cref="UserBar"/>, so it can be loaded with a better deserialiser. /// </summary> /// <param name="userBar">Bar data object from Morphic.Core</param> private string GetUserBarJson(UserBar userBar) { // Serialise the bar data so it can be loaded with a better deserialiser. SystemJson.JsonSerializerOptions serializerOptions = new SystemJson.JsonSerializerOptions(); serializerOptions.Converters.Add(new JsonElementInferredTypeConverter()); serializerOptions.Converters.Add( new SystemJson.Serialization.JsonStringEnumConverter(SystemJson.JsonNamingPolicy.CamelCase)); string barJson = SystemJson.JsonSerializer.Serialize(userBar, serializerOptions); // Dump to a file, for debugging. string barFile = AppPaths.GetConfigFile("last-bar.json5"); File.WriteAllText(barFile, barJson); return(barJson); }
public static Object Deserialize(Object obj, Type type, JSONOPTIONS options = null) { if (options == null) { options = new JSONOPTIONS { PropertyNamingPolicy = JsonNamingPolicy.CamelCase, DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull, WriteIndented = true }; } var json = ToJson(obj, options); return(JsonSerializer.Deserialize(json, type, options)); }
public static Object Deserialize(Object obj, Type type, JSONOPTIONS options = null) { if (options == null) { options = new JSONOPTIONS { PropertyNamingPolicy = JsonNamingPolicy.CamelCase, IgnoreNullValues = true, WriteIndented = true }; } var json = ToJson(obj, options); return(JsonSerializer.Deserialize(json, type, options)); }
public static void SaveEscola() { string escolaFile = DataLocationFolder + "Escolas.json"; System.Text.Json.JsonSerializerOptions options = new System.Text.Json.JsonSerializerOptions() { WriteIndented = true }; string json = System.Text.Json.JsonSerializer.Serialize(Escolas.ToArray(), options); string serverPath = @"srvmm"; using (Network.NetworkShareAccesser.Access(serverPath, "meiomundo", "meiomundo")) { System.IO.File.WriteAllText(escolaFile, json); } }
public IActionResult getNoteContent(string noteId) { string a = System.IO.File.ReadAllText("TextFile.txt"); var options = new System.Text.Json.JsonSerializerOptions { Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping }; //NoteContent noteContent1 = JsonSerializer.Deserialize<NoteContent>(a, options); //NoteService.InsertNoteContent(noteContent1); NoteContent noteContent = NoteContentService.SelectNoteContent(123123); string json = JsonSerializer.Serialize(noteContent, options); // return Content(a); return(Content(json)); }
public static IJournalEvent ParseJournalEvent(string logLine) { var journalEvent = System.Text.Json.JsonSerializer.Deserialize <JournalEvent>(logLine); var allTypes = Assembly.GetExecutingAssembly().GetTypes(); allTypes = typeof(JournalEvent).Assembly.GetTypes(); List <System.Type> eventTypes = new List <System.Type>(); foreach (var t in allTypes) { string eventName = $"{journalEvent.Event}Event"; if (t.Name == eventName) { var methods = typeof(System.Text.Json.JsonSerializer).GetMethods(); foreach (var method in methods) { if (method.IsGenericMethod && method.Name == "Deserialize") { var parameters = method.GetParameters(); if (parameters.Length == 2) { var param1 = parameters[0]; var param2 = parameters[1]; var param1Match = typeof(System.String); var param1Name = param1.Name; var param1Type = param1.ParameterType; if (param1Type == typeof(System.String) && param1Name == "json") { MethodInfo generic = method.MakeGenericMethod(t); var options = new System.Text.Json.JsonSerializerOptions(); return((IJournalEvent)generic.Invoke(null, new object [] { logLine, null })); } } } } } } return(new DeserializeExceptionEvent { Message = $"No type definition found for {journalEvent.Event}" }); }
public void TestConnectionStatesConverter_SystemText_InvalidReturnEmpty() { var jsonOption = new SystemJson.JsonSerializerOptions(); jsonOption.Converters.Add(new ConnectionStatesConverter()); var input = new Dictionary <string, string> { { "aKey", "aValue" }, { "bKey", "123" }, { "cKey", DateTime.Now.ToString() } }; var serialized = SystemJson.JsonSerializer.Serialize(input); var deserialized = SystemJson.JsonSerializer.Deserialize <IReadOnlyDictionary <string, BinaryData> >(serialized, jsonOption); Assert.NotNull(deserialized); Assert.AreEqual(0, deserialized.Count); }
public async Task <IActionResult> RegisterCredentials(string token, string keyName, string data) { try { var tokenVerify = tokenSerivce.VerifyToken(token); if (!tokenVerify) { var apiRe = new ApiRe() { Ok = false, Msg = "注册失败,token无效" }; return(Json(apiRe, MyJsonConvert.GetSimpleOptions())); } JsonSerializerOptions options = new System.Text.Json.JsonSerializerOptions { Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping, Converters = { new JsonStringEnumMemberConverter(), new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) }, DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull }; options.PropertyNamingPolicy = JsonNamingPolicy.CamelCase; options.Converters.Add(new Base64UrlConverter()); var attestationResponse = JsonSerializer.Deserialize <AuthenticatorAttestationRawResponse>(data, options); var user = userService.GetUserByToken(token); if (string.IsNullOrEmpty(keyName) || !MyStringUtil.IsNumAndEnCh(keyName)) { keyName = "key"; } var success = await fido2Service.RegisterCredentials(user, keyName, attestationResponse); // 4. return "ok" to the client return(Json(success)); } catch (Exception e) { return(Json(new CredentialMakeResult(status: "error", errorMessage: FormatException(e), result: null))); } }
public static string ToJson(Object obj, JSONOPTIONS options) { if (obj == null) { return(String.Empty); } if (options == null) { options = new JSONOPTIONS { PropertyNamingPolicy = JsonNamingPolicy.CamelCase, IgnoreNullValues = true, WriteIndented = true }; } return(JsonSerializer.Serialize(obj, obj.GetType(), options)); }