C# 在所有对象属性上进行文本转换，有更好的方法吗？

目前我正在这样做：

我的文本看起来像：

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();
}

有没有更好的方法，也许以某种方式使用反射来循环类的公共属性

编辑

---

是否可以将此方法设置为通用方法，以便我可以将任何对象传递给它？

您可以通过调用

typeof（User.GetProperties（）

通过反射循环所有属性，并替换字符串中的键，大致如下所示：

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

，主要区别在于：可以使用名称作为占位符，而不是索引。要格式化的值可以指定为

IDictionary

，也可以指定为任何对象（在这种情况下，每个占位符都将替换为具有相同名称的属性值）

例如：

// 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" });

---

您也可以使用prop.GetValue（user，null）而不是prop.getMethod（）。调用（…）是否可以将其包装到接受任何对象的方法中？@Fadrian:谢谢，这是一个好建议@布兰克曼：是的，它可以处理任何物体。将其包装到泛型方法中并使用

typeof（T）

（如果对象类型在编译时已知），或者在运行时使用

user.GetType（）

获取类型为

object

的当前参数类型。

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);
    }
}