首页 > 代码库 > contains 方法
contains 方法
不管在c#中还是java中，很多类型都有contains方法。它的原理是什么？
c#中的contains有：
| String.Contains |
| List(T).Contains |
| Enumerable.Contains(TSource) |
| Vector.contains |
| Queue(T).Contains |
| Enumerable.Contains |
| Collection.contains |
| HashSet(T).Contains |
| ICollection(T).Contains |
| Array.contains |
| IQueryable(T).Contains |
| Hashtable.Contains |
| ArrayList.contains |
| Collection(T).Contains |
| Enumerable.Contains(TSource) |
| EntityCollection(TEntity).Contains |
| Stack(T).Contains |
| SortedList.Contains |
| PropertyBag.Contains |
等等。。。。。。。。。
看了下msdn，这些contains的原理，大致分三种
1，默认相等比较器
2，equals
3，hashcode
以List<T> 为例，其contains方法的定义为
// System.Collections.Generic.List<T>/// <summary>Determines whether an element is in the <see cref="T:System.Collections.Generic.List`1" />.</summary>/// <returns>true if <paramref name="item" /> is found in the <see cref="T:System.Collections.Generic.List`1" />; otherwise, false.</returns>/// <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.List`1" />. The value can be null for reference types.</param>[__DynamicallyInvokable]public bool Contains(T item){ if (item == null) { for (int i = 0; i < this._size; i++) { if (this._items[i] == null) { return true; } } return false; } EqualityComparer<T> @default = EqualityComparer<T>.Default; for (int j = 0; j < this._size; j++) { if (@default.Equals(this._items[j], item)) { return true; } } return false;}
可以看到，使用了默认相等比较器的方法Equals：EqualityComparer，看一下其定义
http://msdn.microsoft.com/zh-cn/library/ms224763(v=vs.110).aspx
public abstract class EqualityComparer<T> : IEqualityComparer, IEqualityComparer<T>
这两个接口只有两个方法，Equals和GetHashCode，但是EqualityComparer是一个抽象类，它实现了IEqualityComparer接口的两个方法且定义为私有方法，却把IEqualityComparer<T>接口的两个方法实现为了抽象方法。
那么因为@default.Equals调用的是IEqualityComparer<T>接口的方法，所以我们要知道Equals的实现方式，关键是在Default的获取上，通过它才可以看到Equals的定义，看一下Default的定义
public static EqualityComparer<T> Default { get { EqualityComparer<T> equalityComparer = EqualityComparer<T>.defaultComparer; if (equalityComparer == null) { equalityComparer = EqualityComparer<T>.CreateComparer(); EqualityComparer<T>.defaultComparer = equalityComparer; } return equalityComparer; } }
这里边defaultComparer的定义：
private static volatile EqualityComparer<T> defaultComparer;
我们暂时当它是null的，那么就会调用私有方法CreateComparer了。
private static EqualityComparer<T> CreateComparer() { RuntimeType runtimeType = (RuntimeType)typeof(T); if (runtimeType == typeof(byte)) { return (EqualityComparer<T>)new ByteEqualityComparer(); } if (typeof(IEquatable<T>).IsAssignableFrom(runtimeType)) { return (EqualityComparer<T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericEqualityComparer<int>), runtimeType); } if (runtimeType.IsGenericType && runtimeType.GetGenericTypeDefinition() == typeof(Nullable<>)) { RuntimeType runtimeType2 = (RuntimeType)runtimeType.GetGenericArguments()[0]; if (typeof(IEquatable<>).MakeGenericType(new Type[] { runtimeType2 }).IsAssignableFrom(runtimeType2)) { return (EqualityComparer<T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableEqualityComparer<int>), runtimeType2); } } if (runtimeType.IsEnum && Enum.GetUnderlyingType(runtimeType) == typeof(int)) { return (EqualityComparer<T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(EnumEqualityComparer<int>), runtimeType); } return new ObjectEqualityComparer<T>(); }
在这里，根据不同的运行时类型，实例化不同的EqualityComparer子类。在此只看最后一个return（todo 其他子类），ObjectEqualityComparer：这是一个internal的类，我们是用不了的
internal class ObjectEqualityComparer<T> : EqualityComparer<T>
然后我们可以找到Equals，这里会有两个
public override bool Equals(T x, T y) { if (x != null) { return y != null && x.Equals(y); } return y == null; } public override bool Equals(object obj) { ObjectEqualityComparer<T> objectEqualityComparer = obj as ObjectEqualityComparer<T>; return objectEqualityComparer != null; }
我们用到的是第一个(todo，第二个)。我们看到，这里又一次调用了Equals，但是这个Equals很好定位，它就是Object.Equals
如果当前实例是引用类型，Equals(Object) 方法测试引用相等性，并且，对于 Equals(Object) 方法的调用等效于 ReferenceEquals 方法的调用。 引用相等性意味着进行比较的对象变量引用同一个对象。如果当前实例是值类型，Equals(Object) 方法测试值相等性。
派生类通常重写 Object.Equals(Object) 方法实现值相等性。 此外，类型通常还提供其他的重载到 Equals 方法的强类型，通常通过实现 IEquatable<T> 接口。 当您调用 Equals 方法测试是否相等时，应知道是否当前实例重写 Object.Equals 并了解如何解决对 Equals 方法的特定调用。 否则，您可以执行与您预期不同的相等测试，因此，方法可能会返回意外的值。
http://msdn.microsoft.com/zh-cn/library/bsc2ak47.aspx
追下去后：
public virtual bool Equals(object obj){ return RuntimeHelpers.Equals(this, obj);}
[SecuritySafeCritical][MethodImpl(MethodImplOptions.InternalCall)]public new static extern bool Equals(object o1, object o2);
我觉得系统内置的类的Equals方法，都会重写的。我们关心的是我们自定义的类是怎么使用Equals的。但是这里开始导入外部的方法了，再进一步不知道该怎么办了（todo 继续）。
--======================================================================================
这条路走不通，换一个类型，试试HashSet<T>,首先找到它的contains方法
public bool Contains(T item){ if (this.m_buckets != null) { int num = this.InternalGetHashCode(item); for (int i = this.m_buckets[num % this.m_buckets.Length] - 1; i >= 0; i = this.m_slots[i].next) { if (this.m_slots[i].hashCode == num && this.m_comparer.Equals(this.m_slots[i].value, item)) { return true; } } } return false;}
看了下，m_comparer是IEqualityComparer<T>类型的，所以这里的Equals和上边是一样的。除了Equals，hashset还要比较hashcode，这是比较特别的地方。
contains 方法