Vergelijkingen en sorteringen binnen verzamelingen
De System.Collections klassen voeren vergelijkingen uit in bijna alle processen die betrekking hebben op het beheren van verzamelingen, ongeacht of u zoekt naar het element om de waarde van een sleutel-en-waardepaar te verwijderen of te retourneren.
Verzamelingen maken doorgaans gebruik van een gelijkheidsvergelijker en/of een ordervergelijker. Er worden twee constructies gebruikt voor vergelijkingen.
Controleren op gelijkheid
Methoden zoals Contains, IndexOfen LastIndexOfRemove gebruiken een gelijkheidsgelijker voor de verzamelingselementen. Als de verzameling algemeen is, worden items vergeleken voor gelijkheid volgens de volgende richtlijnen:
Als type T de IEquatable<T> algemene interface implementeert, is de gelijkheidsgelijker de Equals methode van die interface.
Als het type T niet wordt geïmplementeerd IEquatable<T>, Object.Equals wordt gebruikt.
Daarnaast accepteren sommige constructor-overbelastingen voor woordenlijstverzamelingen een IEqualityComparer<T> implementatie, die wordt gebruikt om sleutels voor gelijkheid te vergelijken. Zie de Dictionary<TKey,TValue> constructor voor een voorbeeld.
Sorteervolgorde bepalen
Methoden zoals BinarySearch het gebruik van Sort een rangschikkende vergelijking voor de verzamelingselementen. De vergelijkingen kunnen bestaan uit elementen van de verzameling of tussen een element en een opgegeven waarde. Voor het vergelijken van objecten is het concept van een default comparer en een explicit comparer.
De standaard comparer is afhankelijk van ten minste één van de objecten die worden vergeleken met het implementeren van de IComparable-interface . Het is een goede gewoonte om IComparable te implementeren voor alle klassen die worden gebruikt als waarden in een lijstverzameling of als sleutels in een woordenlijstverzameling. Voor een algemene verzameling wordt gelijkheidsvergelijking bepaald op basis van het volgende:
Als type T de System.IComparable<T> algemene interface implementeert, is de standaard comparer de IComparable<T>.CompareTo(T) methode van die interface
Als type T de niet-algemene System.IComparable interface implementeert, is de standaardvergelijker de IComparable.CompareTo(Object) methode van die interface.
Als type T geen van beide interfaces implementeert, is er geen standaardvergelijker en moet er expliciet een vergelijkingsdelegent of vergelijkingsdelegen worden opgegeven.
Als u expliciete vergelijkingen wilt bieden, accepteren sommige methoden een IComparer-implementatie als parameter. De methode accepteert bijvoorbeeld List<T>.Sort een System.Collections.Generic.IComparer<T> implementatie.
De huidige cultuurinstelling van het systeem kan van invloed zijn op de vergelijkingen en sorteringen binnen een verzameling. De vergelijkingen en sorteringen in de klassen Verzamelingen zijn standaard cultuurgevoelig. Als u de cultuurinstelling wilt negeren en daarom consistente vergelijkings- en sorteerresultaten wilt verkrijgen, gebruikt u de InvariantCulture overbelasting van leden die een CultureInfoaccepteren. Zie Cultuurgevoelige tekenreeksbewerkingen uitvoeren in verzamelingen en Cultuurgevoelige tekenreeksbewerkingen uitvoeren in matrices voor meer informatie.
Voorbeeld van gelijkheid en sortering
De volgende code demonstreert een implementatie van IEquatable<T> en IComparable<T> op een eenvoudig bedrijfsobject. Wanneer het object wordt opgeslagen in een lijst en gesorteerd, ziet u bovendien dat het aanroepen van de Sort() methode resulteert in het gebruik van de standaardvergelijker voor het Part type en de Sort(Comparison<T>) methode die wordt geïmplementeerd met behulp van een anonieme methode.
using System;
using System.Collections.Generic;
// Simple business object. A PartId is used to identify the
// type of part but the part name can change.
public class Part : IEquatable<Part>, IComparable<Part>
{
public string PartName { get; set; }
public int PartId { get; set; }
public override string ToString() =>
$"ID: {PartId} Name: {PartName}";
public override bool Equals(object obj) =>
(obj is Part part)
? Equals(part)
: false;
public int SortByNameAscending(string name1, string name2) =>
name1?.CompareTo(name2) ?? 1;
// Default comparer for Part type.
// A null value means that this object is greater.
public int CompareTo(Part comparePart) =>
comparePart == null ? 1 : PartId.CompareTo(comparePart.PartId);
public override int GetHashCode() => PartId;
public bool Equals(Part other) =>
other is null ? false : PartId.Equals(other.PartId);
// Should also override == and != operators.
}
public class Example
{
public static void Main()
{
// Create a list of parts.
var parts = new List<Part>
{
// Add parts to the list.
new Part { PartName = "regular seat", PartId = 1434 },
new Part { PartName = "crank arm", PartId = 1234 },
new Part { PartName = "shift lever", PartId = 1634 },
// Name intentionally left null.
new Part { PartId = 1334 },
new Part { PartName = "banana seat", PartId = 1444 },
new Part { PartName = "cassette", PartId = 1534 }
};
// Write out the parts in the list. This will call the overridden
// ToString method in the Part class.
Console.WriteLine("\nBefore sort:");
parts.ForEach(Console.WriteLine);
// Call Sort on the list. This will use the
// default comparer, which is the Compare method
// implemented on Part.
parts.Sort();
Console.WriteLine("\nAfter sort by part number:");
parts.ForEach(Console.WriteLine);
// This shows calling the Sort(Comparison<T> comparison) overload using
// a lambda expression as the Comparison<T> delegate.
// This method treats null as the lesser of two values.
parts.Sort((Part x, Part y) =>
x.PartName == null && y.PartName == null
? 0
: x.PartName == null
? -1
: y.PartName == null
? 1
: x.PartName.CompareTo(y.PartName));
Console.WriteLine("\nAfter sort by name:");
parts.ForEach(Console.WriteLine);
/*
Before sort:
ID: 1434 Name: regular seat
ID: 1234 Name: crank arm
ID: 1634 Name: shift lever
ID: 1334 Name:
ID: 1444 Name: banana seat
ID: 1534 Name: cassette
After sort by part number:
ID: 1234 Name: crank arm
ID: 1334 Name:
ID: 1434 Name: regular seat
ID: 1444 Name: banana seat
ID: 1534 Name: cassette
ID: 1634 Name: shift lever
After sort by name:
ID: 1334 Name:
ID: 1444 Name: banana seat
ID: 1534 Name: cassette
ID: 1234 Name: crank arm
ID: 1434 Name: regular seat
ID: 1634 Name: shift lever
*/
}
}
Imports System.Collections.Generic
' Simple business object. A PartId is used to identify the type of part
' but the part name can change.
Public Class Part
Implements IEquatable(Of Part)
Implements IComparable(Of Part)
Public Property PartName() As String
Get
Return m_PartName
End Get
Set(value As String)
m_PartName = Value
End Set
End Property
Private m_PartName As String
Public Property PartId() As Integer
Get
Return m_PartId
End Get
Set(value As Integer)
m_PartId = Value
End Set
End Property
Private m_PartId As Integer
Public Overrides Function ToString() As String
Return "ID: " & PartId & " Name: " & PartName
End Function
Public Overrides Function Equals(obj As Object) As Boolean
If obj Is Nothing Then
Return False
End If
Dim objAsPart As Part = TryCast(obj, Part)
If objAsPart Is Nothing Then
Return False
Else
Return Equals(objAsPart)
End If
End Function
Public Function SortByNameAscending(name1 As String, name2 As String) As Integer
Return name1.CompareTo(name2)
End Function
' Default comparer for Part.
Public Function CompareTo(comparePart As Part) As Integer _
Implements IComparable(Of ListSortVB.Part).CompareTo
' A null value means that this object is greater.
If comparePart Is Nothing Then
Return 1
Else
Return Me.PartId.CompareTo(comparePart.PartId)
End If
End Function
Public Overrides Function GetHashCode() As Integer
Return PartId
End Function
Public Overloads Function Equals(other As Part) As Boolean Implements IEquatable(Of ListSortVB.Part).Equals
If other Is Nothing Then
Return False
End If
Return (Me.PartId.Equals(other.PartId))
End Function
' Should also override == and != operators.
End Class
Public Class Example
Public Shared Sub Main()
' Create a list of parts.
Dim parts As New List(Of Part)()
' Add parts to the list.
parts.Add(New Part() With { _
.PartName = "regular seat", _
.PartId = 1434 _
})
parts.Add(New Part() With { _
.PartName = "crank arm", _
.PartId = 1234 _
})
parts.Add(New Part() With { _
.PartName = "shift lever", _
.PartId = 1634 _
})
' Name intentionally left null.
parts.Add(New Part() With { _
.PartId = 1334 _
})
parts.Add(New Part() With { _
.PartName = "banana seat", _
.PartId = 1444 _
})
parts.Add(New Part() With { _
.PartName = "cassette", _
.PartId = 1534 _
})
' Write out the parts in the list. This will call the overridden
' ToString method in the Part class.
Console.WriteLine(vbLf & "Before sort:")
For Each aPart As Part In parts
Console.WriteLine(aPart)
Next
' Call Sort on the list. This will use the
' default comparer, which is the Compare method
' implemented on Part.
parts.Sort()
Console.WriteLine(vbLf & "After sort by part number:")
For Each aPart As Part In parts
Console.WriteLine(aPart)
Next
' This shows calling the Sort(Comparison(T) overload using
' an anonymous delegate method.
' This method treats null as the lesser of two values.
parts.Sort(Function(x As Part, y As Part)
If x.PartName Is Nothing AndAlso y.PartName Is Nothing Then
Return 0
ElseIf x.PartName Is Nothing Then
Return -1
ElseIf y.PartName Is Nothing Then
Return 1
Else
Return x.PartName.CompareTo(y.PartName)
End If
End Function)
Console.WriteLine(vbLf & "After sort by name:")
For Each aPart As Part In parts
Console.WriteLine(aPart)
Next
'
'
' Before sort:
' ID: 1434 Name: regular seat
' ID: 1234 Name: crank arm
' ID: 1634 Name: shift lever
' ID: 1334 Name:
' ID: 1444 Name: banana seat
' ID: 1534 Name: cassette
'
' After sort by part number:
' ID: 1234 Name: crank arm
' ID: 1334 Name:
' ID: 1434 Name: regular seat
' ID: 1444 Name: banana seat
' ID: 1534 Name: cassette
' ID: 1634 Name: shift lever
'
' After sort by name:
' ID: 1334 Name:
' ID: 1444 Name: banana seat
' ID: 1534 Name: cassette
' ID: 1234 Name: crank arm
' ID: 1434 Name: regular seat
' ID: 1634 Name: shift lever
End Sub
End Class
