使用可变对象作为字典中的键完全可以吗?
假设我有一些特殊的类 WrappedDataTable
,并且我想将每个 WrappedDataTable
与一个 DataTable
关联起来。此外,我希望对于任何给定的 DataTable
来说,存在的 WrappedDataTable
不超过一个。
一位同事建议我可以缓存我的 WrappedDataTable
并使用工厂方法来访问它,如下所示:
public static class DataTableWrapper
{
private Dictionary<DataTable, WrappedDataTable> _wrappedTables;
static DataTableWrapper()
{
_wrappedTables = new Dictionary<DataTable, WrappedDataTable>();
}
public static WrappedDataTable Wrap(this DataTable table)
{
WrappedDataTable wrappedTable;
if (!_wrappedTables.TryGetValue(table, out wrappedTable))
_wrappedTables[table] = wrappedTable = new WrappedDataTable(table);
return wrappedTable;
}
}
一开始这让我觉得非常可疑,我想是因为我已经熟悉了键入的想法字典应该是不可变类型。但或许情况并不一定如此?一项快速测试告诉我,DataTable
似乎在对其内容进行多次修改的过程中保持一致的哈希码;因此,Dictionary
似乎能够一致地为 ContainsKey
返回正确的值。
我想知道的是,默认情况下 object.GetHashCode
的基本版本是否会为每个单独的对象返回不变的值,或者我在 DataTable
中看到的是只是一个幻觉?
如果前者为真 - 并且 object.GetHashCode
工作得很好 - 似乎“仅使用不可变类型作为键”建议实际上仅适用于以下场景:
- 您希望对象相等值相等而不是引用相等,和/或:
- 您有一个自定义类型,它有自己的基于类型成员的
GetHashCode
实现。
有哪位圣人愿意为我阐明这一点吗?
更新:感谢 Jon Skeet 回答我的问题。在其他新闻中,我做了一些挖掘,并认为我想出了一个IEqualityComparer
,它确实提供了身份比较!检查一下(抱歉,讨厌 VB.NET 的人,我刚刚创建了一个 VB.NET 项目,所以这就是我写的内容——翻译很简单):
Imports System.Collections.Generic
Imports System.Runtime.CompilerServices
Public Class IdentityComparer(Of T As Class)
Implements IEqualityComparer(Of T)
Public Overloads Function Equals(ByVal x As T, ByVal y As T) As Boolean _
Implements IEqualityComparer(Of T).Equals
Return Object.ReferenceEquals(x, y)
End Function
Public Overloads Function GetHashCode(ByVal obj As T) As Integer _
Implements IEqualityComparer(Of T).GetHashCode
Return RuntimeHelpers.GetHashCode(obj)
End Function
End Class
看一下这个示例程序:
Dim comparer As IEqualityComparer(Of String) = New IdentityComparer(Of String)
Dim x As New String("Hello there")
Dim y As New String("Hello there")
Console.WriteLine(comparer.Equals(x, y))
Console.WriteLine(comparer.GetHashCode(x))
Console.WriteLine(comparer.GetHashCode(y))
输出:
False 37121646 45592480
Say I have some special class, WrappedDataTable
, and I want to associate each WrappedDataTable
with exactly one DataTable
. Furthermore, I want there to be no more than one WrappedDataTable
in existence for any given DataTable
.
A colleague suggested I could cache my WrappedDataTable
and use a factory method to access one, like this:
public static class DataTableWrapper
{
private Dictionary<DataTable, WrappedDataTable> _wrappedTables;
static DataTableWrapper()
{
_wrappedTables = new Dictionary<DataTable, WrappedDataTable>();
}
public static WrappedDataTable Wrap(this DataTable table)
{
WrappedDataTable wrappedTable;
if (!_wrappedTables.TryGetValue(table, out wrappedTable))
_wrappedTables[table] = wrappedTable = new WrappedDataTable(table);
return wrappedTable;
}
}
This struck me as very questionable at first, I guess because I've become familiar with the idea that keys in a dictionary should be immutable types. But perhaps this is not necessarily the case? A quick test revealed to me that a DataTable
appears to maintain a consistent hash code over the course of numerous modifications to its contents; a Dictionary<DataTable, TValue>
therefore appears to be able to return a correct value for ContainsKey
consistently.
What I'm wondering is if the base version of object.GetHashCode
by default will return an unchanging value for every individual object, or if what I'm seeing with DataTable
is just an illusion?
If the former is true -- and object.GetHashCode
works just fine -- it seems the "use only immutable types as keys" advice really only applies to scenarios where:
- You want equality of objects to be about value equality as opposed to reference equality, and/or:
- You have a custom type with its own
GetHashCode
implementation that is based on the type's members.
Any sages out there care to shed some light on this for me?
UPDATE: Thanks to Jon Skeet for answering my question. In other news, I did some digging and think I came up with an IEqualityComparer<T>
that does provide identity comparison after all! Check it out (sorry VB.NET haters, I just had a VB.NET project up so that's what I wrote it in -- translation is trivial):
Imports System.Collections.Generic
Imports System.Runtime.CompilerServices
Public Class IdentityComparer(Of T As Class)
Implements IEqualityComparer(Of T)
Public Overloads Function Equals(ByVal x As T, ByVal y As T) As Boolean _
Implements IEqualityComparer(Of T).Equals
Return Object.ReferenceEquals(x, y)
End Function
Public Overloads Function GetHashCode(ByVal obj As T) As Integer _
Implements IEqualityComparer(Of T).GetHashCode
Return RuntimeHelpers.GetHashCode(obj)
End Function
End Class
Take a look at this example program:
Dim comparer As IEqualityComparer(Of String) = New IdentityComparer(Of String)
Dim x As New String("Hello there")
Dim y As New String("Hello there")
Console.WriteLine(comparer.Equals(x, y))
Console.WriteLine(comparer.GetHashCode(x))
Console.WriteLine(comparer.GetHashCode(y))
Output:
False 37121646 45592480
如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱,如果其他用户或者作者回复了您的评论,将不能在第一时间通知您!
发布评论
评论(2)
它不必返回唯一的值。它只需要返回一个不变的值 - 这就是
object.GetHashCode
所做的。只要
DataTable
不覆盖Equals
或GetHashCode
,您基本上就获得了相等的对象标识 - 这意味着它并不重要如果对象发生了突变。我个人希望看到IEqualityComparer
的实现,它为任何类型提供身份相等性,但我们无法自己实现 - 没有找出如果没有被覆盖的话GetHashCode
会返回什么的方法。 (Java 在其标准库中具有此功能,但 .NET 没有。Grr。)编辑:Woot - 使用
object.ReferenceEquals
和RuntimeHelpers.GetHashCode(),我们可以轻松实现
IdentityEqualityComparer
。耶!It doesn't have to return a unique value. It just has to return an unchanging one - and that's what
object.GetHashCode
does.So long as
DataTable
doesn't overrideEquals
orGetHashCode
, you've basically got object identity as equality - which means it doesn't matter if the object is mutated.Personally I'd like to see an implementation ofIEqualityComparer<T>
which provides identity equality for any type, but we can't implement that ourselves - there's no way of finding out whatGetHashCode
would have returned if it hadn't been overridden. (Java has this capability in its standard libraries, but .NET doesn't. Grr.)EDIT: Woot - with
object.ReferenceEquals
andRuntimeHelpers.GetHashCode()
, we can easily implement anIdentityEqualityComparer<T>
. Yay!我认为你对事情的理解很好。对于要存储在字典中的对象,任何会影响其哈希值或与其他对象相等的测试的特征都必须是不可变的。不会影响这些事物的特征不必是一成不变的。
I think you understand things fine. For an object to be stored in a dictionary, any characteristics which would affect its hash value or tests for equality with other objects must be immutable. Characteristics which would not affect those things need not be immutable.