参考字典值

Question

在我们的应用程序中，我们有一些来自翻译的字符串可以包含变量。例如在Can i have a {beverage}?中{beverage}部分应该用变量替换。 我的当前实现通过使用所有变量的名称和值的字典，并只替换正确的字符串。不过，我想通过引用来注册变量，以便如果值被更改，结果字符串也会被更改。通常传递一个带有ref关键字的参数可以做到这一点，但我不确定如何将这些参数存储在字典中。

TranslationParser：

static class TranslationParser 
{ 
    private const string regex = "{([a-z]+)}"; 
    private static Dictionary<string, object> variables = new Dictionary<string,object>(); 

    public static void RegisterVariable(string name, object value) 
    { 
     if (variables.ContainsKey(name)) 
      variables[name] = value; 
     else 
      variables.Add(name, value); 
    } 

    public static string ParseText(string text) 
    { 
     return Regex.Replace(text, regex, match => 
     { 
      string varName = match.Groups[1].Value; 

      if (variables.ContainsKey(varName)) 
       return variables[varName].ToString(); 
      else 
       return match.Value; 
     }); 
    } 
} 

main.cs

 string bev = "cola"; 
     TranslationParser.RegisterVariable("beverage", bev); 
     //Expected: "Can i have a cola?" 
     Console.WriteLine(TranslationParser.ParseText("Can i have a {beverage}?")); 
     bev = "fanta"; 
     //Expected: "Can i have a fanta?" 
     Console.WriteLine(TranslationParser.ParseText("Can i have a {beverage}?")); 

这是不可能的，还是我只是接近正确的问题？我担心唯一的解决方案会涉及不安全的代码（指针）。

因此，简而言之，我想将一个变量存储在字典中，更改原始变量并从字典中获取已更改的值。就像你会用ref关键字一样。

Answer 1

使用包装的另一种方式。每次注册时都可以包装变量。

class ObjectWrapper 
{ 
    private object _value; 

    public ObjectWrapper(object value) 
    { 
     _value = value; 
    } 

    public override string ToString() 
    { 
     return _value.ToString(); 
    } 
} 

static class TranslationParser 
{ 
    private const string regex = "{([a-z]+)}"; 
    private static Dictionary<string, ObjectWrapper> variables = new Dictionary<string, ObjectWrapper>(); 

    public static void RegisterVariable(string name, object value) 
    { 
     var wrapped = new ObjectWrapper(value); 
     if (variables.ContainsKey(name)) 
      variables[name] = wrapped; 
     else 
      variables.Add(name, wrapped); 
    } 

    public static string ParseText(string text) 
    { 
     return Regex.Replace(text, regex, match => 
     { 
      string varName = match.Groups[1].Value; 

      if (variables.ContainsKey(varName)) 
       return variables[varName].ToString(); 
      else 
       return match.Value; 
     }); 
    } 
} 

编辑：

但实际上，我认为这是没有不安全的代码无法跟踪你想要做的方式变量。值类型和对存储在堆栈中的引用类型的引用，如果您只是替换引用，它不会影响堆中的实际对象（引用您存储在字典中的对象）。所以你需要有引用（比如指针）来堆栈内存。

再次编辑：我错了！

它可以跟踪任何使用varaible表达式：

class Wrapper 
{ 
    private readonly Dictionary<string, MemberExpression> _registrations = 
     new Dictionary<string, MemberExpression>(); 

    public void Register<T>(string name, Expression<Func<T>> expr) 
    { 
     _registrations[name] = (MemberExpression)expr.Body; 
    } 

    public object GetValue(string name) 
    { 
     var expr = _registrations[name]; 
     var fieldInfo = (FieldInfo)expr.Member; 
     var obj = ((ConstantExpression)expr.Expression).Value; 
     return fieldInfo.GetValue(obj); 
    } 
} 
private static void Main(string[] args) 
{ 
    var wrapper = new Wrapper(); 
    int x = 0; 
    storage.Register("x",() => x); 
    Console.WriteLine(wrapper.GetValue("x")); //0 
    x = 1; 
    Console.WriteLine(wrapper.GetValue("x")); //1 
} 

Answer 2

在提供的代码我看到

string bev = "cola"; 
TranslationParser.RegisterVariable("beverage", bev); 
//Expected: "Can i have a cola?" 
Console.WriteLine(TranslationParser.ParseText("Can i have a {beverage}?")); 
bev = "fanta"; 
//Expected: "Can i have a fanta?" 

是第一你regitser的{饮料}的分别代替像"cola"，但要在运行时改变它到另一个后："fanta"。 Thie引导我思考：为什么不只是一个ParseText函数来接受一个可选参数，这将会对已保存的参数“获胜”？

像这样：

public static string ParseText(string text, string preferedValue=null) 
{ 
     return Regex.Replace(text, regex, match => 
     { 
      string varName = match.Groups[1].Value; 

      if (variables.ContainsKey(varName)) 
      { 
       if(!string.IsNullOrEmpty(preferedValue)) //IF THERE ISPREFERED VALUE               
         return preferedValue;    //RETURN THAT ONE 

       return variables[varName].ToString(); 
      } 
      else 
       return match.Value; 
     }); 
}