public bool Contains(T item) { if (item == null) { for (int i = 0; i < _size; i++) { if (_items[i] == null) { return(true); } } return(false); } else { System.Collections.Generic.EqualityComparer <T> c = System.Collections.Generic.EqualityComparer <T> .Default; for (int i = 0; i < _size; i++) { if (c.Equals(_items[i], item)) { return(true); } } return(false); } }
public NCLinkedListNode <T> Find(T value) { NCLinkedListNode <T> head = this.head; System.Collections.Generic.EqualityComparer <T> comparer = System.Collections.Generic.EqualityComparer <T> .Default; if (head != null) { if (value != null) { do { if (comparer.Equals(head.item, value)) { return(head); } head = head.next; }while (head != this.head); } else { do { if (head.item == null) { return(head); } head = head.next; }while (head != this.head); } } return(null); }
public bool Contains(T item) { if ((Object)item == null) { for (int i = 0; i < _size; i++) { if ((Object)_items[i] == null) { Contract.Assert(Count > 0); return(true); } } return(false); } else { System.Collections.Generic.EqualityComparer <T> c = System.Collections.Generic.EqualityComparer <T> .Default; for (int i = 0; i < _size; i++) { if (c.Equals(_items[i], item)) { Contract.Assert(Count > 0); return(true); } } return(false); } }
static StackObject* Equals_1(ILIntepreter __intp, StackObject* __esp, IList<object> __mStack, CLRMethod __method, bool isNewObj) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject* ptr_of_this_method; StackObject* __ret = ILIntepreter.Minus(__esp, 3); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); System.Int32 @y = ptr_of_this_method->Value; ptr_of_this_method = ILIntepreter.Minus(__esp, 2); System.Int32 @x = ptr_of_this_method->Value; ptr_of_this_method = ILIntepreter.Minus(__esp, 3); System.Collections.Generic.EqualityComparer<System.Int32> instance_of_this_method = (System.Collections.Generic.EqualityComparer<System.Int32>)typeof(System.Collections.Generic.EqualityComparer<System.Int32>).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); var result_of_this_method = instance_of_this_method.Equals(@x, @y); __ret->ObjectType = ObjectTypes.Integer; __ret->Value = result_of_this_method ? 1 : 0; return __ret + 1; }
/// <summary> /// Remove the specified item from the list. Note that RemoveAt() is faster and is advisable if you already know the index. /// </summary> public bool Remove(T item) { if (buffer != null) { System.Collections.Generic.EqualityComparer <T> comp = System.Collections.Generic.EqualityComparer <T> .Default; for (int i = 0; i < size; ++i) { if (comp.Equals(buffer[i], item)) { --size; buffer[i] = default(T); for (int b = i; b < size; ++b) { buffer[b] = buffer[b + 1]; } return(true); } } } return(false); }
/// <summary>Compares the contents of a <see cref="IEnumerable{T}"/> /// implementation to another one to determine equality.</summary> /// <remarks>Thinking of the <see cref="IEnumerable{T}"/> implementation as /// a string with any number of characters, the algorithm checks /// each item in each list. If any item of the list is not equal (or /// one list contains all the elements of another list), then that list /// element is compared to the other list element to see which /// list is greater.</remarks> /// <param name="x">The <see cref="IEnumerable{T}"/> implementation /// that is considered the left hand side.</param> /// <param name="y">The <see cref="IEnumerable{T}"/> implementation /// that is considered the right hand side.</param> /// <returns>True if the items are equal, false otherwise.</returns> private static bool Equals(System.Collections.Generic.IEnumerable <T> x, System.Collections.Generic.IEnumerable <T> y) { // If x and y are null, then return true, they are the same. if (x == null && y == null) { // They are the same, return 0. return(true); } // If one is null, then return a value based on whether or not // one is null or not. if (x == null || y == null) { // Return false, one is null, the other is not. return(false); } // Check to see if the counts on the IEnumerable implementations are equal. // This is a shortcut, if they are not equal, then the lists are not equal. // If the result is indeterminate, then get out. bool?enumerableCountsEqual = EnumerableCountsEqual(x, y); // If the enumerable counts have been able to be calculated (indicated by // a non-null value) and it is false, then no need to iterate through the items. if (enumerableCountsEqual != null && !enumerableCountsEqual.Value) { // The sequences are not equal. return(false); } // The counts of the items in the enumerations are equal, or indeterminate // so a full iteration needs to be made to compare each item. // Get the default comparer for T first. System.Collections.Generic.EqualityComparer <T> defaultComparer = System.Collections.Generic.EqualityComparer <T> .Default; // Get the enumerator for y. System.Collections.Generic.IEnumerator <T> otherEnumerator = y.GetEnumerator(); // Call Dispose on IDisposable if there is an implementation on the // IEnumerator<T> returned by a call to y.GetEnumerator(). using (otherEnumerator as IDisposable) { // Cycle through the items in this list. foreach (T item in x) { // If there isn't an item to get, then this has more // items than that, they are not equal. if (!otherEnumerator.MoveNext()) { // Return false. return(false); } // Perform a comparison. Must check this on the left hand side // and that on the right hand side. bool comparison = defaultComparer.Equals(item, otherEnumerator.Current); // If the value is false, return false. if (!comparison) { // Return the value. return(comparison); } } // If there are no more items, then return true, the sequences // are equal. if (!otherEnumerator.MoveNext()) { // The sequences are equal. return(true); } // The other sequence has more items than this one, return // false, these are not equal. return(false); } }