appendix FileHelper

using System;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;

public class Ini
{
    IDictionary<string, IDictionary<string, string>> dict=new Dictionary<string, IDictionary<string, string>>();
    public void Clear()
    {
        dict.Clear();
    }
    public void Set(string name,string key, string value)
    {
        if(!dict.ContainsKey(name))
            dict.Add(name,new Dictionary<string, string>());

        var tmp = dict[name];
        if (tmp.ContainsKey(key))
        {
            tmp[key] = value;
        }
        else
        {
            tmp.Add(key, value);
        }
    }
    public IDictionary<string,string> GetName(string name)
    {
        IDictionary<string, string> result;
        dict.TryGetValue(name, out result);
        return result;
    }

    public string GetValue(string name,string key)
    {
        if(dict.ContainsKey(name))
        {
            string result;
            dict[name].TryGetValue(key, out result);
            return result;
        }
        return string.Empty;
    }
    public string[] GetKeys(string name)
    {
        if (!dict.ContainsKey(name))
            return default;
        return dict[name].Keys.ToArray();
    }

    public bool Contains(string name)
    {
        return dict.ContainsKey(name);
    }
    public string[] GetNames()
    {
        return dict.Keys.ToArray();
    }
}

public static class FileHelper
{
    public static async Task WriteInitAsync(string path,Ini ini, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
    {
        try
        {
            StringBuilder stringBuilder = new StringBuilder();

            foreach(var name in ini.GetNames())
            {
                stringBuilder.AppendLine($"[{name}]");
                foreach(var item in  ini.GetName(name))
                {
                    stringBuilder.AppendLine($"{item.Key}={item.Value}");
                }
                if (cancellationToken.IsCancellationRequested)
                {
                    cancellationToken.ThrowIfCancellationRequested();
                }
            }
            if(stringBuilder.Length > 0)
            {
                stringBuilder.Length -= 2;
            }

            await WriteAllTextAsync(path, stringBuilder.ToString(), encoding, cancellationToken);
        }
        catch (Exception ex)
        {
            Log.Error($"{ex}");
        }
    }
    public static async Task<Ini> ReadIniAsync(string path, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
    {
        var text = await ReadTextAsync(path, encoding, cancellationToken);
        if (text.Length == 0)
            return default;

        try
        {
            var ini = new Ini();
            var lines = text.Split("\r\n");
            string name= string.Empty;
            bool isStart=false;
            foreach(var line in lines)
            {
                if (line.Length == 0)
                    continue;
                if (line.Contains('[') && line.Contains(']'))
                {
                    name = line.Trim();
                    name = name.Replace("[","");
                    name = name.Replace("]","");
                    isStart = true;
                }
                else if(isStart)
                {
                    var items = line.Split('=');
                    var key = items[0].Trim();
                    string value=string.Empty;
                    if(items.Length == 2)
                    {
                        value = items[1].Trim();
                    }
                    ini.Set(name,key,value);
                }
                if(cancellationToken.IsCancellationRequested)
                {
                    cancellationToken.ThrowIfCancellationRequested();
                }
            }
            
            return ini;
        }
        catch (Exception ex)
        {
            Log.Error($"{ex}");
            return default;
        }
    }
    public static async Task WriteCSVAsync(string path,List<List<string>> contents, char split, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
    {
        try
        {
            StringBuilder stringBuilder = new StringBuilder() ;
            foreach(var line in contents)
            {
                foreach (var col in line)
                {
                    stringBuilder.Append($"{col}{split}");
                }
                if(cancellationToken.IsCancellationRequested)
                {
                    cancellationToken.ThrowIfCancellationRequested();
                }
                if (line.Count > 0)
                {
                    stringBuilder.Length--;
                    stringBuilder.AppendLine();
                }
            }
            await WriteAllTextAsync(path, stringBuilder.ToString(), encoding, cancellationToken);
        }
        catch (Exception ex)
        {
            Log.Error($"{ex}");
        }
    }
    public static async Task<List<List<string>>> ReadCSVAsync(string path,char[] splits, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
    {
        var text =  await ReadTextAsync(path, encoding, cancellationToken);
        if (text.Length == 0)
            return default;
        try
        {
            List<List<string>> result = new List<List<string>>();
            foreach(var line in text.Split("\r\n"))
            {
                List<string> list = new List<string>();
                foreach(var col in line.Split(splits))
                {
                    list.Add(col);
                }
                if(cancellationToken.IsCancellationRequested)
                {
                    cancellationToken.ThrowIfCancellationRequested();
                }
                if (list.Count == 1 && list[0].Length == 0)
                    continue;
                result.Add(list);
            }
            return result;
        }
        catch (Exception ex)
        {
            Log.Error($"{ex}");
            return default;
        }
    }
    public static async Task WriteAllTextAsync(string path,string contents, CancellationToken cancellationToken = default(CancellationToken))
    {
        try
        {
            var dir = Path.GetDirectoryName(path);
            if (!Directory.Exists(dir))
                Directory.CreateDirectory(dir);

            await File.WriteAllTextAsync(path, contents, cancellationToken);
        }
        catch (Exception ex)
        {
            Log.Error($"{ex}");
            return;
        }
    }
    public static async Task WriteAllTextAsync(string path, string contents, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
    {
        try
        {
            var dir = Path.GetDirectoryName(path);
            if (!Directory.Exists(dir))
                Directory.CreateDirectory(dir);

            await File.WriteAllTextAsync(path, contents, encoding, cancellationToken);
        }
        catch (Exception ex)
        {
            Log.Error($"{ex}");
            return;
        }
    }

    public static async Task WriteAllTextAsync(string path, byte[] bytes, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
    {
        try
        {
            var dir = Path.GetDirectoryName(path);
            if (!Directory.Exists(dir))
                Directory.CreateDirectory(dir);

            await File.WriteAllBytesAsync(path, bytes, cancellationToken);
        }
        catch (Exception ex)
        {
            Log.Error($"{ex}");
            return;
        }
    }

    public static async Task<string> ReadTextAsync(string path, CancellationToken cancellationToken = default(CancellationToken))
    {
        try
        {
            if (!File.Exists(path))
                return default;

            return await File.ReadAllTextAsync(path, cancellationToken);
        }
        catch (Exception ex)
        {
            Log.Error($"{ex}");
            return default;
        }
    }

    public static async Task<string> ReadTextAsync(string path, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
    {
        try
        {
            if (!File.Exists(path))
                return default;

            return await File.ReadAllTextAsync(path, encoding, cancellationToken);
        }
        catch (Exception ex)
        {
            Log.Error($"{ex}");
            return default;
        }
    }

    public static async Task<byte[]> ReadAsync(string path, CancellationToken cancellationToken = default(CancellationToken))
    {
        try
        {
            if (!File.Exists(path))
                return default;

            return await File.ReadAllBytesAsync(path,cancellationToken);
        }
        catch(Exception ex)
        {
            Log.Error($"{ex}");
            return default;
        }
    }
}