예제 #1
0
        public void ProcessCSharpClass()
        {
            // type: String size 1 => public string {key} { get; set;}
            // Define {key} NVARCHAR({size/default};

            //            JsonDocument.AddJsonOptions(option =>
            //option.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase);

            var options = new JsonDocumentOptions
            {
                // P = JsonNamingPolicy.CamelCase,
            };

            var doc = JsonDocument.Parse(@"{ ""Text"": ""1"", ""DetailChanges"":[{""Property"":""Comments"",""ChangedTo"":""2nd Comment"",""UniqueId"":null,""SummaryInstance"":null},{""Property"":""CCC"",""ChangedTo"":""XR71"",""UniqueId"":null,""SummaryInstance"":null}], ""Value"": 1, ""IsValid"": true, ""Account"" : { ""AccountId"" : 1234  }  }"
                                         , options);

            Assert.IsNotNull(doc);

            var settings = new OperationSettings()
            {
                Name = "TestName"
            };

            var instance = doc.RootElement.WalkStructure <CSharpClass, CSharpProperty>
                               (new CSharpClass(settings, null), null);

            Assert.IsNotNull(instance);

            SettingsSingleton.Settings = new TempSettings()
            {
                Name = "ProcessCharpClass"
            };

            Console.WriteLine(instance.ToString());
        }
예제 #2
0
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            string str = File.ReadAllText(@"D:\Temp\CMCconverterTestJSON.txt");
            //Console.WriteLine(str);

            JsonDocumentOptions options = new JsonDocumentOptions {
                AllowTrailingCommas = true
            };
            string price = "";

            using (JsonDocument document = JsonDocument.Parse(str, options)) {
                price = document.RootElement
                        .GetProperty("data")
                        .GetProperty("quote")
                        .GetProperty("USD")
                        .GetProperty("price")
                        .ToString();
            }
            double x = double.Parse(price);

            Console.WriteLine(x);

            Console.ReadKey();
        }
예제 #3
0
        /// <summary>
        /// Return a list of profiles for the Windows Terminal
        /// </summary>
        /// <param name="terminal">Windows Terminal package</param>
        /// <param name="settingsJson">Content of the settings JSON file of the Terminal</param>
        public static List <TerminalProfile> ParseSettings(TerminalPackage terminal, string settingsJson)
        {
            var profiles = new List <TerminalProfile>();

            var options = new JsonDocumentOptions
            {
                CommentHandling = JsonCommentHandling.Skip,
            };

            var json = JsonDocument.Parse(settingsJson, options);

            json.RootElement.TryGetProperty("profiles", out JsonElement profilesElement);
            if (profilesElement.ValueKind != JsonValueKind.Object)
            {
                return(profiles);
            }

            profilesElement.TryGetProperty("list", out JsonElement profilesList);
            if (profilesList.ValueKind != JsonValueKind.Array)
            {
                return(profiles);
            }

            foreach (var profile in profilesList.EnumerateArray())
            {
                profiles.Add(ParseProfile(terminal, profile));
            }

            return(profiles);
        }
예제 #4
0
        public AbpCliConfig Read(string directory)
        {
            var settingsFilePath = Path.Combine(directory, appSettingFileName);

            if (!File.Exists(settingsFilePath))
            {
                throw new FileNotFoundException($"appsettings file could not be found. Path:{settingsFilePath}");
            }

            var settingsFileContent = File.ReadAllText(settingsFilePath);

            var documentOptions = new JsonDocumentOptions
            {
                CommentHandling = JsonCommentHandling.Skip
            };

            using (var document = JsonDocument.Parse(settingsFileContent, documentOptions))
            {
                var element    = document.RootElement.GetProperty("AbpCli");
                var configText = element.GetRawText();
                var options    = new JsonSerializerOptions
                {
                    Converters =
                    {
                        new JsonStringEnumConverter()
                    },
                    ReadCommentHandling = JsonCommentHandling.Skip
                };

                return(JsonSerializer.Deserialize <AbpCliConfig>(configText, options));
            }
        }
예제 #5
0
        private IDictionary <string, string> ParseStream(Stream input, string password)
        {
            _data.Clear();

            var jsonReaderOptions = new JsonDocumentOptions
            {
                CommentHandling     = JsonCommentHandling.Skip,
                AllowTrailingCommas = true,
            };

            byte[] buffer = new byte[input.Length];
            input.Read(buffer, 0, buffer.Length);
            var passwordBytes = Encoding.ASCII.GetBytes(password);

            passwordBytes = SHA256.Create().ComputeHash(passwordBytes);
            var bytesDecrypted = AES.GetDecryptedByteArray(buffer, passwordBytes);
            var content        = Encoding.GetEncoding("gb2312").GetString(bytesDecrypted);

            content = content.Replace("\0", "");
            using (var doc = JsonDocument.Parse(content, jsonReaderOptions))
            {
                if (doc.RootElement.ValueKind != JsonValueKind.Object)
                {
                    throw new FormatException($"Unsupported JSON token '{doc.RootElement.ValueKind}' was found.");
                }
                VisitElement(doc.RootElement);
            }
            return(_data);
        }
예제 #6
0
        public List <Item> AllItem()
        {
            List <Item> result = new List <Item>();

            string itemsJson = JsonBody("http://localhost:8000/search");

            //json parse
            var options = new JsonDocumentOptions
            {
                AllowTrailingCommas = true
            };

            if (itemsJson != null)
            {
                using (JsonDocument document = JsonDocument.Parse(itemsJson, options))
                {
                    foreach (JsonElement element in document.RootElement.GetProperty("items").EnumerateArray())
                    {
                        int    id       = element.GetProperty("id").GetInt32();
                        string name     = element.GetProperty("name").GetString();
                        int    price    = element.GetProperty("price").GetInt32();
                        int    current  = element.GetProperty("current").GetInt32();
                        string category = element.GetProperty("category").GetString();
                        string image    = element.GetProperty("image").GetString();

                        result.Add(new Item(id, name, price, current, category, image));
                    }
                }
            }

            return(result);
        }
예제 #7
0
        public List <String> GetCategories()
        {
            List <string> result = new List <string>();

            string itemsJson = JsonBody("http://localhost:8000/categories");
            //json parse
            var options = new JsonDocumentOptions
            {
                AllowTrailingCommas = true
            };

            if (itemsJson != null)
            {
                using (JsonDocument document = JsonDocument.Parse(itemsJson, options))
                {
                    foreach (JsonElement element in document.RootElement.GetProperty("categories").EnumerateArray())
                    {
                        int    id   = element.GetProperty("id").GetInt32();
                        string name = element.GetProperty("name").GetString();

                        result.Add(name);
                    }
                }
            }


            return(result);
        }
예제 #8
0
        public static Tuple <double, DateTime> GetSingleExchangeRate(string firstCurrency, string secondCurrency, double amount = 1)
        {
            string fullJson = ApiConverterTool(firstCurrency, secondCurrency);

            if (string.IsNullOrEmpty(fullJson))
            {
                throw new ArgumentNullException();
            }
            JsonDocumentOptions options = new JsonDocumentOptions {
                AllowTrailingCommas = true
            };

            string extractedPrice = "";
            string extractedDate  = "";

            using (JsonDocument document = JsonDocument.Parse(fullJson, options)) {
                extractedPrice = document.RootElement
                                 .GetProperty("data")
                                 .GetProperty("quote")
                                 .GetProperty(secondCurrency)
                                 .GetProperty("price")
                                 .ToString();

                extractedDate = document.RootElement
                                .GetProperty("data")
                                .GetProperty("quote")
                                .GetProperty(secondCurrency)
                                .GetProperty("last_updated")
                                .ToString();
            }

            Tuple <double, DateTime> result = new Tuple <double, DateTime>(double.Parse(extractedPrice), DateTime.Parse(extractedDate));

            return(result);
        }
예제 #9
0
        public dynamic Parse(string jsonStr = null)
        {
            JsonDocumentOptions jdo = new JsonDocumentOptions();

            jdo.AllowTrailingCommas = true;
            jdo.CommentHandling     = JsonCommentHandling.Skip;

            DynamicObjectExt result = new DynamicObjectExt();

            foreach (string file in mJsonFiles)
            {
                using (StreamReader sr = new StreamReader(file, Encoding.UTF8))
                {
                    string       content = sr.ReadToEnd();
                    JsonDocument doc     = JsonDocument.Parse(content, jdo);
                    JsonElement  rootEl  = doc.RootElement;
                    BindConfigObject(result, rootEl);
                }
            }
            if (!string.IsNullOrEmpty(jsonStr))
            {
                JsonDocument doc    = JsonDocument.Parse(jsonStr, jdo);
                JsonElement  rootEl = doc.RootElement;
                BindConfigObject(result, rootEl);
            }
            return(result);
        }
예제 #10
0
        /// <inheritdoc/>
        public JsonDocument GetPayloadAsJson(JsonDocumentOptions documentOptions = default)
        {
            if (PostData == null)
            {
                return(null);
            }

            string content = PostData;

            if ("application/x-www-form-urlencoded".Equals(this.GetHeaderValue("content-type"), StringComparison.OrdinalIgnoreCase))
            {
                var parsed     = HttpUtility.ParseQueryString(PostData);
                var dictionary = new Dictionary <string, string>();

                foreach (string key in parsed.Keys)
                {
                    dictionary[key] = parsed[key];
                }

                content = JsonSerializer.Serialize(dictionary);
            }

            if (content == null)
            {
                return(null);
            }

            return(JsonDocument.Parse(content, documentOptions));
        }
예제 #11
0
        public JsonSchemaSource Load(FileInfo path, string jsonPath)
        {
            var options = new JsonDocumentOptions
            {
            };

            if (!m_cache.TryGetValue(path, out byte[] bytes))
예제 #12
0
    private static double ComputeAverageTemperatures(string json)
    {
        JsonDocumentOptions options = new JsonDocumentOptions
        {
            AllowTrailingCommas = true
        };

        using (JsonDocument document = JsonDocument.Parse(json, options))
        {
            int sumOfAllTemperatures = 0;
            int count = 0;

            foreach (JsonElement element in document.RootElement.EnumerateArray())
            {
                DateTimeOffset date = element.GetProperty("date").GetDateTimeOffset();

                if (date.DayOfWeek == DayOfWeek.Monday)
                {
                    int temp = element.GetProperty("temp").GetInt32();
                    sumOfAllTemperatures += temp;
                    count++;
                }
            }

            double averageTemp = (double)sumOfAllTemperatures / count;
            return(averageTemp);
        }
    }
예제 #13
0
        private IDictionary <string, string> ParseStream(int baseIndex, string json)
        {
            _baseIndex = baseIndex;

            //
            // Set up JSON options.
            //
            JsonDocumentOptions jsonDocumentOptions = new JsonDocumentOptions
            {
                CommentHandling     = JsonCommentHandling.Skip,
                AllowTrailingCommas = true,
            };

            //
            // Create a document and parse the JSON text.
            //
            using (JsonDocument doc = JsonDocument.Parse(json, jsonDocumentOptions))
            {
                //
                // Only allow an object at the root of the document.
                //
                if (doc.RootElement.ValueKind != JsonValueKind.Object)
                {
                    throw new FormatException("Invalid top level JSON object.");
                }

                //
                // Start parsing t the top level object.
                //
                this.VisitElement(doc.RootElement);
            }

            return(_data);
        }
예제 #14
0
        public void FromJson()
        {
            var options = new JsonDocumentOptions
            {
                AllowTrailingCommas = true,
                CommentHandling     = JsonCommentHandling.Skip,
            };

            Aes128Ctr Load(string json)
            {
                using (JsonDocument doc = JsonDocument.Parse(json, options))
                {
                    return((Aes128Ctr)Aes128Ctr.FromJson(doc.RootElement));
                }
            }

            Aes128Ctr cipher = Load(@"{
                ""iv"": ""bc7f2ca23bfee0dd9725228ab2b0d98a"",
            }");

            TestUtils.AssertBytesEqual(
                new byte[]
            {
                0xbc, 0x7f, 0x2c, 0xa2, 0x3b, 0xfe, 0xe0, 0xdd,
                0x97, 0x25, 0x22, 0x8a, 0xb2, 0xb0, 0xd9, 0x8a,
            }.ToImmutableArray(),
                cipher.Iv
                );

            Assert.Throws <InvalidKeyJsonException>(() =>
                                                    Load(@"{
                    // ""iv"": ""..."",  // lacks
                }")
                                                    );

            Assert.Throws <InvalidKeyJsonException>(() =>
                                                    Load(@"{
                    ""iv"": true,  // not a string
                }")
                                                    );

            Assert.Throws <InvalidKeyJsonException>(() =>
                                                    Load(@"{
                    ""iv"": null,  // not a string, but null
                }")
                                                    );

            Assert.Throws <InvalidKeyJsonException>(() =>
                                                    Load(@"{
                    ""iv"": ""not a hexadecimal string"",
                }")
                                                    );

            Assert.Throws <InvalidKeyJsonException>(() =>
                                                    Load(@"{
                    ""iv"": ""bc7f2ca23bfee0dd9725228ab2b0d98"",
                    // iv: invalid length
                }")
                                                    );
        }
예제 #15
0
        private static async Task <List <Setting> > FlattenJson(string filePath)
        {
            var flattenedJson = new List <Setting>();

            var options = new JsonDocumentOptions
            {
                AllowTrailingCommas = true,
                CommentHandling     = JsonCommentHandling.Skip
            };

            await using (FileStream fileStream = new FileStream(
                             filePath,
                             FileMode.Open,
                             FileAccess.Read,
                             FileShare.Read,
                             bufferSize: 4096,
                             useAsync: true))
                using (JsonDocument document = await JsonDocument.ParseAsync(fileStream, options))
                {
                    foreach (JsonProperty property in document.RootElement.EnumerateObject())
                    {
                        var keys = new List <string> {
                            property.Name
                        };

                        Parse(flattenedJson, keys, property);
                    }
                }

            return(flattenedJson);
        }
        public static ReportLayout ReadReportLayout(this PBIFile pbiFile)
        {
            var reportLayoutFile = pbiFile.ArchiveEntries
                                   .FirstOrDefault(x => x.FullName == PbiFileContents.ReportLayout);

            if (reportLayoutFile == null)
            {
                throw new ContentNotFoundException("Unable to read Report Layout content.");
            }

            var reader = new StreamReader(reportLayoutFile.Open(), Encoding.Unicode);
            var reportLayoutFileContent = reader.ReadToEnd();

            if (reportLayoutFileContent == null)
            {
                throw new ContentEmptyException("Report Layout is empty");
            }

            var options = new JsonDocumentOptions {
                AllowTrailingCommas = true
            };
            var report = JsonDocument.Parse(reportLayoutFileContent, options);

            var reportLayout = new ReportLayout
            {
                Id            = GetReportId(report.RootElement),
                ReportPages   = GetPages(report.RootElement),
                Configuration = GetConfiguration(report.RootElement)
            };

            return(reportLayout);
        }
        /// <summary>
        /// Parses the Json body of a trigger call to a TriggerCall model object
        /// </summary>
        /// <param name="data">Json data</param>
        /// <param name="type">Trigger type</param>
        /// <returns>Parsed model object</returns>
        public static TriggerCall ParseJson(string data, string type)
        {
            TriggerCall tc = new TriggerCall(type);

            var options = new JsonDocumentOptions
            {
                AllowTrailingCommas = true
            };

            using (JsonDocument document = JsonDocument.Parse(data, options))
            {
                foreach (JsonProperty property in document.RootElement.EnumerateObject())
                {
                    if (property.Name.Equals("INPUT", System.StringComparison.CurrentCultureIgnoreCase))
                    {
                        int length = property.Value.GetArrayLength();
                        tc.Input = new string[length];

                        for (int i = 0; i < length; i++)
                        {
                            tc.Input[i] = property.Value[i].ToString();
                        }
                    }
                    else
                    {
                        tc.EnvironmentVars.Add(property.Name, property.Value.GetString());
                    }
                }
            }

            return(tc);
        }
예제 #18
0
        public async Task <ExportResult> ExportLocalizationFilesAsync(string templateJsonPath, ExportOptions options, CancellationToken cancellationToken = default)
        {
            JsonDocumentOptions jsonOptions = new JsonDocumentOptions()
            {
                CommentHandling     = JsonCommentHandling.Skip,
                AllowTrailingCommas = true,
            };

            try
            {
                using FileStream fileStream     = new FileStream(templateJsonPath, FileMode.Open, FileAccess.Read);
                using JsonDocument jsonDocument = await JsonDocument.ParseAsync(fileStream, jsonOptions, cancellationToken).ConfigureAwait(false);

                TemplateStringExtractor        stringExtractor     = new TemplateStringExtractor(jsonDocument, _loggerFactory);
                IReadOnlyList <TemplateString> templateJsonStrings = stringExtractor.ExtractStrings(out string templateJsonLanguage);

                string targetDirectory = options.TargetDirectory ?? Path.Combine(Path.GetDirectoryName(templateJsonPath) ?? string.Empty, "localize");

                await TemplateStringUpdater.UpdateStringsAsync(
                    templateJsonStrings,
                    templateJsonLanguage,
                    options.Languages ?? ExportOptions.DefaultLanguages,
                    targetDirectory,
                    options.DryRun,
                    _logger,
                    cancellationToken).ConfigureAwait(false);

                return(new ExportResult(templateJsonPath));
            }
            catch (Exception exception)
            {
                return(new ExportResult(templateJsonPath, null, exception));
            }
        }
예제 #19
0
        public object Parse(string json)
        {
            var jsonDocumentOptions = new JsonDocumentOptions();
            var jsonDocument        = JsonDocument.Parse(json, jsonDocumentOptions);

            return(_deserializer.Deserialize(jsonDocument.RootElement));
        }
예제 #20
0
 public static Object DeepParse(string json, JsonDocumentOptions options = default)
 {
     using (var doc = System.Text.Json.JsonDocument.Parse(json, options))
     {
         return(DeepClone(doc));
     }
 }
        /// <summary>
        /// Loads the JSON data from a stream.
        /// </summary>
        /// <param name="stream">The JSON stream to read.</param>
        /// <param name="options">The parser options.</param>
        public static IDictionary <string, string> ParseStream(Stream stream, ParseToDictionaryOptions options = null)
        {
            var parserOptions = options ?? new ParseToDictionaryOptions();

            var data        = new SortedDictionary <string, string>(StringComparer.OrdinalIgnoreCase);
            var prefixStack = new Stack <string>();

            var jsonDocumentOptions = new JsonDocumentOptions
            {
                CommentHandling     = JsonCommentHandling.Skip,
                AllowTrailingCommas = true,
            };

            if (parserOptions.Parents != null)
            {
                foreach (var parent in parserOptions.Parents)
                {
                    prefixStack.Push(parent);
                }
            }

            using (var reader = new StreamReader(stream))
            {
                using (var doc = JsonDocument.Parse(reader.ReadToEnd(), jsonDocumentOptions))
                {
                    if (doc.RootElement.ValueKind != JsonValueKind.Object)
                    {
                        throw new FormatException($"Top-level JSON element must be an object. Instead, '{doc.RootElement.ValueKind}' was found.");
                    }
                    VisitElement(doc.RootElement, prefixStack, data, parserOptions);
                }
            }

            return(data);
        }
예제 #22
0
        /// <summary>
        /// Import games from the json file and add them to the global game dictionary.
        /// </summary>
        private static void ImportGames(ref int nGameCount)
        {
            var options = new JsonDocumentOptions
            {
                AllowTrailingCommas = true
            };

            string strDocumentData = File.ReadAllText(GAME_JSON_FILE);

            if (strDocumentData == "")            // File is empty
            {
                return;
            }

            using (JsonDocument document = JsonDocument.Parse(strDocumentData, options))
            {
                JsonElement jArrGames;
                if (!document.RootElement.TryGetProperty(GAMES_ARRAY, out jArrGames))
                {
                    return;                     // 'games' array does not exist
                }
                foreach (JsonElement jElement in jArrGames.EnumerateArray())
                {
                    string strTitle    = jElement.GetProperty(GAMES_ARRAY_TITLE).GetString();
                    string strLaunch   = jElement.GetProperty(GAMES_ARRAY_LAUNCH).GetString();
                    string strPlatform = jElement.GetProperty(GAMES_ARRAY_PLATFORM).GetString();
                    bool   bFavourite  = jElement.GetProperty(GAMES_ARRAY_FAVOURITE).GetBoolean();

                    CGameData.AddGame(strTitle, strLaunch, bFavourite, strPlatform);
                    nGameCount++;
                }
            }
        }
예제 #23
0
        public static List <Field> GetJsonFields(string Json)
        {
            object obj = JsonSerializer.Deserialize <object>(Json);

            Console.WriteLine("JsonString:" + Json);
            Console.WriteLine("Obj:" + obj.ToString());
            Console.WriteLine("ObjType:" + obj.GetType());

            var options = new JsonDocumentOptions
            {
                AllowTrailingCommas = true
            };

            var fields = new List <Field>();

            using (JsonDocument document = JsonDocument.Parse(Json, options))
            {
                fields = ReadProperties(document.RootElement).Distinct().Select(x => new Field()
                {
                    FieldName = x.TrimStart('.')
                }).ToList();
            }

            return(fields);
        }
 public ModelQuery(string content)
 {
     _content      = content;
     _parseOptions = new JsonDocumentOptions
     {
         AllowTrailingCommas = true
     };
 }
예제 #25
0
        public void RunJsonPatchTests(string path)
        {
            Debug.WriteLine($"Test {path}");
            string text        = System.IO.File.ReadAllText(path);
            var    jsonOptions = new JsonDocumentOptions();

            jsonOptions.CommentHandling = JsonCommentHandling.Skip;
            using JsonDocument doc      = JsonDocument.Parse(text, jsonOptions);
            var testsEnumeratable = doc.RootElement.EnumerateArray();
            var comparer          = JsonElementEqualityComparer.Instance;

            foreach (var testGroup in testsEnumeratable)
            {
                JsonElement given                 = testGroup.GetProperty("given");
                var         testCases             = testGroup.GetProperty("cases");
                var         testCasesEnumeratable = testCases.EnumerateArray();
                foreach (var testCase in testCasesEnumeratable)
                {
                    string      comment;
                    JsonElement commentElement;
                    if (testCase.TryGetProperty("comment", out commentElement) && commentElement.ValueKind == JsonValueKind.String)
                    {
                        comment = commentElement.GetString();
                    }
                    else
                    {
                        comment = "";
                    }

                    try
                    {
                        JsonElement patch;
                        Assert.IsTrue(testCase.TryGetProperty("patch", out patch) && patch.ValueKind == JsonValueKind.Array);
                        JsonElement expected;
                        if (testCase.TryGetProperty("error", out expected))
                        {
                            // Assert.ThrowsException<JsonPatchParseException>(() => JsonPatch.Parse(exprElement.ToString()));
                        }
                        else if (testCase.TryGetProperty("result", out expected))
                        {
                            using JsonDocument result = JsonPatch.ApplyPatch(given, patch);
                            Assert.IsTrue(comparer.Equals(result.RootElement, expected));

                            using JsonDocument patch2  = JsonPatch.FromDiff(given, result.RootElement);
                            using JsonDocument result2 = JsonPatch.ApplyPatch(given, patch2.RootElement);
                            Assert.IsTrue(comparer.Equals(result2.RootElement, expected));
                        }
                    }
                    catch (Exception e)
                    {
                        Debug.WriteLine("File: {0}", path);
                        Debug.WriteLine(comment);
                        Debug.WriteLine("Error: {0}", e.Message);
                        throw e;
                    }
                }
            }
        }
예제 #26
0
        private void LoadProgramSettingsJSON()
        {
            listaDirHistoria = new List <List <DirInfo> >();
            try
            {
                string jsonString = File.ReadAllText(_settingsFileName);
                var    options    = new JsonDocumentOptions {
                    AllowTrailingCommas = true, CommentHandling = JsonCommentHandling.Skip
                };

                using JsonDocument document = JsonDocument.Parse(jsonString, options);

                JsonElement element = document.RootElement.GetProperty("GUI");

                this.StartPosition   = FormStartPosition.Manual;
                this.DesktopLocation = new Point(element.GetProperty("Left").GetInt32(), element.GetProperty("Top").GetInt32());
                this.ClientSize      = new Size(element.GetProperty("Width").GetInt32(), element.GetProperty("Height").GetInt32());

                element = document.RootElement.GetProperty("DirInfo");

                DirInfo dir;
                int     i = 0;
                foreach (JsonProperty Folder in element.EnumerateObject())
                {
                    listaDirHistoria.Add(new List <DirInfo>());
                    foreach (JsonElement SubFolder in Folder.Value.EnumerateArray())
                    {
                        JsonElement SubF = SubFolder.EnumerateObject().ElementAt(0).Value;

                        dir.Nombre     = SubF.GetProperty("Name").GetString();
                        dir.Ruta       = SubF.GetProperty("Path").GetString();
                        dir.Carpetas   = SubF.GetProperty("Folders").GetInt32();
                        dir.Archivos   = SubF.GetProperty("Files").GetInt32();
                        dir.porcentaje = SubF.GetProperty("Percentage").GetDouble();
                        dir.bytes      = SubF.GetProperty("Bytes").GetInt64();
                        dir.kilo       = SubF.GetProperty("KB").GetDouble();
                        dir.mega       = SubF.GetProperty("MB").GetDouble();
                        dir.giga       = SubF.GetProperty("GB").GetDouble();
                        listaDirHistoria[0].Add(dir);
                    }
                    i++;
                }
            }
            catch (FileNotFoundException)
            {
            }
            catch (Exception ex)
            {
                using (new CenterWinDialog(this))
                {
                    MessageBox.Show(this,
                                    "Error loading settings file\n\n" + ex.Message,
                                    "Error",
                                    MessageBoxButtons.OK,
                                    MessageBoxIcon.Error);
                }
            }
        }
        private JsonElement ToJsonDocument(string response)
        {
            var documentOptions = new JsonDocumentOptions
            {
                CommentHandling = JsonCommentHandling.Skip
            };

            return(JsonDocument.Parse(response, documentOptions).RootElement);
        }
예제 #28
0
        /// <summary>
        ///   Parse text representing a single JSON value.
        /// </summary>
        /// <param name="utf8Json">JSON text to parse.</param>
        /// <param name="nodeOptions">Options to control the node behavior after parsing.</param>
        /// <param name="documentOptions">Options to control the document behavior during parsing.</param>
        /// <returns>
        ///   A <see cref="JsonNode"/> representation of the JSON value.
        /// </returns>
        /// <exception cref="JsonException">
        ///   <paramref name="utf8Json"/> does not represent a valid single JSON value.
        /// </exception>
        public static JsonNode?Parse(
            ReadOnlySpan <byte> utf8Json,
            JsonNodeOptions?nodeOptions         = null,
            JsonDocumentOptions documentOptions = default(JsonDocumentOptions))
        {
            JsonElement element = JsonElement.ParseValue(utf8Json, documentOptions);

            return(JsonNodeConverter.Create(element, nodeOptions));
        }
예제 #29
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PartImporter"/> class.
 /// </summary>
 /// <param name="repository">The repository.</param>
 /// <exception cref="ArgumentNullException">repository</exception>
 public PartImporter(ICadmusRepository repository)
 {
     _options = new JsonDocumentOptions
     {
         AllowTrailingCommas = true
     };
     _repository = repository ??
                   throw new ArgumentNullException(nameof(repository));
 }
예제 #30
0
파일: Resources.cs 프로젝트: EYHN/Anything
    public static JsonDocument ReadEmbeddedJsonFile(Assembly assembly, string path)
    {
        var options = new JsonDocumentOptions {
            CommentHandling = JsonCommentHandling.Skip
        };
        var document = JsonDocument.Parse(ReadEmbeddedFile(assembly, path), options);

        return(document);
    }