private static void Serialize(ApplicationSetting setting, string path) { var serializer = new SerializerBuilder().EmitDefaults().Build(); var yml = serializer.Serialize(setting); using (var sr = new StreamWriter(path)) { sr.Write(yml); } }
public static string DumpAsYaml(this object o) { var stringBuilder = new StringBuilder(); var serializer = new SerializerBuilder() .EnsureRoundtrip() .Build(); serializer.Serialize(new IndentedTextWriter(new StringWriter(stringBuilder)), o, o.GetType()); return(stringBuilder.ToString()); }
public static void Serialize <T>([NotNull] FileInfo file, [CanBeNull] T obj) { using var stream = file.CreateText(); var serializer = new SerializerBuilder() .ConfigureDefaultValuesHandling(DefaultValuesHandling.Preserve) .WithTagMappings(TagMappings) .Build(); serializer.Serialize(stream, obj); }
static Serializer() { _serializer = new SerializerBuilder() .WithNamingConvention(CamelCaseNamingConvention.Instance) .Build(); _deserializer = new DeserializerBuilder() .WithNamingConvention(CamelCaseNamingConvention.Instance) .Build(); }
public static void DataToYaml(TextWriter writer, IEnumerable <Dictionary <string, object> > datatable, YamlColumnNamesType yamlColumnNames = null) { var builder = new SerializerBuilder(); builder.EmitDefaults(); var serializer = builder.Build(); var tree = yamlColumnNames == null ? datatable : ConvertDataTableWithYamlColumns(datatable, yamlColumnNames); serializer.Serialize(writer, tree); }
public static ISerializer Create(SwaggerYamlOptions swaggerYamlOptions) { var builder = new SerializerBuilder(); builder.WithNamingConvention(new HyphenatedNamingConvention()); builder.WithTypeInspector(innerInspector => new PropertiesIgnoreTypeInspector(innerInspector, swaggerYamlOptions.IgnoredProperties)); builder.WithTypeInspector(innerInspector => new JsonPropertyNameApplyingTypeInspector(innerInspector)); builder.WithTypeInspector(innerInspector => new StringQuotingTypeInspector(innerInspector)); return(builder.Build()); }
public void Save(string filepath) { var builder = new SerializerBuilder(); builder.WithNamingConvention(HyphenatedNamingConvention.Instance); var serializer = builder.Build(); var yaml = serializer.Serialize(this); File.WriteAllText(filepath, yaml); }
static void Main(string[] args) { // Setup the input Console.WriteLine("Enter the File Name with Extension"); var fileName = Console.ReadLine(); string extension = CheckExtension(fileName); if (extension == "yaml") { try { var fileNameInstance = new StreamReader(".\\" + fileName); var deserializer = new DeserializerBuilder().Build(); var yamlObject = deserializer.Deserialize(fileNameInstance); var serializer = new SerializerBuilder() .JsonCompatible() .Build(); var json = serializer.Serialize(yamlObject); var jsonArray = JsonArray.Parse(json); foreach (var item in jsonArray) { Console.WriteLine("importing : " + item.ToString()); } } catch { Console.WriteLine("Either is File not Found Or Something went wrong"); } } else if (extension == "json") { try { var json = File.ReadAllText(".\\" + fileName); var jsonArray = JsonArray.Parse(json); foreach (var item in jsonArray) { Console.WriteLine("importing : " + item.ToString()); } } catch { Console.WriteLine("Either is File not Found Or Something went wrong"); } } else { Console.WriteLine("The " + extension + " File Extension is Not Designed as of now"); } }
/// <summary> /// Serialize a message. (See <see cref="IAsyncSerializer{T}.SerializeAsync(T, SerializationContext)" />.) /// </summary> public virtual async Task <byte[]> SerializeAsync(T data, SerializationContext context) { var serialize = await(_cache.GetOrAdd(SubjectNameBuilder(context), async subject => { int id; Action <T, Stream> @delegate; try { var existing = await _resolve(subject).ConfigureAwait(false); var schema = SchemaReader.Read(existing.SchemaString); @delegate = SerializerBuilder.BuildDelegate <T>(schema); id = existing.Id; } catch (Exception e) when(RegisterAutomatically && ( (e is SchemaRegistryException sre && sre.ErrorCode == 40401) || (e is AggregateException a && a.InnerExceptions.All(i => i is UnsupportedSchemaException || i is UnsupportedTypeException )) )) { var schema = SchemaBuilder.BuildSchema <T>(); var json = SchemaWriter.Write(schema); @delegate = SerializerBuilder.BuildDelegate <T>(schema); id = await _register(subject, json).ConfigureAwait(false); } var bytes = BitConverter.GetBytes(id); if (BitConverter.IsLittleEndian) { Array.Reverse(bytes); } return(value => { var stream = new MemoryStream(); using (stream) { stream.WriteByte(0x00); stream.Write(bytes, 0, bytes.Length); @delegate(value, stream); } return stream.ToArray(); }); })).ConfigureAwait(false); return(serialize(data)); }
async Task OnJsonSwitch(bool value) { this.ShowJson = value; var text = await this.yamlEditor.GetValue(); bool isJson = text.Trim().StartsWith("{"); try { if (this.ShowJson == true) { if (!isJson) { var doc = yamlDeserializer.Deserialize <LucyDocument>(new StringReader(text)); await yamlEditor.SetValue(JsonConvert.SerializeObject(doc, Formatting.Indented)); } } else { if (isJson) { var doc = JsonConvert.DeserializeObject <LucyDocument>(text); var yaml = new SerializerBuilder() .WithNamingConvention(CamelCaseNamingConvention.Instance) .Build() .Serialize(doc); await yamlEditor.SetValue(yaml); } } } catch (SemanticErrorException err) { this.Error = err.Message; this.alertBox.Show(); //this.editor.ScrollToLine(err.Start.Line); //var line = this.editor.Document.GetLineByNumber(err.Start.Line - 1); //this.editor.Select(line.Offset, line.Length); } catch (SyntaxErrorException err) { this.Error = err.Message; this.alertBox.Show(); //this.error.Visibility = Visibility.Visible; //this.editor.ScrollToLine(err.Start.Line); //var line = this.editor.Document.GetLineByNumber(err.Start.Line - 1); //this.editor.Select(line.Offset, line.Length); } catch (Exception err) { this.Error = err.Message; this.alertBox.Show(); //this.error.Content = err.Message; //this.error.Visibility = Visibility.Visible; } }
public MarkdownParseResult Parse(string markdown) { if (string.IsNullOrEmpty(markdown)) { return(new MarkdownParseResult(null, null)); } markdown = Regex.Replace(markdown, @"(\r\n)|(\n\r)|(\n\r)|(\r)", Environment.NewLine); var builder = new MarkdownPipelineBuilder(); builder.Extensions.Add(new Markdig.Extensions.Yaml.YamlFrontMatterExtension()); var pipeline = builder.Build(); var document = Markdown.Parse(markdown, pipeline); var yamlBlocks = document.Descendants <Markdig.Extensions.Yaml.YamlFrontMatterBlock>() .ToList(); if (yamlBlocks.Count == 0) { return(new MarkdownParseResult(null, markdown)); } if (yamlBlocks.Count > 1) { throw new InvalidOperationException(); } var yamlBlock = yamlBlocks.First(); var yamlBlockIterator = yamlBlock.Lines.ToCharIterator(); var yamlString = new StringBuilder(); while (yamlBlockIterator.CurrentChar != '\0') { yamlString.Append(yamlBlockIterator.CurrentChar); yamlBlockIterator.NextChar(); } var yamlDeserializer = new DeserializerBuilder().Build(); var yamlObject = yamlDeserializer.Deserialize(new StringReader(yamlString.ToString())); var serializer = new SerializerBuilder() .JsonCompatible() .Build(); dynamic yaml = Newtonsoft.Json.JsonConvert.DeserializeObject(serializer.Serialize(yamlObject)); markdown = markdown.Substring(yamlBlock.Span.End + 1); if (markdown.StartsWith(Environment.NewLine)) { markdown = markdown.Substring(Environment.NewLine.Length); } return(new MarkdownParseResult(yaml, markdown)); }
private static string JsonToYaml(JObject json) { var jsonString = JsonConvert.SerializeObject(json); var expConverter = new ExpandoObjectConverter(); dynamic deserializedObject = JsonConvert.DeserializeObject <ExpandoObject>(jsonString, expConverter); var serializer = new SerializerBuilder().DisableAliases().Build(); string yaml = serializer.Serialize(deserializedObject); return(yaml); }
public BlogBuilder() { inputDirectory = Path.Combine(".", "Input").ToDirectoryInfo(true); ouputDirectory = Path.Combine(".", "Output").ToDirectoryInfo(true); var builder = new SerializerBuilder() .WithNamingConvention(CamelCaseNamingConvention.Instance) .WithTypeConverter(new DateTimeConverter(DateTimeKind.Unspecified, null, YamlDateFormat)); this.yamlSerialiser = builder.Build(); }
/// <summary> /// Saves the configuration. /// </summary> /// <param name="config">The configuration.</param> /// <param name="strHelpDirectory">The string help directory.</param> /// <exception cref="NotImplementedException"></exception> public static void SaveConfig(HelpConfig config, string strHelpDirectory) { //string strConfigFilenameJSON = string.Format("{0}\\{1}", strHelpDirectory, CONFGIG_FILE_JSON); //string strJsonContent = JsonConvert.SerializeObject(config, Formatting.Indented); //File.WriteAllText(strConfigFilenameJSON, strJsonContent, Encoding.Default); string strConfigFilenameYAML = string.Format("{0}\\{1}", strHelpDirectory, CONFGIG_FILE_YAML); string strYamlContent = new SerializerBuilder().Build().Serialize(config); File.WriteAllText(strConfigFilenameYAML, strYamlContent, Encoding.Default); }
public void SerializationIncludesKeyWhenEmittingDefaults() { var writer = new StringWriter(); var obj = new Example { MyString = null }; SerializerBuilder.EmitDefaults().Build().Serialize(writer, obj, typeof(Example)); writer.ToString().Should().Contain("MyString"); }
public static string Serialize(object obj) { SerializerBuilder sb = new SerializerBuilder(); sb.EmitDefaults(); Serializer s = sb.Build(); StringWriter w = new StringWriter(); s.Serialize(w, obj, obj.GetType()); return(w.ToString()); }
public override string ToString() { var serializer = new SerializerBuilder() .WithEventEmitter(e => new LiteralMultilineEventEmitter(e)) .ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitDefaults) .DisableAliases() .Build(); var str = serializer.Serialize(this); return(str.Replace(": |-\r\n", ": |\r\n")); }
/// <summary> /// Loads this configuration file to the file system. /// </summary> public void Store() { Logger.LogDebug($"storing configuration to {File}"); var serializer = new SerializerBuilder().Build(); var yaml = serializer.Serialize(Configuration); using (var writer = new StreamWriter(File)) { writer.Write(yaml); } }
internal void Store() { Logger.LogDebug($"storing cloud foundry manifest to {File}"); var serializer = new SerializerBuilder().Build(); var yaml = serializer.Serialize(CloudFoundryManifest); using (var writer = new StreamWriter(File)) { writer.Write(yaml); } }
static ISerializer Build(SerializerBuilder serializerBuilder) { return(serializerBuilder .WithNamingConvention(CamelCaseNamingConvention.Instance) .WithTypeConverter(new SemanticVersionYamlTypeConverter()) .WithTypeConverter(new OsPlatformYamlTypeConverter()) .WithTypeConverter(new UriYamlTypeConverter()) .WithTypeConverter(new DateTimeConverter(DateTimeKind.Utc)) .DisableAliases() .Build()); }
public Model.Document CreateReportModel(dynamic data) { var yamlDeserializer = new DeserializerBuilder().Build(); var yamlSerializerJson = new SerializerBuilder().JsonCompatible().Build(); RenderedYamlDocument = _stubbleRenderer.Render(_yamlTemplateContent, data); var renderedYamlObj = yamlDeserializer.Deserialize <object>(RenderedYamlDocument); RenderedJsonDocument = yamlSerializerJson.Serialize(renderedYamlObj); return(JsonConvert.DeserializeObject <Model.Document>(RenderedJsonDocument)); }
public Configuration Save() { var serializer = new SerializerBuilder().EmitDefaults().WithNamingConvention(new CamelCaseNamingConvention()).Build(); using (var streamWriter = new StreamWriter(ConfigurationName)) { serializer.Serialize(streamWriter, this); } return(this); }
internal void Store() { Logger.LogDebug($"storing kubernetes deployment config to {File}"); var serializer = new SerializerBuilder().Build(); var yaml = serializer.Serialize(KubernetesDeploymentConfig); using (var writer = new StreamWriter(File)) { writer.Write(yaml); } }
/// <summary> /// Saves the configurations to disk. /// </summary> public async void SaveConfigs() { var serializer = new SerializerBuilder() .WithNamingConvention(new UnderscoredNamingConvention()) .Build(); using (var writer = cfgFile.OpenWrite()) { var resultingText = Encoding.UTF8.GetBytes(serializer.Serialize(cfgHashMap)); await writer.WriteAsync(resultingText, 0, resultingText.Length); } }
public void Yaml_Can_Convert_To_Json() { var deserializer = new DeserializerBuilder().Build(); var yamlObject = deserializer.Deserialize(new StringReader(YamlTestFileLoader.Load(@"Rijksoverheid/Zorgtoeslag.yaml"))); var serializer = new SerializerBuilder() .JsonCompatible() .Build(); var json = serializer.Serialize(yamlObject); }
public static string ToYaml(object obj) { if (obj == null) { return(null); } var yamlSerializer = new SerializerBuilder().Build(); var yaml = yamlSerializer.Serialize(obj); return(yaml); }
private async Task SaveYaml <T>(T data) where T : class { ISerializer serializer = new SerializerBuilder().EmitDefaults() .WithNamingConvention(new CamelCaseNamingConvention()) .Build(); var serializedYaml = serializer.Serialize(data); var encodedData = Encoding.UTF8.GetBytes(serializedYaml); var filePath = @$ "{Name}.yml"; await File.WriteAllBytesAsync(filePath, encodedData); }
public static string CreateToc(IEnumerable <TocEntry> entries) { var serializer = new SerializerBuilder() .ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitNull) .WithNamingConvention(CamelCaseNamingConvention.Instance) .Build(); var writer = new StringWriter(); serializer.Serialize(writer, entries); return("### YamlMime:TableOfContent" + Environment.NewLine + writer.ToString()); }
/// <summary> /// Serialize the configuration to a YAML string. /// </summary> public override string ToString() { var builder = new SerializerBuilder(); builder.EmitDefaults(); // Force even default values to be written, like 0, false. var serializer = builder.Build(); var strWriter = new StringWriter(); serializer.Serialize(strWriter, this); return(strWriter.ToString()); }
public void SerializationOfDefaultsWorkInJson() { var writer = new StringWriter(); var obj = new Example { MyString = null }; SerializerBuilder.EmitDefaults().JsonCompatible().Build().Serialize(writer, obj, typeof(Example)); writer.ToString().Should().Contain("MyString"); }
public string Serialize(IConfig config, Type type) { using (var writer = new StringWriter()) { var serializer = new SerializerBuilder() .EmitDefaults() .WithNamingConvention(new NullNamingConvention()) .WithTypeConverter(new VersionConverter()) .Build(); serializer.Serialize(writer, config); return writer.ToString(); } }
public void MappingIsSerializable(string yaml, string[] expectedKeysAndValues) { var deserializer = new Deserializer(); var node = deserializer.Deserialize<YamlMappingNode>(Yaml.ReaderForText(yaml)); Assert.NotNull(node); Assert.Equal(expectedKeysAndValues.Length / 2, node.Children.Count); for (int i = 0; i < expectedKeysAndValues.Length; i += 2) { Assert.Equal(expectedKeysAndValues[i + 1], ((YamlScalarNode)node.Children[expectedKeysAndValues[i]]).Value); } var serializer = new SerializerBuilder() .Build(); var buffer = new StringWriter(); serializer.Serialize(buffer, node); Assert.Equal(yaml.Replace("\r\n", Environment.NewLine), buffer.ToString().TrimEnd('\r', '\n', '.')); }
public void ScalarIsSerializable(string yaml, string expectedValue) { var deserializer = new Deserializer(); var node = deserializer.Deserialize<YamlScalarNode>(Yaml.ReaderForText(yaml)); Assert.NotNull(node); Assert.Equal(expectedValue, node.Value); var serializer = new SerializerBuilder() .Build(); var buffer = new StringWriter(); serializer.Serialize(buffer, node); Assert.Equal(yaml, buffer.ToString().TrimEnd('\r', '\n', '.')); }