sobrecargar elección

Question

Tengo dos métodos de extensión:

public static IPropertyAssertions<T> ShouldHave<T>(this T subject) 
{ 
    return new PropertyAssertions<T>(subject); 
} 

public static IPropertyAssertions<T> ShouldHave<T>(this IEnumerable<T> subject) 
{ 
    return new CollectionPropertyAssertions<T>(subject); 
} 

Ahora escribir un código que lo utiliza:

List<Customer> collection2 = new List<Customer>(); 
collection2.ShouldHave(); //first overload is chosen 
IEnumerable<Customer> collection3 = new List<Customer>(); 
collection3.ShouldHave(); //second overload is chosen 

Segunda sobrecarga se elige sólo si puedo especificar explícitamente el tipo IEnumerable. ¿Hay alguna forma de hacer que la segunda sobrecarga sea elegida en ambos casos?

Answer 1

En Fluido aserción 2,0 por fin he logrado resolver los problemas anteriores de una manera decente. Lea todo sobre eso aquí: http://www.dennisdoomen.net/2012/09/asserting-object-graph-equivalence.html

Answer 2

No lo creo. No creo que sea posible que en este caso IEnumerable<T> se llame siempre a la sobrecarga, ya que tiene menos coincidencia exacta con respecto al tipo T. Si no especifica un concreto IEnumerable<T>, la mejor coincidencia será siempre un primer método, en este caso.

Answer 3

La primera de sobrecarga es un partido mejor, porque T se infiere como List<Customer>, lo que da una coincidencia exacta. Para la segunda sobrecarga, inferiría T como Customer, por lo que el parámetro sería IEnumerable<Customer>, que es una coincidencia menos exacta que List<Customer>.

Answer 4

shouldhave() tiene un doble significado. En el primer caso, ShouldHave() tiene un retorno sobre el objeto proporcionado por el sujeto-parámetro. En el segundo caso, la devolución se trata de elementos en la enumeración, y no de la enumeración en sí misma.

En caso de que cree mi propia colección y quiera probar esta colección en sí (no los artículos), ciertamente quiero que ShouldHave (este sujeto T) sea llamado y no ShouldHave (este tema IEnumerable).

Tal vez debería reconsiderar su diseño. El segundo ShouldHave() hace dos cosas, por lo que debe dividirse en un método que extraiga los elementos de colección y una llamada al primer ShouldHave(), que ya tiene.