Necesito un diccionario para el cual la clave debe ser dos guid. El orden de guid no importa. Tengo dos soluciones que se mencionan a continuación, quiero saber cuál es mejor y cuál debo elegir si en el futuro necesito agregar el tercer guid, así como parte de la clave. El rendimiento sí importa, pero si la diferencia no es mucha, entonces debería estar bien.
Primera solución
var guids = guids .OrderBy(g => g.ToString("N")) // Ordering so key always come as sorted .ToList(); dict[Tuple.Create(guids[0], guids[1]) = "RandomObj";Segunda solución
public class GuidsModel { public GuidsModel(Guid guid1, Guid guid2) { Guid1= guid1; Guid2= guid2; } public Guid Guid1 { get; private set; } public Guid Guid2 { get; private set; } } public class GuidsModelComparer : IEqualityComparer<GuidsModel> { public static GuidsModelComparer Default = new GuidsModelComparer(); private static IEqualityComparer<HashSet<Guid>> _hashSetComparer = HashSet<Guid>.CreateSetComparer(); public bool Equals(GuidsModel x, GuidsModel y) { return _hashSetComparer.Equals(new HashSet<Guid> { x.Guid1, x.Guid2}, new HashSet<Guid> { y.Guid1, y.Guid2}); } public int GetHashCode(GuidsModel obj) { if (obj == null) return 0; return _hashSetComparer.GetHashCode(new HashSet<Guid> { obj.Guid1, obj.Guid2}); } // usage var dict = new Dictionary<GuidsModel, object>(GuidsModelComparer.Default); dict[new GuidsModel(guids[0], guids[1])] = "RandomObj";Puede depender en gran medida del contexto, pero diría que si desea acceder al diccionario en más de un lugar, encapsular la lógica de "clasificación" de guid en un solo lugar tendría más sentido. También, personalmente, solo implementaría Equals y GetHashcode en el modelo en sí en lugar de crear un comparador personalizado.
public class GuidsModel { public GuidsModel(Guid guid1, Guid guid2) { if (guid1.CompareTo(guid2) > 0) // when there will be more than 2 guids can switch to ordering collection ie new [] {guid1, guid2, guid3}.OrderBy()... { Guid1 = guid1; Guid2 = guid2; } else { Guid1 = guid2; Guid2 = guid1; } } public Guid Guid1 { get; private set; } public Guid Guid2 { get; private set; } private bool Equals(GuidsModel other) { return Guid1.Equals(other.Guid1) && Guid2.Equals(other.Guid2); } public override bool Equals(object obj) { if (ReferenceEquals(null, obj)) return false; if (ReferenceEquals(this, obj)) return true; if (obj.GetType() != this.GetType()) return false; return Equals((GuidsModel)obj); } public override int GetHashCode() { return HashCode.Combine(Guid1, Guid2); } }Por lo que entendí, necesita un HashSet<Something> y este algo contiene dos valores del mismo tipo y el HashSet también debería coincidir, si el orden es diferente.
Conseguir esta orden de ignorar es bastante complicado. Pero si usa un método de fábrica para crear las instancias y este método de fábrica se encarga del ordenamiento, entonces se vuelve mucho más simple:
// Some class that holds two Guids, but it respects ordering public record GuidPair(Guid First, Guid Second); public static class Create { public static GuidPair GuidPair(Guid first, Guid second) { // Order guids somehow in factory method to ensure // correct equality comparison if (first.CompareTo(second) > 0) return new GuidPair(second, first); else return new GuidPair(first, second); } } public static class Program { public static void Main(string[] args) { // Some source for Guid values. var values = Enumerable.Range(0, 100) .Select(_ => Guid.NewGuid()); // Create a HashSet with arbitrary values. var hashes = values.Zip(values) .Select(pair => Create.GuidPair(pair.First, pair.Second)) .ToHashSet(); // Pick some "random" element var someEntry = hashes.Skip(17).First(); // Create explicitly a new item with values swapped (with factory method). var toCompare = Create.GuidPair(someEntry.Second, someEntry.First); // Check if default HashSet comparer works. var isAvailable = hashes.Contains(toCompare); // Prints "Found { first = Guid, second = Guid }: true" Console.WriteLine($"Found {toCompare}: {isAvailable}"); Console.ReadKey(); } }