如何动态替换电子邮件模板中的占位符

问题描述 投票：0回答：4

有没有一个用动态数据替换占位符的好方法？ 我尝试加载模板，然后用元对象中的数据替换所有 {{PLACEHOLDER}} 标签，这是有效的。 但是，如果我需要添加更多占位符，我必须在代码中完成，并进行新的部署，所以如果可能的话，我想通过数据库来完成，如下所示：

Table Placeholders
ID, Key (nvarchar(50),  Value (nvarchar(59))
1   {{RECEIVER_NAME}}   meta.receiver
2   {{RESOURCE_NAME}}   meta.resource
3 ..
4 .. and so on

meta 是发送到 BuildTemplate 方法的参数名称。

因此，当我循环遍历所有占位符（来自数据库）时，我想将值从数据库转换为元对象。 我不需要获取“meta.receiver”，而是需要参数内的值。

GetAllAsync ex.1

public async Task<Dictionary<string, object>> GetAllAsync()
{
     return await _context.EmailTemplatePlaceholders.ToDictionaryAsync(x => x.PlaceholderKey, x => x.PlaceholderValue as object);
}

GetAllAsync ex.2

public async Task<IEnumerable<EmailTemplatePlaceholder>> GetAllAsync()
{
     var result = await _context.EmailTemplatePlaceholders.ToListAsync();
     return result;
}

示例不使用数据库（工作））

private async Task<string> BuildTemplate(string template, dynamic meta)
{
    var sb = new StringBuilder(template);

    sb.Replace("{{RECEIVER_NAME}}", meta.receiver?.ToString());
    sb.Replace("{{RESOURCE_NAME}}", meta.resource?.ToString());    

    return sb.ToString();
}

我希望它如何工作

private async Task<string> BuildTemplate(string template, dynamic meta)
{
    var sb = new StringBuilder(template);

    var placeholders = await _placeholders.GetAllAsync();

    foreach (var placeholder in placeholders)
    {           
        // when using reflection I still get a string like "meta.receiver" instead of meta.receiver, like the object.
        // in other words, the sb.Replace methods gives the same result.
        //sb.Replace(placeholder.Key, placeholder.Value.GetType().GetField(placeholder.Value).GetValue(placeholder.Value));
        sb.Replace(placeholder.Key, placeholder.Value);
    }  

    return sb.ToString();
}

我认为这可能是解决这个问题的更好方法。请告诉我！

c# .net entity-framework dynamic property-placeholder
4个回答
4
投票

我们在开发中已经解决了类似的问题。

我们创建了扩展来格式化任何对象。

请查看我们的源代码：

public static string FormatWith(this string format, object source, bool escape = false)
{
    return FormatWith(format, null, source, escape);
}

public static string FormatWith(this string format, IFormatProvider provider, object source, bool escape = false)
{
    if (format == null)
        throw new ArgumentNullException("format");

    List<object> values = new List<object>();
    var rewrittenFormat = Regex.Replace(format,
        @"(?<start>\{)+(?<property>[\w\.\[\]]+)(?<format>:[^}]+)?(?<end>\})+",
        delegate(Match m)
        {
            var startGroup = m.Groups["start"];
            var propertyGroup = m.Groups["property"];
            var formatGroup = m.Groups["format"];
            var endGroup = m.Groups["end"];

            var value = propertyGroup.Value == "0"
                ? source
                : Eval(source, propertyGroup.Value);

            if (escape && value != null)
            {
                value = XmlEscape(JsonEscape(value.ToString()));
            }

            values.Add(value);

            var openings = startGroup.Captures.Count;
            var closings = endGroup.Captures.Count;

            return openings > closings || openings%2 == 0
                ? m.Value
                : new string('{', openings) + (values.Count - 1) + formatGroup.Value
                  + new string('}', closings);
        },
        RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);

    return string.Format(provider, rewrittenFormat, values.ToArray());
}

private static object Eval(object source, string expression)
{
    try
    {
        return DataBinder.Eval(source, expression);
    }
    catch (HttpException e)
    {
        throw new FormatException(null, e);
    }
}

使用方法非常简单：

var body = "[{Name}] {Description} (<a href='{Link}'>See More</a>)";
var model = new { Name="name", Link="localhost", Description="" };
var result = body.FormatWith(model);
0
投票

你想这样做：

sb.Replace(placeholder.Key, meta.GetType().GetField(placeholder.Value).GetValue(meta).ToString())

并且您的数据库将只存储 

meta.reciever
，而不是
receiver

这样，数据库中指定的占位符将替换为元对象中的相应值。缺点是您只能使用此方法从元对象中提取值。然而，据我所知，这对你来说似乎不是问题，所以这可能并不重要。

更多说明：您所尝试的问题

//sb.Replace(placeholder.Key, placeholder.Value.GetType().GetField(placeholder.Value).GetValue(placeholder.Value));

首先，您尝试获取整个字符串

meta.reciever
的类型，而不仅仅是
meta
部分，但此外，似乎没有从字符串到类类型的转换（例如
Type.GetType("meta")
）。此外，当您 GetValue 时，没有从字符串到您需要的对象的转换（不知道会是什么样子）。

0
投票

由于您希望动态替换模板中的所有占位符，而不是手动一一替换。所以我认为正则表达式更适合这些事情。

此函数将获取一个您想要插入的模板以及一个您想要与模板绑定的对象。此功能将自动替换您的占位符，例如 {{RECEIVER_NAME}} 与对象中的值。 您将需要一个包含要绑定的所有属性的类。在此示例中，类是 MainInvoiceBind。

    public static string Format(string obj,MainInvoiceBind invoice)
    {
        try
        {
            return Regex.Replace(obj, @"{{(?<exp>[^}]+)}}", match =>
            {
                try
                {
                    var p = Expression.Parameter(typeof(MainInvoiceBind), "");
                    var e = System.Linq.Dynamic.DynamicExpression.ParseLambda(new[] { p }, null, match.Groups["exp"].Value);
                    return (e.Compile().DynamicInvoke(invoice) ?? "").ToString();
                }
                catch
                {
                    return "Nill";
                }

            });
        }
        catch
        {
            return string.Empty;
        }
    }

我在一个项目中实现了这项技术，我必须从指定的模板动态生成电子邮件。它对我来说很有用。希望它能解决您的问题。

0
投票

我将 habib 的解决方案更新为最新的 

System.Linq.Dynamic.Core
NuGet 包，并进行了一些小改进。

此函数会自动将 {{RECEIVER_NAME}} 等占位符替换为对象中的数据。您甚至可以使用一些运算符，因为它使用 Linq。

public static string Placeholder(string input, object obj)
{
    try {
        var p = new[] { Expression.Parameter(obj.GetType(), "") };

        return Regex.Replace(input, @"{{(?<exp>[^}]+)}}", match => {
            try {
                return DynamicExpressionParser.ParseLambda(p, null, match.Groups["exp"].Value)
                  .Compile().DynamicInvoke(obj)?.ToString();
            }
            catch {
                return "(undefined)";
            }
        });
    }
    catch {
        return "(error)";
    }
}

您还可以使多个对象可访问并为其命名。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.