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', '.'));
}
