Question

我在java中有一个泛型类定义为：

public static class KeyCountMap<T> 
{
   private Map<T, MutableInt> map = new LinkedHashMap<T, MutableInt>();
   // ... rest of the properties...  

   public KeyCountMap()  
   { }  

   @SuppressWarnings({ "unchecked", "rawtypes" })  
   public KeyCountMap(Class<? extends Map> mapType) throws InstantiationException, IllegalAccessException   
   {
      map = mapType.newInstance();
   }  
   //... rest of the methods...  
}

我在.NET中定义了相同的类：

public static class KeyCountMap<T>  
{  
   private Dictionary<T, MutableInt> map = new Dictionary<T, MutableInt>();
   // ... rest of properties...  

   public KeyCountMap()  
   { }  

   public void KeyCountMap<T>(T obj) where T : Dictionary<T, MutableInt>  
   {  
      obj = new T();  // Unable to define new instance of T
      map = obj;      // Unable to convert T to base class
   }  
}

然后定义一个方法，按降序对值KeyCountMap<T>的映射进行排序。该方法定义为：

public static KeyCountMap<T> SortMapByDescendValue<T>(KeyCountMap<T> _map)
{
   List<KeyValuePair<T, MutableInt>> _list = new List<KeyValuePair<T, MutableInt>>(_map.EntrySet());  
   // whereas _map.EntrySet() return of type HashSet<KeyValuePair<T, MutableInt>>  
   _list = _list.OrderByDescending(_x => _x.Value).ToList();

   KeyCountMap<T> _result = new KeyCountMap<T>();
   foreach (KeyValuePair<T, MutableInt> _entry in _list)
   {
       _result.Put(_entry.Key, _entry.Value);
   }
   return _result; 
}

如何更正.NET中定义的类？

Answer 1

有两个问题。首先，您需要告诉编译器T有一个无参数构造函数，因此您可以调用new T()。您可以通过向类定义提供new()参数来实现。

您还必须告诉编译器T实际上是您要分配的字典，因此我们必须更多地扩展该类：

public class KeyCountMap<K>
{
    private Dictionary<K, MutableInt> map = new Dictionary<K, MutableInt>();
    // ... rest of properties...

请注意，K是字典的键类型，您尚未指定。

其次，方法中的T可以成为您班级中的另一个T。省略这将解决问题：

public void Map()
{
    var obj = new Dictionary<K, MutableInt>();  // Unable to define new instance of T
    map = obj;      // Unable to convert T to base class
}

Answer 2

我假设您知道Java在编译后会删除任何泛型类型信息（变量的元数据，但实际对象没有泛型类型信息）。而且，您的代码不是类型安全的：

@SuppressWarnings({ "unchecked", "rawtypes" })

您正在使用此功能，因为您正在创建Map的非参数化实例。

在.NET中，你不能像这样绕过类型系统，因为通用类型信息在运行时保持并且。

让我们看看你的C＃代码：

public static class KeyCountMap<T>

C＃中的静态类是一个无法实例化的类，它仅用于静态成员。我想你不想要这个。也许KeyCountMap是Java中的静态嵌套类，而不是内部类。

在C＃中，你没有内部课程。嵌套类不与包含类的实例共享数据，就好像包含类的名称是嵌套类的命名空间的一部分一样。因此，您不需要，实际上并不需要static关键字。

{  
   private Dictionary<T, MutableInt> map = new Dictionary<T, MutableInt>();

在.NET中，Dictionary是一个类。要保持意图，您应使用IDictionary（相应的界面）作为map字段的类型。

   // ... rest of properties...  

   public KeyCountMap()  
   { }  

   public void KeyCountMap<T>(T obj) where T : Dictionary<T, MutableInt>

为什么void返回类型，这不是构造函数？

在C＃中，构造函数不是通用的。您可能需要Type。

您的C＃代码没有意义，所以您可以做以下事情：

   public KeyCountMap(Type dictionaryType)
   {
      if (!typeof(IDictionary<T, MutableInt>).IsAssignableFrom(dictionaryType))
      {
          throw new ArgumentException("Type must be a IDictionary<T, MutableInt>", nameof(dictionaryType));
      }
      map = (IDictionary<T, MutableInt>)Activator.CreateInstance(dictionaryType);
   }
}

我们在创建实例之前检查类型。如果我们没有，我们会创建一个实例，转换会失败并且分配甚至不会发生，所以新实例只会是垃圾。

可能是实际的实例将是代理;如果是这样，您可能不想在创建实例之前检查类型。

您不能只是将Java复制粘贴为C＃（反之亦然），并希望在其工作之前进行一些更改，对于某些工作的定义，例如它汇编。这些语言并不相似，很可能有太多微妙的事情是错误的。

这种方法起初可能很有趣，但是你会经常跌跌撞撞，很快就会停止玩乐。在逐行开始翻译代码之前，您应该学习基础知识并了解目标语言的完成方式。很多时候，你可能会发现在一个环境中你必须做的事情已经存在于另一个环境中，反之亦然，或者在另一个环境中可能需要采取更多或更少的步骤，等等。

在这种特殊情况下，Java使Class成为泛型类，而.NET使Type成为非泛型类。在.NET中，只有接口和委托可以声明泛型类型协方差或逆变。无论如何，这是相当严格的，如果Type是通用的，则预期用途可以是协变的或逆变的。但请记住，在Java中，运行时的泛型Class<T>与Class一样好，它在编译时只有任何值，无论如何你都可以告诉编译器，就像你一样。< / p>

Answer 3

也许这就是你想要的？

public class KeyCountMap<T>
    where T : new()
{
    private Dictionary<T, MutableInt> map = new Dictionary<T, MutableInt>();
    // ... rest of properties...  

    public KeyCountMap()
    { }

    public KeyCountMap(T obj)
    {
        obj = new T();
        map = (Dictionary<T, MutableInt>)(object)obj;
    }
}

获取Java的类的行为<！ - ？在.NET中扩展Map - >

3 个答案: