【コピペで使える】C# で YAML ファイルを読み書きするクラス作りました

using System.Xml.Linq;
using System.Xml.Serialization;
using CommonClass;

//テストデータを定義
var data = new Dictionary<string, object>
        {
            { "Name", "John Doe" },
            { "Age", 30 },
            { "Tel", new string[]{"080-3333-5555","080-3333-6666","090-4444-2222"} },
            { "Address", new Dictionary<string, object>
                {
                    { "Street", "123 Main St" },
                    { "City", "New York" },
                    { "Country", "USA" }
                }
            }
        };

//YamlUtilクラスのインスタンスを生成
var yaml = new YamlUtil();

//テストデータをYAML形式で保存
yaml.Write(@"p:\data.yaml", data);

//テストデータの中身をクリア
data.Clear();

//YAMLファイルを読み込んでテストデータを復元
data = yaml.Read(@"p:\test.yaml");

using System.Xml.Linq;
using System.Xml.Serialization;
using CommonClass;

//Dataクラスのインスタンスを生成
var data = new Data();
data.Name = "John Doe";
data.Age = 32;
data.Tel = new string[] { "080-3333-5555", "080-3333-6666", "090-4444-2222" };
data.Address = new Dictionary<string, object>()
               {
                    { "Street", "123 Main St" },
                    { "City", "New York" },
                    { "Country", "USA" }
               };

//YamlUtilクラスのインスタンスを生成
var yaml = new YamlUtil();

//DataクラスのオブジェクトをYAML形式で保存
yaml.Write(@"p:\data.yaml", data);

data = null;

//YAMLファイルを読み込んでDataクラスのオブジェクトを復元
data = yaml.Read<Data>(@"p:\data.yaml");

//Dataクラスの定義
class Data
{
    public string Name { get; set; }
    public int Age { get; set; }
    public string[] Tel { get; set; }
    public Dictionary<string, object> Address { get; set; }
}

 [0]: {[Street, 123 Main St]}
 [1]: {[City, New York]}
 [2]: {[Country, USA]}

var data = yaml.Read(@"p:\test.yaml");
var address = (Dictionary<object, object>)data["Address"];
var street = address["Street"]
var city= address["City"]

var dic = yaml.ToOrderedDictionary(data["Address"]); //順序が保証された辞書として返す
var arr = yaml.ToArray(data["Address"]); // タプルの配列として返す

var dic = yaml.ToDictionary(data["Address"]); // 辞書として返す。(内部でCASTしているだけ)
var keys = yaml.GetKeys(data["Address"]);  // キーの一覧を配列で返す
var values = yaml.GetKeys(data["Address"]); // 値の一覧を配列で返す

var data = yaml.Read(@"p:\test.yaml");
var (List<object>)data["Tel"];

yaml.GetList(data["Tel"])

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

namespace CommonClass
{
    public class YamlUtil
    {
        /// <summary>
        /// 指定されたデータをYAML形式でファイルに書き込みます。
        /// </summary>
        /// <param name="filename">ファイル名</param>
        /// <param name="data">書き込むデータ（Dictionary<string, object>）</param>
        public void Write(string filename, Dictionary<object, object> data)
        {
            // YAMLシリアライザを作成
            var serializer = new SerializerBuilder()
                .WithNamingConvention(CamelCaseNamingConvention.Instance)
                .Build();

            // データをYAMLにシリアライズ
            var yaml = serializer.Serialize(data);

            // ファイルにYAMLを書き込み
            File.WriteAllText(filename, yaml);
        }

        /// <summary>
        /// 指定されたファイルからYAML形式のデータを読み込み、Dictionary<string, object>として返します。
        /// ファイルが存在しない場合は空のDictionaryを返します。
        /// </summary>
        /// <param name="filename">ファイル名</param>
        /// <returns>読み込んだYAMLデータを表すDictionary<string, object></returns>
        public Dictionary<object, object> Read(string filename)
        {
            // ファイルが存在しない場合は空のDictionaryを返す
            if (!File.Exists(filename))
            {
                return new Dictionary<object, object>();
            }

            // YAMLデシリアライザを作成
            var deserializer = new DeserializerBuilder()
                .WithNamingConvention(CamelCaseNamingConvention.Instance)
                .Build();

            // ファイルからYAMLを読み込み、Dictionary<string, object>にデシリアライズして返す
            var yaml = File.ReadAllText(filename);
            return deserializer.Deserialize<Dictionary<object, object>>(yaml);
        }

        /// <summary>
        /// 指定されたデータをYAML形式でファイルに書き込みます。
        /// </summary>
        /// <typeparam name="T">書き込むデータの型</typeparam>
        /// <param name="filename">ファイル名</param>
        /// <param name="data">書き込むデータ</param>
        public void Write<T>(string filename, T data)
        {
            // YAMLシリアライザを作成
            var reserializer = new SerializerBuilder().Build();

            // データをYAMLにシリアライズ
            var yaml = reserializer.Serialize(data);

            // ファイルにYAMLを書き込み
            File.WriteAllText(filename, yaml);
        }

        /// <summary>
        /// 指定されたファイルからYAML形式のデータを読み込み、指定された型（T）にデシリアライズして返します。
        /// </summary>
        /// <typeparam name="T">デシリアライズするデータの型</typeparam>
        /// <param name="filename">ファイル名</param>
        /// <returns>デシリアライズされたデータ</returns>
        public T Read<T>(string filename)
        {
            // YAMLデシリアライザを作成
            var reserializer = new DeserializerBuilder().Build();

            // ファイルからYAMLを読み込み、指定された型（T）にデシリアライズして返す
            var yaml = File.ReadAllText(filename);
            return reserializer.Deserialize<T>(yaml);
        }

        /// <summary>
        /// YAMLの配列を辞書に変換する
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>

        public Dictionary<object, object> ToDictionary(object array)
        {
            return (Dictionary<object, object>) array;
        }

        /// <summary>
        /// YAMLの配列をOrderedDictionary（登録順序が保証された辞書）に変換する
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>

        public OrderedDictionary ToOrderedDictionary(object array)
        {
            OrderedDictionary res = new OrderedDictionary();
            foreach (KeyValuePair<object, object> kvp in (Dictionary<object, object>)array)
            {
                res.Add(kvp.Key, kvp.Value);
            }
            return res;
        }

        /// <summary>
        /// YAMLの配列をTupleの配列に変換する
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public (object key, object value)[] ToArray(object array)
        {
            List<(object, object)> res = new List<(object, object)>();

            foreach (KeyValuePair<object, object> kvp in (Dictionary<object, object>)array)
            {
                res.Add((kvp.Key, kvp.Value));
            }

            return res.ToArray();
        }

        /// <summary>
        /// YAMLの配列からキーの一覧を取り出す
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public object[] GetKeys(object array)
        {
            return ToArray(array).Select(i => i.key.ToString()).ToArray()!;
        }

        /// <summary>
        /// YAMLの配列から値の一覧を取り出す
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public object[] GetValues(object array)
        {
            return ToArray(array).Select(i => i.value).ToArray()!;
        }

        /// <summary>
        /// 配列として定義されている内容をリストとして取り出す
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public List<object> GetList(object array)
        {
            return (List<object>)array;
        }
    }
}