目前我正在这样做：
我的文字看起来像：
Hello ${user.name}, this is ....
我这样做：
public string TransformUser(User user, string text)
{
StringBuilder sb = new StringBuilder(text);
sb.Replace("${user.name}", user.Name);
...
...
return sb.ToString();
}
有没有更好的方法，也许以某种方式使用反射来循环遍历类的公共属性？
编辑
是否有可能使这个方法通用，所以我可以将任何对象传递给它？
使用反射遍历所有属性并替换字符串中的键大致如下所示：
var args = new object[0];
foreach(var prop in typeof(User).GetProperties()) {
if (prop.CanRead) {
string val = prop.GetGetMethod().Invoke(user, args).ToString();
sb.Replace("${user." + prop.Name +"}", val);
}
}
它用于CanRead检查属性是否具有 getter，然后调用 getter 来读取值。一个值被简单地转换为字符串ToString，这可能适用于原始类型（取决于所需的行为）。这是区分大小写的，因此ToLower如果用户使用小写（如您的示例）编写密钥，您可能希望使用。
我写了一个StringTemplate类，它可能会根据您的需要进行修改...它的行为类似于String.Format，但有一个主要区别：您可以使用名称作为占位符，而不是索引。要格式化的值可以指定为 aIDictionary<string, object>或任何对象（在这种情况下，每个占位符将替换为具有相同名称的属性的值）。
例如 ：
// with a dictionary :
var values = new Dictionary<string, object>
{
{ "Title", "Mr." },
{ "LastName", "Smith" }
};
string a = StringTemplate.Format("Hello {Title} {LastName}", values);
// with an anonymous type :
string b = StringTemplate.Format(
"Hello {Title} {LastName}",
new { Title = "Mr.", LastName = "Smith" });
如果您需要多次使用同一个模板，您可以创建一个实例StringTemplate并重用它以获得更好的性能（模板字符串只会被解析一次）。
您还可以指定格式修饰符，例如 in String.Format。
为了满足您的确切需求，本课程需要进行一些调整，但应该不会太难......
这是代码：
public class StringTemplate
{
private string _template;
private static Regex _regex = new Regex(@"(?<open>{+)(?<key>\w+)(?<format>:[^}]+)?(?<close>}+)", RegexOptions.Compiled);
public StringTemplate(string template)
{
template.CheckArgumentNull("template");
this._template = template;
ParseTemplate();
}
private string _templateWithIndexes;
private List<string> _placeholders;
private void ParseTemplate()
{
_placeholders = new List<string>();
MatchEvaluator evaluator = (m) =>
{
if (m.Success)
{
string open = m.Groups["open"].Value;
string close = m.Groups["close"].Value;
string key = m.Groups["key"].Value;
string format = m.Groups["format"].Value;
if (open.Length % 2 == 0)
return m.Value;
open = RemoveLastChar(open);
close = RemoveLastChar(close);
if (!_placeholders.Contains(key))
{
_placeholders.Add(key);
}
int index = _placeholders.IndexOf(key);
return string.Format("{0}{{{1}{2}}}{3}", open, index, format, close);
}
return m.Value;
};
_templateWithIndexes = _regex.Replace(_template, evaluator);
}
private string RemoveLastChar(string str)
{
if (str.Length > 1)
return str.Substring(0, str.Length - 1);
else
return string.Empty;
}
public static implicit operator StringTemplate(string s)
{
return new StringTemplate(s);
}
public override string ToString()
{
return _template;
}
public string Format(IDictionary<string, object> values)
{
values.CheckArgumentNull("values");
object[] array = new object[_placeholders.Count];
for(int i = 0; i < _placeholders.Count; i++)
{
string key = _placeholders[i];
object value;
if (!values.TryGetValue(key, out value))
{
value = string.Format("{{{0}}}", key);
}
array[i] = value;
}
return string.Format(_templateWithIndexes, array);
}
private IDictionary<string, object> MakeDictionary(object obj)
{
Dictionary<string, object> dict = new Dictionary<string, object>();
Type type = obj.GetType();
foreach (string propName in _placeholders)
{
var prop = type.GetProperty(propName);
if (prop != null)
dict.Add(propName, prop.GetValue(obj, null));
}
return dict;
}
public string Format(object values)
{
return Format(MakeDictionary(values));
}
public static string Format(string template, IDictionary<string, object> values)
{
return new StringTemplate(template).Format(values);
}
public static string Format(string template, object values)
{
return new StringTemplate(template).Format(values);
}
}
您可以通过调用来遍历属性typeof(User).GetProperties()。