private void SaveJson(JsonConfigurationProvider provider, JObject json) { lock (_locker) { if (provider.Source.FileProvider is PhysicalFileProvider physicalFileProvider) { var jsonFilePath = Path.Combine(physicalFileProvider.Root, provider.Source.Path); try { using (var sw = new StreamWriter(jsonFilePath, false)) using (var jsonTextWriter = new JsonTextWriter(sw) { Formatting = Formatting.Indented, }) { json?.WriteTo(jsonTextWriter); } } catch (IOException exception) { _logger.LogWarning(exception, "JSON configuration could not be written: {path}", jsonFilePath); } } } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { Department department = (Department)value; JObject o = new JObject(); o["DepartmentId"] = new JValue(department.DepartmentId.ToString()); o["Name"] = new JValue(new string(department.Name.Reverse().ToArray())); o.WriteTo(writer); }
public void WriteRuntimeFile(string filePath, RuntimeFile runtimeFile) { using (var fileStream = new FileStream(filePath, FileMode.Create)) { using (var textWriter = new StreamWriter(fileStream)) { using (var jsonWriter = new JsonTextWriter(textWriter)) { jsonWriter.Formatting = Formatting.Indented; var json = new JObject(); WriteRuntimeFile(json, runtimeFile); json.WriteTo(jsonWriter); } } } }
protected void editButton_Click(object sender, EventArgs e) { string dirstr = HttpContext.Current.Server.MapPath("~/Json/"); string jsonDirstr = string.Format("history.json"); string fullDirstr = Path.Combine(dirstr, jsonDirstr); string value1 = history.Text; //string value2 = HttpUtility.HtmlDecode(value1); JObject j = new JObject(new JProperty("1", value1)); File.WriteAllText(fullDirstr, j.ToString()); using (StreamWriter file = File.CreateText(fullDirstr)) using (JsonTextWriter writer = new JsonTextWriter(file)) { j.WriteTo(writer); } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { Node node = (Node)value; JObject jo = new JObject(); jo.Add("name", node.Name); if (node.Children.Count == 0) { jo.Add("leaf", true); } else { jo.Add("children", JArray.FromObject(node.Children, serializer)); } jo.WriteTo(writer); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var obj = new JObject(); var enumerable = (IEnumerable)value; foreach (object kvp in enumerable) { // TODO: caching var keyProp = kvp.GetType().GetProperty("Key"); var keyValue = keyProp.GetValue(kvp, null); obj.Add(keyValue.ToString(), JArray.FromObject((IEnumerable)kvp)); } obj.WriteTo(writer); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { JToken t = JToken.FromObject(value); if (t.Type != JTokenType.Object) { t.WriteTo(writer); } else { JObject o = (JObject)t; DelimitedLogRecordBase record = value as DelimitedLogRecordBase; o.AddFirst(new JProperty("Timestamp", record.TimeStamp)); o.WriteTo(writer); } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var parameter = value as ArmParameter; if (parameter == null) { return; } JObject jo = new JObject(); var propertiesToken = JToken.FromObject(parameter.Properties); jo.Add(parameter.Name, propertiesToken); jo.WriteTo(writer); }
private void Save(JObject json) { if (!FileSystemHelpers.FileExists(_path)) { FileSystemHelpers.EnsureDirectory(Path.GetDirectoryName(_path)); } // opens file for FileAccess.Write but does allow other dirty read (FileShare.Read). // it is the most optimal where write is infrequent and dirty read is acceptable. using (var writer = new JsonTextWriter(new StreamWriter(FileSystemHelpers.OpenFile(_path, FileMode.Create, FileAccess.Write, FileShare.Read)))) { // prefer indented-readable format writer.Formatting = Formatting.Indented; json.WriteTo(writer); } }
public void SaveTraceResult(TextWriter textWriter, TracerResult traceResult) { var jtokens = from threadTracerResult in traceResult.dThreadTracerResults.Values select SaveThreads(threadTracerResult); JObject traceResultJSON = new JObject { { "Thread", new JArray(jtokens) } }; using (var jsonWriter = new JsonTextWriter(textWriter)) { jsonWriter.Formatting = Formatting.Indented; traceResultJSON.WriteTo(jsonWriter); } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var img = (ImageField)value; JObject jo = new JObject(); jo.Add(new JProperty("HasValue", img.HasValue)); if (img.HasValue) { var url = ((string)img).Substring(1); jo.Add(new JProperty("Url", url)); } jo.WriteTo(writer); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var room = (Room2D)value; var o = new JObject { new JProperty(nameof(room.Identifier), new JValue(room.Identifier)), new JProperty(nameof(room.IsTopExposed), new JValue(room.IsTopExposed)), new JProperty(nameof(room.IsGroundContact), new JValue(room.IsGroundContact)), new JProperty(nameof(room.FloorToCeilingHeight), new JValue(room.FloorToCeilingHeight)), new JProperty(nameof(room.Properties.Energy.ConstructionSet), new JValue(room.Properties.Energy.ConstructionSet.Identifier)), new JProperty(nameof(room.Properties.Energy.ProgramType), new JValue(room.Properties.Energy.ProgramType.Identifier)), }; o.WriteTo(writer); }
private void WriteRuntimeConfig(LibraryExporter exporter) { if (!_context.TargetFramework.IsDesktop()) { // TODO: Suppress this file if there's nothing to write? RuntimeOutputFiles would have to be updated // in order to prevent breaking incremental compilation... var json = new JObject(); var runtimeOptions = new JObject(); json.Add("runtimeOptions", runtimeOptions); var redistPackage = _context.RootProject.Dependencies .Where(r => r.Type.Equals(LibraryDependencyType.Platform)) .ToList(); if (redistPackage.Count > 0) { if (redistPackage.Count > 1) { throw new InvalidOperationException("Multiple packages with type: \"platform\" were specified!"); } var packageName = redistPackage.Single().Name; var redistExport = exporter.GetAllExports() .FirstOrDefault(e => e.Library.Identity.Name.Equals(packageName)); if (redistExport == null) { throw new InvalidOperationException($"Platform package '{packageName}' was not present in the graph."); } else { var framework = new JObject( new JProperty("name", redistExport.Library.Identity.Name), new JProperty("version", redistExport.Library.Identity.Version.ToNormalizedString())); runtimeOptions.Add("framework", framework); } } var runtimeConfigJsonFile = Path.Combine(_runtimeOutputPath, _compilerOptions.OutputName + FileNameSuffixes.RuntimeConfigJson); using (var writer = new JsonTextWriter(new StreamWriter(File.Create(runtimeConfigJsonFile)))) { writer.Formatting = Formatting.Indented; json.WriteTo(writer); } } }
private IFileSystem GetMockFileSystem(string path, params KeyValuePair <string, string>[] values) { MemoryStream mem = null; var fileSystem = new Mock <IFileSystem>(); var file = new Mock <FileBase>(); var directory = new Mock <DirectoryBase>(); // Arrange file.Setup(f => f.Open(path, FileMode.Create, FileAccess.Write, FileShare.Read)).Returns(() => { mem = new MemoryStream(); return(mem); }); file.Setup(f => f.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)).Returns(() => { if (mem == null) { throw new FileNotFoundException(path + " does not exist."); } byte[] bytes = mem.GetBuffer(); mem = new MemoryStream(bytes, 0, bytes.Length, writable: false, publiclyVisible: true); return(mem); }); if (values.Length > 0) { JObject json = new JObject(); foreach (KeyValuePair <string, string> pair in values) { json[pair.Key] = pair.Value; } mem = new MemoryStream(); using (var writer = new JsonTextWriter(new StreamWriter(mem))) { json.WriteTo(writer); } } file.Setup(f => f.Exists(path)).Returns(() => mem != null); fileSystem.Setup(fs => fs.File).Returns(file.Object); fileSystem.Setup(fs => fs.Directory).Returns(directory.Object); return(fileSystem.Object); }
/// <inheritdoc /> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (writer == null) { throw new ArgumentNullException(nameof(writer)); } DirectedGraph <TVertex, TEdge> graph = (DirectedGraph <TVertex, TEdge>)value; int count = 0; Dictionary <TVertex, int> vertices = graph.Vertices.ToDictionary(v => v, v => count++); writer.WriteStartObject(); // write edges writer.WritePropertyName("Edges"); writer.WriteStartArray(); foreach (TEdge edge in graph.Edges) { JObject jo = JObject.FromObject(edge, serializer); jo.AddFirst(new JProperty( "$type", DirectedGraphJsonConverter <TGraph, TVertex, TEdge> .RemoveAssemblyDetails(edge.GetType().AssemblyQualifiedName))); jo.AddFirst(new JProperty( "$path", string.Join(DirectedGraphJsonConverter <TGraph, TVertex, TEdge> .EdgeSeparator, vertices[edge.Source], vertices[edge.Target]))); jo.WriteTo(writer); } writer.WriteEnd(); // write vertices writer.WritePropertyName("Vertices"); writer.WriteStartArray(); foreach (TVertex vertex in vertices.Keys) { JObject jo = JObject.FromObject(vertex, serializer); jo.AddFirst(new JProperty( "$type", DirectedGraphJsonConverter <TGraph, TVertex, TEdge> .RemoveAssemblyDetails(vertex.GetType().AssemblyQualifiedName))); jo.WriteTo(writer); } writer.WriteEnd(); writer.WriteEndObject(); }
public void Parse(JObject data) { JToken tableNameJToken; if (!data.TryGetValue("table", out tableNameJToken)) { _logger.Warning($"Table attribute is not present in data"); return; } var tableName = tableNameJToken.Value <string>(); _store.LastUpdateTime = DateTime.Now; if (tableName == SymbolTables.OrderBookL2) { new OrderBookL2Parser(_orderBookUpdator, _logger).Parse(data); } else if (tableName == SystemTables.Order) { new OrdersTableParser(_ordersTableUpdator, _logger).Parse(data); } else if (tableName == SystemTables.Execution) { new ExecutionTableParser(_executionTableUpdator, _logger).Parse(data); } else { _logger.Error($"Not supported table {tableName}"); } if (_logInFile) { var path = $"C:\\BitMex\\logs\\{tableName}"; if (Directory.Exists(path) == false) { Directory.CreateDirectory(path); } using (var sw = File.CreateText($"{path}\\{Guid.NewGuid()}.json")) { using (var writer = new JsonTextWriter(sw)) data.WriteTo(writer); } } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var location = value as Point; if (location == null) { throw new ArgumentException($"Excepted: MapElement, got: {value.GetType()}"); } JObject o = JObject.FromObject( new LatLng { Lat = location.Coordinates[0].X, Lng = location.Coordinates[0].Y }); o.WriteTo(writer); }
public override async Task <ActionResponse> ExecuteActionAsync(ActionRequest request) { string rowBatchSize = request.DataStore.GetValue("RowBatchSize"); string sapClient = request.DataStore.GetValue("SapClient"); string sapHost = request.DataStore.GetValue("SapHost"); string sapLanguage = request.DataStore.GetValue("SapLanguage"); string sapRouterString = request.DataStore.GetValue("SapRouterString"); string sapSystemId = request.DataStore.GetValue("SapSystemId"); string sapSystemNumber = request.DataStore.GetValue("SapSystemNumber"); var sqlConnectionStrings = request.DataStore.GetAllValues("SqlConnectionString"); string sqlConnectionString = sqlConnectionStrings != null ? sqlConnectionStrings[0] : string.Empty; if (!string.IsNullOrEmpty(sqlConnectionString)) { SqlCredentials sqlCredentials = SqlUtility.GetSqlCredentialsFromConnectionString(sqlConnectionString); sqlCredentials.Username = string.Empty; sqlCredentials.Password = string.Empty; sqlConnectionString = SqlUtility.GetConnectionString(sqlCredentials); } string jsonDestination = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), JSON_PATH); (new FileInfo(jsonDestination)).Directory.Create(); JObject config = new JObject( new JProperty("RowBatchSize", rowBatchSize), new JProperty("SapClient", sapClient), new JProperty("SapHost", sapHost), new JProperty("SapLanguage", sapLanguage), new JProperty("SapRouterString", sapRouterString), new JProperty("SapSystemId", sapSystemId), new JProperty("SapSystemNumber", sapSystemNumber), new JProperty("SqlConnectionString", sqlConnectionString) ); using (StreamWriter file = File.CreateText(jsonDestination)) { using (JsonTextWriter writer = new JsonTextWriter(file)) { config.WriteTo(writer); } } return(new ActionResponse(ActionStatus.Success, JsonUtility.GetEmptyJObject())); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var suggester = Factory.GetConfigNode("suggesters"); if (suggester?.Attributes == null) { return; } _suggesterName = suggester.Attributes["name"].Value; if (!_suggesterName.Any()) { return; } _suggesterSearchMode = suggester.Attributes["searchMode"].Value; _sugesterFields = (Factory.GetConfigNodes("suggesters/sourceFields/suggesterField") .Cast <XmlNode>() .Select(node => XmlUtil.GetAttribute("suggesterFieldName", node))).ToList(); if (!_sugesterFields.Any()) { return; } var suggesters = new List <Suggester> { new Suggester(_suggesterName, _suggesterSearchMode, _sugesterFields) }; IEnumerable <JToken> suggjtokens = suggesters.Select(f => JToken.FromObject((object)f, serializer)); IndexDefinition indexDefinition = value as IndexDefinition; if (indexDefinition == null) { return; } JObject jobject = JObject.FromObject((object)indexDefinition.AnalyzerDefinitions, serializer) ?? new JObject(); IEnumerable <JToken> jtokens = indexDefinition.Fields.Select <IndexedField, JToken>((Func <IndexedField, JToken>)(f => JToken.FromObject((object)f, serializer))); jobject.AddFirst((object)new JProperty("fields", (object)new JArray((object)jtokens))); jobject.AddFirst((object)new JProperty("suggesters", (object)new JArray((object)suggjtokens))); jobject.WriteTo(writer, Array.Empty <JsonConverter>()); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { JToken jToken = JToken.FromObject(value); if (jToken.Type != JTokenType.Object) { jToken.WriteTo(writer); return; } JObject jObject = (JObject)jToken; IList <string> content = (from p in jObject.Properties() where p.Name == "w" || p.Name == "x" || p.Name == "y" || p.Name == "z" select p.Name).ToList(); jObject.AddFirst(new JProperty("Keys", new JArray(content))); jObject.WriteTo(writer); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { Composite composite = (Composite)value; // Need to use reflection here because Elements is private PropertyInfo prop = typeof(Composite).GetProperty("Elements", BindingFlags.NonPublic | BindingFlags.Instance); List <Element> children = (List <Element>)prop.GetValue(composite); JArray array = new JArray(); foreach (Element e in children) { array.Add(JToken.FromObject(e, serializer)); } JObject obj = new JObject(); obj.Add(composite.Name, array); obj.WriteTo(writer); }
public override void WriteJson(JsonWriter writer, TPlugin value, JsonSerializer serializer) { var pluginType = value.GetType(); var config = pluginType.GetProperty("Config")?.GetValue(value, null); var o = new JObject { { "Type", JToken.FromObject(pluginType.Name) } }; if (config != null) { o.Add("Config", JToken.FromObject(config)); } o.WriteTo(writer); }
private static void CreateJsonFile(ObjFields objFileds) { JObject jsonFile = JObject.Parse(File.ReadAllText(objFileds.path)); JObject appConfiguration = (JObject)jsonFile["AppConfiguration"]; appConfiguration["DevelopmentConnection"] = objFileds.StringConn; FileStream fsOverwrite = new FileStream(objFileds.path, FileMode.Create); StreamWriter swOverwrite = new StreamWriter(fsOverwrite); using (JsonTextWriter writer = new JsonTextWriter(swOverwrite)) { writer.Formatting = Newtonsoft.Json.Formatting.Indented; jsonFile.WriteTo(writer); } }
public GlobalSettings GetGlobalSettings(JObject json) { using (var stream = new MemoryStream()) { using (var sw = new StreamWriter(stream, Encoding.UTF8, 256, true)) { using (var writer = new JsonTextWriter(sw)) { writer.Formatting = Formatting.Indented; json.WriteTo(writer); } stream.Position = 0; return(GlobalSettings.GetGlobalSettings(stream, SomePath)); } } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var notifyEntry = value as NotifyEntry; if (notifyEntry == null) { return; } var o = new JObject(); // Write all well-known properties o.Add(new JProperty(nameof(NotifyEntry.Type), notifyEntry.Type.ToString())); o.Add(new JProperty(nameof(NotifyEntry.Message), notifyEntry.Message.ToString())); o.WriteTo(writer); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { ImportMultiAddress.ScriptPubKeyObject req = (ImportMultiAddress.ScriptPubKeyObject)value; JToken t = JToken.FromObject(value); if (req.IsAddress) { // Serialize as a complex object (i.e., { "address": "XYZasASDFASDasdfasdfasdfsd" } ) JObject jo = (JObject)t; jo.WriteTo(writer); } else { // Serialize as a simple string value (i.e., "035cd888286d39e64c7c52a49561b323c732fc5cfa48d73faedcf5c40d99747474" writer.WriteValue(req.ScriptPubKey.ToHex()); } }
public static void EnsureConfig(string path) { if (!File.Exists(path)) { Console.WriteLine("No config.json"); JObject robberyConfig = new JObject(); robberyConfig.Add("interval", 600); using (StreamWriter file = File.CreateText(path)) using (JsonTextWriter writer = new JsonTextWriter(file)) { robberyConfig.WriteTo(writer); Console.WriteLine("Generated Robbery config"); } } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { JObject jo = new JObject(); foreach (PropertyInfo prop in value.GetType().GetProperties()) { if (prop.CanRead) { object propValue = prop.GetValue(value, null); if (propValue != null) { jo.Add(prop.Name.ToUnderscoreLower(), JToken.FromObject(propValue, serializer)); } } } jo.WriteTo(writer); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (value != null) { Vector3 vector = (Vector3)value; JObject obj = new JObject( new JProperty("x", vector.x), new JProperty("y", vector.y), new JProperty("z", vector.z) ); obj.WriteTo(writer); } else { JValue.CreateNull().WriteTo(writer); } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { var type = value.GetType().GetCustomAttribute <TypeNameAttribute>().Type; var jObject = new JObject(); jObject.Add("type", new JValue(type)); foreach (var prop in value.GetType().GetProperties()) { var propValue = prop.GetValue(value); var name = prop.GetCustomAttribute <JsonPropertyAttribute>()?.PropertyName ?? prop.Name; if (propValue != null) { jObject.Add(camelCaseContractResolver.GetResolvedPropertyName(name), JToken.FromObject(propValue, serializer)); } } jObject.WriteTo(writer); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { JToken jt = JToken.FromObject(value); if (jt.Type != JTokenType.Object) { jt.WriteTo(writer); } else { JObject o = (JObject)jt; o.AddFirst(new JProperty("ObjectType", value.GetType().Name)); o.WriteTo(writer); } }
public void Example() { #region Usage JObject videogameRatings = new JObject( new JProperty("Halo", 9), new JProperty("Starcraft", 9), new JProperty("Call of Duty", 7.5)); File.WriteAllText(@"c:\videogames.json", videogameRatings.ToString()); // write JSON directly to a file using (StreamWriter file = File.CreateText(@"c:\videogames.json")) using (JsonTextWriter writer = new JsonTextWriter(file)) { videogameRatings.WriteTo(writer); } #endregion }
public void Example() { #region Usage JObject o = new JObject { { "name1", "value1" }, { "name2", "value2" } }; MemoryStream ms = new MemoryStream(); using (BsonWriter writer = new BsonWriter(ms)) { o.WriteTo(writer); } string data = Convert.ToBase64String(ms.ToArray()); Console.WriteLine(data); // KQAAAAJuYW1lMQAHAAAAdmFsdWUxAAJuYW1lMgAHAAAAdmFsdWUyAAA= #endregion }
public void Utf8Text() { string badText =System.IO.File.ReadAllText(@"PoisonText.txt"); var j = new JObject(); j["test"] = badText; var memoryStream = new MemoryStream(); var bsonWriter = new BsonWriter(memoryStream); j.WriteTo(bsonWriter); bsonWriter.Flush(); memoryStream.Position = 0; JObject o = JObject.Load(new BsonReader(memoryStream)); Assert.AreEqual(badText, (string)o["test"]); }