string.Format()のDictionary対応

var now = DateTime.Now;
 
// 従来方式
var text1 = string.Format("{0}年{1:d2}月{2:d2}日", now.Year, now.Month, now.Day);
 
// 文字列補間による記述
var text2 = $"{now.Year}年{now.Month:d2}月{now.Day:d2}日");

public class FormatDictionary : Dictionary<string, object>
{
    public FormatDictionary()
        : base() { }
    public FormatDictionary(IEqualityComparer<string> comparer)
        : base(comparer) { }
    public FormatDictionary(IDictionary<string, object> dictionary)
        : base(dictionary) { }
    public FormatDictionary(int capacity)
        : base(capacity) { }
    public FormatDictionary(IDictionary<string, object> dictionary, IEqualityComparer<string> comparer)
        : base(dictionary, comparer) { }
    public FormatDictionary(int capacity, IEqualityComparer<string> comparer)
        : base(capacity, comparer) { }
}
 
public static class StringExtension
{
    #region 内部クラス
    private struct Formatter
    {
        public string format(string str, IDictionary<string, object> args, bool useOption)
        {
            clear();
 
            var length = str.Length;
 
            var begin = 0;
            var left = -1;
            var right = -1;
            var nameEnd = -1;
 
            // {key[,alignment][:formatString]}形式のパース
            for(var i = 0; i < length; ++i) {
                var c = str[i];
 
                switch(c) {
                case '{':
                    // 左波括弧の連続はエスケープなのでそのまま通過
                    if(left >= 0 && left == i - 1) {
                        left = -1;
                        continue;
                    }
 
                    left = i;
                    nameEnd = -1;
                    break;
                case '}':
                    // 右波括弧の連続はエスケープなのでそのまま通過
                    if(right >= 0 && right == i - 1) {
                        right = -1;
                        continue;
                    }
 
                    // フォーマット引数の処理
                    if(left >= 0) {
                        right = i;
 
                        // 前方部分文字列の反映
                        append(str.Substring(begin, left - begin + 1));
 
                        // 引数名の取得
                        var nameBegin = left + 1;
                        if(nameEnd < 0) {
                            nameEnd = i;
                        }
                        var key = str.Substring(nameBegin, nameEnd - nameBegin);
 
                        // 引数名をインデックスに変換して反映
                        var index = toIndex(key);
                        if(index == null) {
                            index = addArg(key, args[key]);
                        }
                        append(index);
 
                        // オプションがあれば反映
                        if(useOption && nameEnd < right) {
                            var option = str.Substring(nameEnd, right - nameEnd);
                            append(option);
                        }
 
                        // 閉じ括弧の反映
                        append("}");
 
                        begin = i + 1;
                        left = right = nameEnd = -1;
                        continue;
                    }
 
                    right = i;
                    break;
                case ',':
                case ':':
                    // 引数名の処理中であれば引数名の終了位置として記憶
                    if(useOption && left >= 0 && nameEnd < 0) {
                        nameEnd = i;
                    }
                    break;
                }
            }
 
            // 末尾の追加
            if(begin > 0 && begin < length) {
                append(str.Substring(begin, length - begin));
            }
 
            // フォーマット実行
            if(_list != null) {
                var format = string.Concat(_list.ToArray());
                _cache = format.format(getArgs());
            }
            else {
                _cache = str.format();
            }
 
            return _cache;
        }
 
        public override string ToString()
        {
            return _cache;
        }
 
        private void append(string str)
        {
            if(str.isNullOrEmpty()) return;
 
            // 必要になって初めてアロケート
            if(_list == null) {
                _list = new List<string>();
            }
 
            _list.Add(str);
        }
 
        private string toIndex(string key)
        {
            if(key.isNullOrEmpty()) return null;
            if(_indexes == null) return null;
 
            string index;
            if(_indexes.TryGetValue(key, out index)) {
                return index;
            }
 
            return null;
        }
 
        private string addArg(string key, object value)
        {
            // 必要になって初めてアロケート
            if(_indexes == null) {
                _indexes = new Dictionary<string, string>();
            }
            if(_args == null) {
                _args = new List<object>();
            }
 
            _args.Add(value);
 
            var index = (_args.Count - 1).ToString();
            _indexes[key] = index;
 
            return index;
        }
 
        private object[] getArgs()
        {
            if(_args != null) {
                return _args.ToArray();
            }
            return null;
        }
 
        private void clear()
        {
            if(_list != null) _list.Clear();
            if(_args != null) _args.Clear();
            if(_indexes != null) _indexes.Clear();
 
            _cache = "";
        }
 
        private List<string> _list;
 
        private List<object> _args;
        private Dictionary<string, string> _indexes;
 
        private string _cache;
    }
    #endregion
 
    #region 叙述
    public static bool isNullOrEmpty(this string str)
    {
        return string.IsNullOrEmpty(str);
    }
    #endregion
 
    #region 書式指定
    public static string format(this string str, params object[] args)
    {
        return string.Format(str, args);
    }
 
    public static string formatByName(this string str, IDictionary<string, object> args, bool useOption = true)
    {
        var formatter = new Formatter();
        return formatter.format(str, args, useOption);
    }
    #endregion
}

var now = DateTime.Now;
var args = new FormatDictionary {
    { "year", now.Year },
    { "month", now.Month },
    { "day", now.Day },
};
var text = "{year}年{month:d2}月{day:d2}日".formatByName(args);

var now = DateTime.Now;
var args = new FormatDictionary {
    ["year"] = now.Year,
    ["month"] = now.Month,
    ["day"] = now.Day,
};
var text = "{year}年{month:d2}月{day:d2}日".formatByName(args);