C＃ - 任何类似于boost :: any的东西？

Question

我有哪里的要求：1。 我需要存储在列表中的任何类型的对象 2.避免铸造呼吁尽可能

为此我试图来的东西。无论我尝试过什么，我都无法摆脱拳击\拆箱。我想知道你们中是否有人遇到过能够实现这一目标的事情。

我创建的类几乎没有用处，除非您处理的是小集合，因为在内存和性能方面它需要1.5倍ArrayList。我试图找到改善其中至少一个的方法（最好是性能）。

任何反馈意见。

public class Castable 
    { 
     Object _o; 

     public override bool Equals(object obj) { return base.Equals(obj); } 

     public override int GetHashCode() { return base.GetHashCode(); } 

     public bool Equals<T>(T obj) 
     { 
      T v1 = (T)this._o; 
      //T v2 = obj; 
      //var v2 = obj; // Convert.ChangeType(obj, obj.GetType()); 

      // This doesn't work.. (Cannot convert T to Castable 
      //var v2 = Convert.ChangeType(this.GetType() == obj.GetType() ? 
      //((Castable)obj)._o.GetType(), obj.GetType()); 

      //if (((T)this._o) != obj) //<== why this doesn't work? 
      //if (v1 == obj) //<== "Operator '==' cannot be applied to operands of type 'T' and 'T'" 
      if(v1.Equals(obj)) 
      { 
       return true; 
      } 

      return false; 
     } 

     public bool Equals(Castable obj) 
     { 
      var v = Convert.ChangeType(obj._o, obj._o.GetType()); 
      return Equals(v); 
     } 


     public static bool operator ==(Castable a, Castable b) 
     { 
      return a.Equals(b); 
     } 

     public static bool operator !=(Castable a, Castable b) 
     { 
      return !a.Equals(b); 
     } 

     #region HOW CAN WE USE GENRIC TYPE FOR == and != OPERATOR? 
     public static bool operator ==(Castable a, object b) 
     { 
      return a.Equals(b); 
     } 

     public static bool operator !=(Castable a, object b) 
     { 
      return !a.Equals(b); 
     } 
     #endregion 

     public void Set<T>(T t) { _o = t; } 

     public T Get<T>() { return (T)_o; } 

     public static long TestLookup(IList list, int elements, int lookups) 
     { 
      object value; 
      Stopwatch watch = new Stopwatch(); 
      watch.Start(); 
      for (long index = 0; index < lookups; ++index) 
      { 
       value = list[random.Next(0, elements - 1)]; 
      } 
      watch.Stop(); 

      return watch.ElapsedMilliseconds; 
     } 

     public static long TestCompare(IList list, int elements, int lookups) 
     { 
      //object value; 
      bool match; 
      Stopwatch watch = new Stopwatch(); 
      watch.Start(); 
      for (long index = 0; index < lookups; ++index) 
      { 
       match = random.Next() == (int)list[random.Next(0, elements - 1)]; 
      } 
      watch.Stop(); 

      return watch.ElapsedMilliseconds; 
     } 

     public static long TestCompareCastable(IList<Castable> list, int elements, int lookups) 
     { 
      //object value; 
      bool match; 
      Stopwatch watch = new Stopwatch(); 
      watch.Start(); 
      for (long index = 0; index < lookups; ++index) 
      { 
       match = list[random.Next(0, elements - 1)] == random.Next(); //most of the times 1.4 times 
       //match = list[random.Next(0, elements - 1)].Equals(random.Next()); // may be 1.3 times ArrayList 
      } 
      watch.Stop(); 

      return watch.ElapsedMilliseconds; 
     } 


     public static void Test(int elements, int lookups, int times) 
     { 
      List<int> intList = new List<int>(); 
      List<Castable> castableList = new List<Castable>(); 
      ArrayList intArrayList = new ArrayList(); 

      if (Stopwatch.IsHighResolution) 
       Console.WriteLine("We have a high resolution timer available"); 

      long frequency = Stopwatch.Frequency; 
      Console.WriteLine(" Timer frequency in ticks per second = {0}", frequency); 

      for (int index = 0; index < elements; ++index) 
      { 
       intList.Add(random.Next()); 
       intArrayList.Add(random.Next()); 
       Castable c = new Castable(); 
       c.Set(random.Next()); 
       castableList.Add(c); 
      } 

      long ms = 0; 


      string result = ""; 
      string ratios = ""; 
      for (int time = 0; time < times; ++time) 
      { 
       ms = TestLookup(intList, elements, lookups); 
       result += "intList Lookup Time " + ms.ToString() + " MS\n"; 
       ms = TestLookup(castableList, elements, lookups); 
       result += "intArrayList Lookup Time " + ms.ToString() + " MS\n"; 
       ms = TestLookup(intArrayList, elements, lookups); 
       result += "castableList Lookup Time " + ms.ToString() + " MS\n"; 

       ms = TestCompare(intList, elements, lookups); 
       result += "intList Compare Time " + ms.ToString() + " MS\n"; 
       long msarraylist = ms = TestCompare(intArrayList, elements, lookups); 
       result += "intArrayList Compare Time " + ms.ToString() + " MS\n"; 
       ms = TestCompareCastable(castableList, elements, lookups); 
       result += "castableList Compare Time " + ms.ToString() + " MS\n"; 
       ratios += String.Format("round: {0}, ratio: {1}\n", time, (float)ms/msarraylist); 
      } 

      //MessageBox.Show(result); 
      MessageBox.Show(ratios); 


      int i = 10; 
      Castable o1 = new Castable(); 
      o1.Set(i); 
      int j = 10; 
      Castable o2 = new Castable(); 
      o2.Set(j); 
      if (!o1.Equals(10)) 
      { 
       Console.WriteLine("unequal"); 
      } 

      if (!o1.Equals(o2)) 
      { 
       Console.WriteLine("unequal"); 
      } 

      if (o1 != j) 
      { 
       Console.WriteLine("unequal"); 
      } 

      int x = o1.Get<int>(); 

     } 

    } 

编辑

总之我想实现：

@ winSharp93：是的，在短： 列表GenericGenericCollection =新名单（）;
GenericGenericCollection.Add（新字符串（ “十四行诗”）;
GenericGenericCollection.Add（42）;
GenericGenericCollection.Add（新MyOwnCustomType）;

再次编辑

有两种我发现的方法： 1.在.NET 4中引入了一个新的'dynamic'关键字，如果用dynamic _o;代替行Object _o;，您可以照原样使用代码。问题是虽然动态应该是动态的类型，性能就像拳击..

1. 性能可以通过添加隐式的（我喜欢）或显式转换操作符，而不是依赖于通用的==操作符来提高。

2. 根据http://igoro.com/archive/fun-with-c-generics-down-casting-to-a-generic-type/我添加了以下类。这需要关心拳击和性能 - 下面的类的性能比int或Castable的ArrayList好一点。当然，当List<int>比较时，它还有很长的路要走。 从我的角度来看，唯一的问题是，一旦将对象分配给普通Any对象以获取嵌入在AnyInternal<T>内部的具体类型。我也无法找到方法T Get()。即使关键字的动态在运行时出现故障，在statment：

Any.AnyInternal<dynamic> any = (Any.AnyInternal<dynamic>)anyInstanceContainingAnyInternalForInt;

//too bad I can't seal Any after AnyInternal<T> has derived from it. 
public abstract class Any 
{ 
    public static implicit operator int(Any any) 
    { 
     return Any.ToType<int>(any).Data; 
    } 

    public static AnyInternal<T> ToType<T>(Any any) 
    { 
     return ((AnyInternal<T>)any); 
    } 

    public class AnyInternal<T> : Any 
    { 
     private T _data; 
     public T Data { get { return _data; } } 
     public AnyInternal(T data) 
     { 
      _data = data; 
     } 
    } 
} 

Answer 1

使用泛型列表<牛逼>（内System.Collections.Generic），而不是ArrayList的。
对于值类型不会发生任何装箱/拆箱操作。