你能避免在记忆通用方法中拆箱吗？

Question

我有一个通用方法，用于将数据库中的字符串值转换为实际转换值。

public MySpecialValue {
    object val;
    bool valSet = false; 

    T GetValue<T> () { 
         if (!valSet)
         {
                val = (T)Convert.ChangeType(DatabaseValue, typeof(T));
                valSet = true;
         }
         return (T)val;
     }

     public string DatabaseValue { get; set; }
}

问题是在初始化期间我不知道数据库中的数据是什么类型，只有在第一次调用时我才能做出这个决定。

有没有什么方法可以构造它，使其不会被强制拆箱缓存的值类型？ （不改变包含类的签名）

Answer 1

您提供的代码有些奇怪。 “DoSomethingExpensive”如何知道为任意 T 返回一个 T ？这对我来说毫无意义。

您通常编写通用记忆器的方式是这样的：

public static Func<T> Memoize(this Func<T> func)
{
    bool executed = false;
    T result = default(T);
    Func<T> memoized = ()=> 
    {
        if (!executed)
        {
            result = func();
            executed = true;
        }
        return result;
    };
    return memoized;
}

现在你可以说：

Func<int> expensive = DoSomethingExpensiveThatGetsAnInt;
Func<int> memoized = expensive.Memoize();

你就完成了。不需要拳击。

Answer 2

如果 T 和 Convert.ChangeType 的结果是引用类型，则不会拆箱。

如果Convert.ChangeType 返回一个装箱的值类型，而 T 是一个值类型，那么如果你想让 GetValue 返回 T，你就无法避免拆箱。

Answer 3

考虑为此使用Lazy<T>。

因此，如果您有某种属性集合。

public class MyClass 
{
...
}

Public class MyClass<T> : MyClass
{
  T val;
  bool valSet; 
  public T GetValue<T> () { 
        if (!valSet)
        {
            val = (T)Convert.ChangeType(DatabaseValue, typeof(T))};
            valSet = true;
        }
        return val;
    }
}

大概你的父类中有一个泛型方法

class SomePropertyBag{

private Dictionary<string, MyClass> dict;

T GetValue<T>(string name, T default)
{
  MyClass res;
  if(!dict.TryGetValue(out res))
  {
     res = new MyClass<T>(name);
     dict.Add(name, res);
  }
  return ((MyClass<T>)res).GetValue();
}

Answer 4

我愿意打赌（好吧，我也有源代码的优势......）在大多数情况下，这个代码是根据你在your reply中的示例调用的

Get("Site.Twitter.AccountName", "")

或

Get("Site.Twitter.AccountName", 77)

在这种情况下，您使用的是泛型类型推断。但是还有另一个更简单的东西可以在那里编译...不要使用泛型。我希望这里只有几个场景；所以编写一些类/方法重载 - 一个用于string，一个用于int，等等。

string Get(string key, string defaultValue) {...}
int Get(string key, int defaultValue) {...}
bool Get(string key, bool defaultValue) {...}

当然，会有一点重复，但编译器将能够针对每个单独的场景进行优化 - 没有装箱。您甚至可以（如果您选择）将Convert.ChangeType 替换为int.Parse 之类的东西（对于T = int 的情况）。

---

另一种选择（根据您的示例）是使记忆对象通用：

public MySpecialValue<T> {
    T val;
    bool valSet = false; 

    T GetValue() { 
         if (!valSet)
         {
                val = (T)Convert.ChangeType(DatabaseValue, typeof(T));
                valSet = true;
         }
         return val;
     }

     public string DatabaseValue { get; set; }
}

然后将<T> 代码提升一个级别，这样就可以在强制转换中完成。

Answer 5

这使得值类型的东西稍微快一点（没有拆箱）......而对于 ref 类型的额外调用则稍微慢一点......但是有点奇怪。

 class MyClass {
    class Container<T>
    {
        public T Value { get; set; }
    }

    bool valSet;
    object val; 

    public T GetValue<T> () { 
        if (!valSet)
        {
            val = new Container<T>{Value =  (T)Convert.ChangeType(DatabaseValue, typeof(T))};
            valSet = true;
        }
        return ((Container<T>)val).Value;
    }

    public string DatabaseValue { get; set; }
 }