Пример #1
0
        static String Describe <T>(T m)
        {
            var serializer = new YamlDotNet.Serialization.Serializer();
            var rv         = serializer.Serialize(m);

            return(rv);
        }
Пример #2
0
        public static string write(ListValue value)
        {
            IList <object> docs   = convertList(value);
            var            writer = new YamlDotNet.Serialization.Serializer();

            return(writer.Serialize(docs));
        }
Пример #3
0
        private static void WriteOutput(object value, OutputFormat format, TextWriter writer)
        {
            switch (format)
            {
            case OutputFormat.Yaml:
            {
                var serializer = new YamlDotNet.Serialization.Serializer();

                serializer.Serialize(writer, value);
                break;
            }

            case OutputFormat.Json:
            {
                var serializer = new Newtonsoft.Json.JsonSerializer
                {
                    Formatting = Newtonsoft.Json.Formatting.Indented,
                };

                serializer.Serialize(writer, value);
                break;
            }

            default:
            {
                throw new NotSupportedException($"Output format `{format}` is not supported in this context.");
            }
            }
        }
Пример #4
0
        public static void SaveYaml <T>(string path, T obj)
        {
            var yaml     = new YamlDotNet.Serialization.Serializer();
            var contents = yaml.Serialize(obj);

            File.WriteAllText(path, Env.ConfigTitle + contents);
        }
Пример #5
0
        }        //end stats

        //This is what changes the text output
        public async Task <string> optupt_converter(string format, object obj)
        {
            if (null == obj)
            {
                if (globals.debug)
                {
                    Console.WriteLine(String.Format("Output Converter: No Object"));
                }
                return("");
            }
            string     output      = String.Empty;
            TextWriter text_writer = new StringWriter();

            switch (format)
            {
            case "none": break;

            case "raw": await text_writer.WriteAsync(obj.ToString()); break;

            case "json": await text_writer.WriteAsync(JsonConvert.SerializeObject(obj)); break;

            case "yaml": var serializer = new YamlDotNet.Serialization.Serializer();                                        //TODO awync yaml
                serializer.Serialize(text_writer, obj, obj.GetType());
                break;
            }
            return(text_writer.ToString());
        }
Пример #6
0
        public void Serialization()
        {
            ProgramDefinition pd = new ProgramDefinition();

            pd.Commands = new Dictionary <string, CommandDefinition>();
            pd.Commands.Add("stepname", new CommandDefinition()
            {
                Action = "xxd",
                Args   = new Dictionary <string, object>()
                {
                    { "sss", 22 }
                }
            });;


            pd.State = new Dictionary <string, object>()
            {
                { "key", "value" }
            };

            var dese = new YamlDotNet.Serialization.Serializer();
            var sttr = dese.Serialize(pd);

            Assert.NotNull(sttr);
        }
Пример #7
0
        //[CakeNamespaceImport("YamlDotNet")]
        public static void SerializeYamlToFile <T> (this ICakeContext context, FilePath filename, T instance)
        {
            var s = new YamlDotNet.Serialization.Serializer();

            using (var tw = new StreamWriter(File.Open(filename.MakeAbsolute(context.Environment).FullPath, FileMode.Create)))
                s.Serialize(tw, instance);
        }
        static async Task RunImageScanAsync()
        {
            var contninue = false;

            do
            {
                Console.Clear();
                Console.WriteLine("Enter an Image URL (e.g. https://moderatorsampleimages.blob.core.windows.net/samples/sample16.png):");
                var url = Console.ReadLine();

                if (string.IsNullOrWhiteSpace(url))
                {
                    Console.WriteLine("URL is empty");
                }
                else
                {
                    Console.WriteLine("Analyzing the image with Azure Cognitive Service...");
                    var cv = new ComputerVisionService(new ConfigurationReader());
                    var ar = await cv.AnalyzeImageUrl(url);

                    var serializer = new YamlDotNet.Serialization.Serializer();
                    var yaml       = serializer.Serialize(ar);
                    Console.WriteLine("Analysis report:");
                    Console.WriteLine(yaml);

                    Console.WriteLine("\n\nPress 'C' to continue...");
                    contninue = Char.ToUpperInvariant(Console.ReadKey().KeyChar) == 'C';
                }
            } while (contninue);
        }
Пример #9
0
        private static async Task <int> Citizen(CitizenOptions opts)
        {
            var api = new NexusApi();

            if (opts.CitizenId == null)
            {
                var list = await api.GetCitizensAsync().ConfigureAwait(false);

                Console.WriteLine($"{list.Count:N0} citizens fetched");
                foreach (var citizen in list)
                {
                    Console.WriteLine($"{citizen.Id,6:D} {citizen.Name}");
                }
            }
            else
            {
                var details = await api.GetCitizenAsync(opts.CitizenId.Value).ConfigureAwait(false);

                if (details == null)
                {
                    Console.WriteLine($"Citizen {opts.CitizenId.Value} does not exist");
                    return(0);
                }

                Console.WriteLine($"Citizen {details.Id} fetched");

                var serialiser = new YamlDotNet.Serialization.Serializer();
                var yml        = serialiser.Serialize(details);
                Console.WriteLine(yml);
            }

            return(0);
        }
Пример #10
0
        /// <summary>
        /// 执行
        /// </summary>
        /// <param name="context">上下文</param>
        /// <param name="result">值</param>
        /// <returns></returns>
        public async Task ExecuteAsync(ActionContext context, T result)
        {
            var serialize   = new YamlDotNet.Serialization.Serializer();
            var valueString = serialize.Serialize(result.Value);

            context.HttpContext.Response.ContentType = "Content-Type: text/html; charset=utf-8";
            await context.HttpContext.Response.WriteAsync(valueString);
        }
Пример #11
0
        // object dumper for debug/dev
        public static void DumpAsYaml(object obj)
        {
            var stringBuilder = new System.Text.StringBuilder();
            var serializer    = new YamlDotNet.Serialization.Serializer();

            serializer.Serialize(new System.CodeDom.Compiler.IndentedTextWriter(new StringWriter(stringBuilder)), obj);
            Console.WriteLine(stringBuilder);
        }
Пример #12
0
 /// <summary>
 /// Serialize
 /// </summary>
 /// <param name="entity"></param>
 /// <param name="stream"></param>
 public void Serialize(object entity, Stream stream)
 {
     if (_serializer == null)
     {
         _serializer = new YamlDotNet.Serialization.Serializer();
     }
     _serializer.Serialize(new StreamWriter(stream), entity);
 }
Пример #13
0
 /// <summary>
 /// Serialize
 /// </summary>
 /// <param name="entity"></param>
 /// <returns></returns>
 public string Serialize(object entity)
 {
     if (_serializer == null)
     {
         _serializer = new YamlDotNet.Serialization.Serializer();
     }
     return(_serializer.Serialize(entity));
 }
Пример #14
0
        public override void Save(T data)
        {
            var serializer = new YamlDotNet.Serialization.Serializer();

            using (TextWriter writer = File.CreateText(FileName))
            {
                serializer.Serialize(writer, data);
            }
        }
Пример #15
0
        public static void SaveAsYaml(string filePath, object obj)
        {
            using (var writer = System.IO.File.CreateText(filePath))
            {
                var serializer = new YamlDotNet.Serialization.Serializer();

                serializer.Serialize(writer, obj);
            }
        }
Пример #16
0
 public string Serialize <T>(T data) where T : class, new()
 {
     using (var stringWriter = new StringWriter())
     {
         var serializer = new YamlDotNet.Serialization.Serializer();
         serializer.Serialize(stringWriter, data);
         return(stringWriter.ToString());
     }
 }
Пример #17
0
 public static void SaveConfiguration(SavedApplicationVM configuration)
 {
     Directory.CreateDirectory(Path.GetDirectoryName(GetConfigurationPath()));
     using (var writer = File.CreateText(GetConfigurationPath()))
     {
         var s = new YamlDotNet.Serialization.Serializer();
         s.Serialize(writer, configuration);
     }
 }
Пример #18
0
        public void SaveAsYaml(string path)
        {
            var output = new System.IO.StreamWriter(path);

            var serializer = new YamlDotNet.Serialization.Serializer(YamlDotNet.Serialization.SerializationOptions.Roundtrip, new YamlDotNet.Serialization.NamingConventions.CamelCaseNamingConvention());

            serializer.Serialize(output, this);

            output.Close();
        }
Пример #19
0
        public void YAML出力Test()
        {
            var vpath = new VariablePath(@"$(Exe)test.txt");

            var sr   = new YamlDotNet.Serialization.Serializer();
            var yaml = sr.Serialize(vpath);

            Assert.AreEqual(@"$(Exe)test.txt
...
", yaml);
        }
Пример #20
0
        public static void Test()
        {
            Console.WriteLine("YAML: YamlDotNet.Serialization.Deserializer|Serializer");
            var zer = new YamlDotNet.Serialization.Deserializer();
            var per = zer.Deserialize <Person>("Name: Wagsn\r\nAge: 23\r\nSex: true");

            Console.WriteLine($"deserialize: name: {per?.Name}, age: {per?.Age}, sex: {per?.Sex}");
            var ser = new YamlDotNet.Serialization.Serializer();

            Console.WriteLine($"serialize: {ser.Serialize(per)}");
        }
Пример #21
0
        //[CakeNamespaceImport("YamlDotNet")]
        public static string SerializeYaml <T> (this ICakeContext context, T instance)
        {
            var s = new YamlDotNet.Serialization.Serializer();

            var sb = new StringBuilder();

            using (var tw = new StringWriter(sb))
                s.Serialize(tw, instance);

            return(sb.ToString());
        }
Пример #22
0
        public static void ExportDocument(string fileName, string mimeType, object data)
        {
            StreamWriter writer = new StreamWriter(fileName);

            writer.WriteLine("### YamlMime:" + mimeType);
            YamlDotNet.Serialization.SerializerBuilder builder = new YamlDotNet.Serialization.SerializerBuilder();
            YamlDotNet.Serialization.Serializer        s       = builder.Build();
            s.Serialize(writer, data);
            writer.Close();
            writer.Dispose();
        }
Пример #23
0
        static void SaveSiteMetadata(XElement[] children)
        {
            var siteMetaData = new SiteMetaData {
                Title       = children.First(e => e.Name == "title").Value,
                Description = children.First(e => e.Name == "description").Value
            };

            using (TextWriter writer = File.CreateText(Path.Combine(UserSettings.PathToJekyllSite, "siteMetaData.yaml"))) {
                var a = new YamlDotNet.Serialization.Serializer();
                a.Serialize(writer, siteMetaData);
            }
        }
Пример #24
0
        public async Task <bool> DeployAsync(UpdateInfo info, NetworkCredential credentials)
        {
            try
            {
                var rsa = SignaturePrivateCertificate.GetRSAPrivateKey();

                // generate manifest bytes
                var serializer = new YamlDotNet.Serialization.Serializer();
                var yaml       = serializer.Serialize(info);
                var yamlBytes  = Encoding.UTF8.GetBytes(yaml);

                // generate signature for yaml manifest
                var signature = rsa.SignData(yamlBytes, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);

                try
                {
                    // upload manifest and signature
                    var webClient = new WebClient {
                        Credentials = credentials
                    };

                    await webClient.UploadDataTaskAsync(new Uri(UpdateUri, "update.yml"), "PUT", yamlBytes)
                    .ConfigureAwait(false);

                    await webClient.UploadDataTaskAsync(new Uri(UpdateUri, "update.sig"), "PUT", signature)
                    .ConfigureAwait(false);

                    Logger?.Info("Uploaded update manifest.");

                    // upload all application files
                    foreach (var infoFile in info.Files)
                    {
                        await webClient
                        .UploadFileTaskAsync(new Uri(UpdateUri, infoFile.RelativeUrl), "PUT", infoFile.RelativeUrl)
                        .ConfigureAwait(false);

                        Logger?.Info($"Uploaded {Path.GetFileName(infoFile.RelativeUrl)}.");
                    }

                    return(true);
                }
                catch (WebException e)
                {
                    Logger?.Error("Unable to upload file.", e);
                    return(false);
                }
            }
            catch (CryptographicException e)
            {
                Logger?.Error($"Failed to use private key: {e.Message}", e);
                return(false);
            }
        }
Пример #25
0
    static void Main(string[] args)
    {
        var json            = "{\"swagger\":\"2.0\",\"info\":{\"title\":\"UberAPI\",\"description\":\"MoveyourappforwardwiththeUberAPI\",\"version\":\"1.0.0\"},\"host\":\"api.uber.com\",\"schemes\":[\"https\"],\"basePath\":\"/v1\",\"produces\":[\"application/json\"]}";
        var swaggerDocument = ConvertJTokenToObject(JsonConvert.DeserializeObject <JToken>(json));
        var serializer      = new YamlDotNet.Serialization.Serializer();

        using (var writer = new StringWriter())
        {
            serializer.Serialize(writer, swaggerDocument);
            var yaml = writer.ToString();
            Console.WriteLine(yaml);
        }
    }
Пример #26
0
        public static void SaveTheme(this MsDev2013_Theme theme, string fileName)
        {
            var serializer = new YamlDotNet.Serialization.Serializer();

              using (var writer = new System.IO.StringWriter())
              {
            var themeSettings = Wrap(theme.ToSetting());
            serializer.Serialize(writer, themeSettings, typeof(MsDev2013SettingsCollection));
            var stringdata = writer.ToString();
            System.IO.File.WriteAllText(fileName, stringdata);
              }
              serializer = null;
        }
Пример #27
0
        private static T ConvertNodeToObject <T>(YamlNode node)
        {
            var yamlStr = new YamlDotNet.Serialization.Serializer().Serialize(node);

            using (var tr = new StringReader(yamlStr)) {
                try {
                    return(new YamlDotNet.Serialization.Deserializer().Deserialize <T>(tr));
                }
                catch (YamlException) {
                    throw new InvalidCastException($"Invalid type: /{yamlStr}/ expected: {typeof(T).Name}");
                }
            }
        }
        public YamlNode ToYaml()
        {
            var serializer = new YamlDotNet.Serialization.Serializer();

            string json = JsonConvert.SerializeObject(Token);
            var    dict = JsonConvert.DeserializeObject <ExpandoObject>(json, new ExpandoObjectConverter());

            var yaml         = serializer.Serialize(dict);
            var deserializer = new YamlDotNet.Serialization.Deserializer();

            using (TextReader reader = new StringReader(yaml))
            {
                return(deserializer.Deserialize(reader, typeof(YamlMappingNode)) as YamlMappingNode);
            }
        }
Пример #29
0
    public void Apply(SwaggerDocument swaggerDoc, SchemaRegistry schemaRegistry, IApiExplorer apiExplorer)
    {
        string file = AppDomain.CurrentDomain.BaseDirectory + "swagger.yaml";

        if (!File.Exists(file))
        {
            var serializer = new YamlDotNet.Serialization.Serializer();
            using (var writer = new StringWriter())
            {
                serializer.Serialize(writer, swaggerDoc);
                var stream = new StreamWriter(file);
                stream.WriteLine(writer.ToString());
            }
        }
    }
Пример #30
0
        public void DumpMapping(WorkItemsStageConfiguration mapping)
        {
            var output = new System.IO.StringWriter();

            output.WriteLine();
            output.WriteLine("# mapping dump start #");
            var serializer = new YamlDotNet.Serialization.Serializer(YamlDotNet.Serialization.SerializationOptions.EmitDefaults, new YamlDotNet.Serialization.NamingConventions.CamelCaseNamingConvention());

            serializer.Serialize(output, mapping);
            output.WriteLine("# mapping dump  end  #");
            output.Flush();

            this.Verbose("Dumping Mapping");
            base.RawOut(VerboseColor, TraceLevel.Verbose, output.ToString());
        }
Пример #31
0
        public void Execute(BuildRequest request, ZlpDirectoryInfo workingDirectory)
        {
            // https://docs.aws.amazon.com/codedeploy/latest/userguide/writing-app-spec.html
            try
            {
                ZlpFileInfo appSpecFile = (from f in workingDirectory.GetFiles("appspec.yml", SearchOption.TopDirectoryOnly)
                                           select f).SingleOrDefault();

                if (appSpecFile == null)
                {
                    Program.Logger.Warn("Generating AppSpec file. For advanced configuration create and include an appspec.yml at the root of your project. See: https://docs.aws.amazon.com/codedeploy/latest/userguide/app-spec-ref-structure.html");

                    string appSpecFilePath = Path.Combine(workingDirectory.FullName, "appspec.yml");

                    appSpecFile = new ZlpFileInfo(appSpecFilePath);

                    AppSpec appSpec = this.BuildAppSpec(request, workingDirectory);

                    using (FileStream stream = appSpecFile.OpenCreate())
                    {
                        using (StreamWriter sWriter = new StreamWriter(stream))
                        {
                            using (StringWriter writer = new StringWriter())
                            {
                                YamlDotNet.Serialization.Serializer serializer = new YamlDotNet.Serialization.Serializer();
                                serializer.Serialize(writer, appSpec);
                                var yaml = writer.ToString();
                                sWriter.WriteLine(yaml);
                                Program.Logger.Info("----------------------- BEGIN APPSPEC -----------------------");
                                Program.Logger.Info(yaml);
                                Program.Logger.Info("----------------------- END APPSPEC -----------------------");
                            }
                        }
                    }
                }
                else
                {
                    Program.Logger.Info("    An AppSpec file was found in the working directory. This plug-in will not generate an AppSec.");
                }
            }
            catch (Exception ex)
            {
                Program.Logger.Error(ex);
                throw ex;
            }
        }
Пример #32
0
        public override void Run()
        {
            var serializer = new YamlDotNet.Serialization.Serializer();
              using (var writer = new System.IO.StringWriter())
              {
            using (var sfd = new System.Windows.Forms.SaveFileDialog() { Filter = "YAML File|*.yml" })
            {
              var themeSettings = new MsDev2013SettingsCollection()
              {
            Theme =new System.Collections.Generic.List<MsDev2013Settings>
            { { MsDev2013_Theme.Instance.ToSetting() } }
              };

              serializer.Serialize(writer, themeSettings, typeof(MsDev2013SettingsCollection));
              var stringdata = writer.ToString();

              if (sfd.ShowDialog() != DialogResult.OK) return;

              System.IO.File.WriteAllText(sfd.FileName, stringdata);
            }
              }
              serializer = null;
        }
Пример #33
0
 public static string Save(ThemeSetting input)
 {
     using (var writer = new System.IO.StringWriter()) {
     var serializer = new YamlDotNet.Serialization.Serializer();
     serializer.Serialize(writer, input);
     var result = writer.ToString();
     serializer = null;
     return result;
       }
 }