var template = Template.Parse("Hello {{name}}!");
var result = template.Render(new { Name = "World" }); // => "Hello World!"

var obj = new
{
    Today = new { time = DateTime.Now, luckyNumber = 3.1415926525 },
};
 var temp = Template.Parse("当前时间：{{Today.time}}");
 var test = temp.Render(obj);
 // Cannot get the member Today.time for a null object

public class TemplateUtil
{
    /// <summary>
    /// 渲染模板
    /// </summary>
    /// <param name="template">模板内容</param>
    /// <param name="anonymousObject">匿名对象</param>

    public static string RenderTemplate(string template, object anonymousObject)
    {
        if (string.IsNullOrEmpty(template) || anonymousObject == null)
            return template;
        try
        {
            // 通过对象构建脚本对象示例
            var scriptObject = (ScriptObject)ToScriptObject(anonymousObject);
            // 解析模板
            var parsedTemplate = Template.Parse(template);
            // 创建模板引擎的执行上下文
            var context = new TemplateContext();
            // 将ScriptObject添加到模板的全局作用域中
            context.PushGlobal(scriptObject);
            // 解析错误就直接返回template
            if (parsedTemplate.HasErrors)
            {
                // 错误信息：parsedTemplate.Messages
                return template;
            }
            // 获取解析后的字符串
            var result = parsedTemplate.Render(context);
            return result;
        }
        catch
        {
            return template;
        }
    }

    /// <summary>
    /// 将匿名对象转换为Scriban可识别的ScriptObject【解决嵌套对象中非字符字段解析问题】
    /// </summary>
    /// <param name="anonymousObject">要转换的匿名对象</param>
    /// <returns>转换后的ScriptObject</returns>
    public static object ToScriptObject(object anonymousObject)
    {
        // 空值检查
        if (anonymousObject == null) return null;
        // 检查是否为JObject
        if (anonymousObject is JObject jObject)
        {
            return ConvertJObjectToScriptObject(jObject);
        }
        // 检查是否为JToken（处理JValue等）
        if (anonymousObject is JToken jToken)
        {
            return ConvertJTokenToObject(jToken);
        }
        // 创建新的 ScriptObject 来存储转换后的数据
        var scriptObject = new ScriptObject();
        // 获取匿名对象的实际类型
        var type = anonymousObject.GetType();
        // 通过反射获取对象的所有属性
        foreach (var property in type.GetProperties())
        {   // 获取属性值
            var value = property.GetValue(anonymousObject);
            // 保留模板中的原始属性，并将转换后的属性值添加到ScriptObject
            scriptObject[property.Name] = ConvertValue(value);
        }
        return scriptObject;
    }

    /// <summary>
    /// 将JObject转换为ScriptObject
    /// </summary>
    /// <param name="jObject">要转换的JObject</param>
    /// <returns>转换后的ScriptObject</returns>
    private static ScriptObject ConvertJObjectToScriptObject(JObject jObject)
    {
        var scriptObject = new ScriptObject();
        foreach (var property in jObject.Properties())
        {
            scriptObject[property.Name] = ConvertJTokenToObject(property.Value);
        }
        return scriptObject;
    }

    /// <summary>
    /// 将JToken转换object
    /// </summary>
    /// <param name="token">要转换的JToken</param>
    /// <returns>转换后的对象</returns>
    private static object ConvertJTokenToObject(JToken token)
    {
        if (token == null) return null;
        return token.Type switch
        {
            JTokenType.Object => ConvertJObjectToScriptObject((JObject)token),
            JTokenType.Array => ConvertJArrayToList((JArray)token),
            JTokenType.Integer => token.Value<long>(),
            JTokenType.Float => token.Value<double>(),
            JTokenType.String => token.Value<string>(),
            JTokenType.Boolean => token.Value<bool>(),
            JTokenType.Null => null,
            JTokenType.Date => token.Value<DateTime>(),
            JTokenType.Guid => token.Value<Guid>(),
            _ => token.ToString(),
        };
    }

    /// <summary>
    /// 将JArray转换为List
    /// </summary>
    /// <param name="jArray">要转换的JArray</param>
    /// <returns>转换后的列表</returns>
    private static List<object> ConvertJArrayToList(JArray jArray)
    {
        var list = new List<object>();
        foreach (var item in jArray)
        {
            list.Add(ConvertJTokenToObject(item));
        }
        return list;
    }

    /// <summary>
    /// 递归转换属性值
    /// 处理各种类型的值：基本类型、匿名对象、集合等
    /// </summary>
    /// <param name="value">要转换的值</param>
    /// <returns>转换后的值</returns>

    private static object ConvertValue(object value)
    {
        // 空值检查
        if (value == null) return null;
        // 获取值类型
        var valueType = value.GetType();
        // 检查是否为JObject
        if (value is JObject jObject)
        {
            return ConvertJObjectToScriptObject(jObject);
        }
        // 检查是否为JToken
        if (value is JToken jToken)
        {
            return ConvertJTokenToObject(jToken);
        }
        // 如果是匿名类型，递归转换
        if (valueType.IsClass && valueType.Name.Contains("AnonymousType"))
        {
            return ToScriptObject(value);
        }
        // 如果是数组或集合，就单独处理
        if (IsCollection(valueType))
        {
            return ConvertEnumerable(value);
        }
        // 直接返回值
        return value;
    }

    /// <summary>
    /// 判断是否为集合或数组
    /// </summary>
    private static bool IsCollection(Type type)
    {
        // 排除字符串（虽然字符串实现了 IEnumerable<char>，但通常不作为集合处理）
        if (type == typeof(string)) return false;
        // 1. 检查是否为数组
        if (type.IsArray)
        {
            return true;
        }
        // 2. 检查是否实现了 IEnumerable<> 泛型接口
        if (type.IsGenericType)
        {
            var interfaces = type.GetInterfaces();
            if (interfaces.Any(i =>
                i.IsGenericType &&
                i.GetGenericTypeDefinition() == typeof(IEnumerable<>)))
            {
                return true;
            }
        }
        // 3. 检查是否实现了非泛型 IEnumerable 接口
        if (typeof(IEnumerable).IsAssignableFrom(type))
        {
            return true;
        }
        return false;
    }

    /// <summary>
    /// 转换可枚举对象
    /// </summary>
    /// <param name="enumerable">要转换的可枚举对象</param>
    /// <returns>转换后的列表</returns>
    private static object ConvertEnumerable(object enumerable)
    {
        // 创建列表来存储转换后的元素
        var list = new List<object>();
        // 遍历原始集合中的每个元素
        foreach (var item in (IEnumerable)enumerable)
        {
            // 递归转换每个元素并添加到列表
            list.Add(ConvertValue(item));
        }
        return list;
    }
}

/// <summary>
/// 使用样例（仅支持匿名对象和JObject的渲染）
/// </summary>
public static void Test()
{
    // 匿名对象
    var obj = new
    {
        Name = "时分",
        Address = new { Province = "四川", City = "成都" },
        Today = new { time = DateTime.Now, luckyNumber = 3.1415926525 },
        Scores = new[] { 80, 85, 90 },
        爱好 = new
        {
            音乐 = "燕归巢",
            游戏 = "原神"
        }
    };
    // 文本处理
    var textTemplate = "你好，我是{{ Name }}。我目前居住在{{ Address['Province'] }}{{ Address.City }}，我喜欢听{{ 爱好.音乐 }}这首歌，偶尔玩玩{{ 爱好.游戏 }}";
    var text = TemplateUtil.RenderTemplate(textTemplate, obj);
    Console.WriteLine(text); // 你好，我是时分。我目前居住在四川成都，我喜欢听燕归巢这首歌，偶尔玩玩原神
    // 日期处理 时间参数不能是date，方法date.to_string冲突
    var dateTemplate = "当前时间: {{ Today.time | date.to_string '%Y-%m-%d' }}"; // Y(年)、m(月)、d(日)、H(时)、M(分)、S(秒)
    var date = TemplateUtil.RenderTemplate(dateTemplate, obj);
    Console.WriteLine(date); // 当前时间: 2025-11-13 17:15:06
    // 数字处理
    var number1 = TemplateUtil.RenderTemplate("{{ Today.luckyNumber | math.round 3 }}", obj); // 四舍五入并指定小数位数
    Console.WriteLine(number1); // 3.142
    var number2 = TemplateUtil.RenderTemplate("{{ Today.luckyNumber | math.format 'p2'}}", obj); // 百分数 P(n)表示保留n位小数
    Console.WriteLine(number2);  // 314.16 %
    // 循环处理
    var scoreTemplate = "分数列表:{{ for score in Scores }} {{ score }} 分 {{ end }}";
    var score = TemplateUtil.RenderTemplate(scoreTemplate, obj);
    Console.WriteLine(score); // 分数列表: 80 分  85 分  90 分

    // JObject对象
    var jobj = new JObject
    {
        ["Name"] = "时秒",
        ["Address"] = new JObject
        {
            ["Province"] = "四川",
            ["City"] = "成都",
        },
        ["座右铭"] = new JArray
            {
                new JObject
                {
                    ["Sentence"] = "长风破浪会有时，直挂云帆济沧海",
                    ["Author"] = "李白"
                },
                new JObject
                {
                    ["Sentence"] = "书中自有颜如玉，书中自有黄金屋",
                    ["Author"] = "赵恒"
                }
            }
    };
    var textTemplate2 = "你好，我是{{ Name }}。我目前居住在{{ Address['Province'] }}{{ Address.City }}。" +
        "我特别喜欢{{ for poem in 座右铭 }} {{ poem.Author }}的{{ poem.Sentence }} {{ end }}";
    var text2 = TemplateUtil.RenderTemplate(textTemplate2, jobj);
    Console.WriteLine(text2); // 你好，我是时秒。我目前居住在四川成都。我特别喜欢 李白的长风破浪会有时，直挂云帆济沧海  赵恒的书中自有颜如玉，书中自有黄金屋
}

var config1 = new {
    name = "Tom",
    age = 18
};

var config2 = new {
    age = 20,
    desc = "A student in high school",
    experience = new
    {
       first = "Grade 6 of primary school won the third prize in football",
       second = "I was the first in my class in the final exam of the third year of junior high school"
    }
}
var mergeConfig = TypeMerger.TypeMerger.Merge(config1, config2);
var configString = JsonConvert.SerializeObject(mergeConfig);
Console.WriteLine(configString);

var mergeConfig = TypeMerger.TypeMerger.Ignore(() => config1.age).Merge(config1, config2);
var configString = JsonConvert.SerializeObject(mergeConfig);
Console.WriteLine(configString);

/// <summary>
/// 使用SqlBulkCopy批量添加数据
/// </summary>
/// <param name="connStr">数据库连接字符串</param>
/// <param name="tableName">表名</param>
/// <param name="datas">数据</param>
/// <param name="batchSize">大小</param>
/// <param name="timeout">延迟</param>
public void BulkInsert<T>(string connStr, string tableName, IEnumerable<T> datas, int batchSize, int timeout)
{
    var dataList = new List<T>(datas);
    while (dataList.Count > 0)
    {
        // 计算当前批次的实际大小
        int currentBatchSize = Math.Min(batchSize, dataList.Count);
        // 获取当前批次的数据
        List<T> batchData = dataList.GetRange(0, currentBatchSize);
        using (var conn = new SqlConnection(connStr))
        {
            // 打开连接
            conn.Open();
            // 开始事务
            SqlTransaction tran = conn.BeginTransaction();
            try
            {
                // 创建 SqlBulkCopy 实例，并进行设置
                using (var bulkCopy = new SqlBulkCopy(conn, SqlBulkCopyOptions.Default, tran))
                {
                    bulkCopy.DestinationTableName = tableName;
                    bulkCopy.BatchSize = batchSize;
                    bulkCopy.BulkCopyTimeout = timeout;
                    // 启用流式传输
                    bulkCopy.EnableStreaming = true;
                    var properties = typeof(T).GetProperties().OrderBy(p => p.MetadataToken).ToArray();
                    foreach (var prop in properties)
                    {
                        bulkCopy.ColumnMappings.Add(prop.Name, prop.Name);
                    }
                    // 使用ObjectReader流式读取数据
                    using (var reader = ObjectReader.Create(batchData))
                    {
                        bulkCopy.WriteToServer(reader);
                    }
                }
                // 提交事务
                tran.Commit();
                // 成功提交后移除当前批次的数据
                dataList.RemoveRange(0, currentBatchSize);
            }
            catch
            {
                // 发生异常时回滚事务
                tran.Rollback();
                throw;
            }
        }
    }
}

public class User
{
    public Guid UserId { get; set; }
    public string Username { get; set; }
    public string Hobby { get; set; }
}

var users = new List<User>(){
new User(){UserId = Guid.NewGuid(), Username = "小一", Hobby = "旅游"},
new User(){UserId = Guid.NewGuid(), Username = "小二", Hobby = "散步"}
}
string connStr = GetConnectionString(); // 自行定义
BulkInsert(connStr, "dbo.user", users, 1000, 30);

public class UserInfo
{
    [JsonProperty("用户名")]
    public string Name { get; set; }
    [JsonProperty("年龄")]
    public string Age { get; set; }
}
var tom = new UserInfo{Name = 'Tom', Age = 20};
var jsonstr = JsonConvert.SerializeObject(tom);
var json = JsonConvert.DeserializeObject<UserInfo>(jsonstr);

public class JsonToChineseConverter<T> : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(T);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        JObject jsonObject = JObject.Load(reader);
        T targetObject = (T)Activator.CreateInstance(objectType);
        foreach (var property in objectType.GetProperties())
        {
            NameAttribute nameAttribute = property.GetCustomAttribute<NameAttribute>();
            string propertyName = nameAttribute != null ? nameAttribute.ChineseName : property.Name;
            if (jsonObject[propertyName] != null)
            {
                property.SetValue(targetObject, jsonObject[propertyName].ToObject(property.PropertyType, serializer));
            }
        }
        return targetObject;
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        JObject jsonObject = new JObject();
        Type objectType = value.GetType();
        foreach (var property in objectType.GetProperties())
        {
            NameAttribute nameAttribute = property.GetCustomAttribute<NameAttribute>();
            string propertyName = nameAttribute != null ? nameAttribute.ChineseName : property.Name;
            jsonObject[propertyName] = JToken.FromObject(property.GetValue(value), serializer);
        }
        jsonObject.WriteTo(writer);
    }
}

[AttributeUsage(AttributeTargets.Property)]
public class NameAttribute : Attribute
{
    public string ChineseName {
        get;
    }
    public NameAttribute(string chineseName)
    {
        ChineseName = chineseName;
    }
}

public class UserInfo
{
    [Name("用户名")]
    public string Name { get; set; }
    [Name("年龄")]
    public string Age { get; set; }
}
var tom = new UserInfo{Name = 'Tom', Age = 20};
var setting = new JsonToChineseConverter<UserInfo>();
var jsonstr = JsonConvert.SerializeObject(tom, setting);
var json = JsonConvert.DeserializeObject<UserInfo>(jsonstr, setting);
Console.WriteLine(jsonstr); // {"用户名":"Tom","年龄":20}