Создание метода расширения для обертывания типов как IEnumerables

Question

Я хотел создать метод расширения, который бы эффективно обертывал отдельные объекты как IEnumerables. Это было во избежание случаев, когда вы положили new [] {} в середине выражения. Это достаточно легко сделать, используя следующий метод:

public static IEnumerable<TSource> WrapAsEnumerable<TSource>(this TSource source) 
{ 
    return new[] { source }; 
} 

Проблема заключается в том, что это будет применяться к любым типам (это ожидаемое поведение), но это также будет иметь побочный эффект: метод доступен по IEnumerable <T> экземплярам. В случае, когда разрешенный расширенный тип является IEnumerable<T>, я просто хотел бы вернуть этот IEnumerable, так как альтернатива находит себя с IEnumerable<IEnumerable<T>>, что на самом деле не так, как вы ожидали при вызове метода.

Инстинктивно (и, возможно, сонно), я сначала создал перегрузку, которая выглядела как этот

public static IEnumerable<TSource> WrapAsEnumerable<TSource>(this IEnumerable<TSource> source) 
{ 
    return source; 
} 

для того, чтобы обрабатывать случай, когда тип завернуть является IEnumerable<T>, Но, конечно, поток управления всегда разрешает первый метод.

Итак, вопрос в том, как я могу создать такой метод упаковки, который обрабатывает как случай, когда экземпляр расширенного параметра является IEnumerable<T>, а когда нет?

Answer 1

Вот еще одна попытка, вдохновленная отличным сообщением Эрика Липперта: https://stackoverflow.com/a/1451184/4955425.

Вы можете управлять разрешением перегрузки, разместив ваши 2 метода расширения на разных уровнях иерархии пространства имен.

namespace MyExtensions 
{ 
    public static class HighPrecendenceExtensions 
    { 
     public static IEnumerable<TSource> WrapAsEnumerable<TSource>(this IEnumerable<TSource> source) 
     { 
      return source; 
     } 
    } 

    namespace LowerPrecedenceNamespace 
    { 
     public static class LowPrecedenceExtensions 
     { 
      public static IEnumerable<TSource> WrapAsEnumerable<TSource>(this TSource source) 
      { 
       return new[] { source }; 
      } 
     } 
    } 
} 

Однако недостатком является то, что вам всегда нужно обращаться к обоим пространствам имен, чтобы получить правильное поведение вызова метода.

using MyExtensions; 
using MyExtensions.LowerPrecedenceNamespace; 

Answer 2

Вы считаете, что меняете свою подпись немного, делает код немного более сложным, но делает его чрезвычайно простым.

public static class Extensions 
{ 
    public static IEnumerable<TSource> WrapAsEnumerable<TSource>(this object source) 
    { 
     var allInterfaces = source.GetType().GetInterfaces(); 

     IEnumerable<Type> allEnumerableInterfaces = allInterfaces.Where(t => t.Name.StartsWith("IEnumerable")); 
     if (!allEnumerableInterfaces.Any()) 
      return new[] { (TSource)source }; 

     IEnumerable<Type> genericEnumerableOfTSource = allEnumerableInterfaces.Where(t => t.GenericTypeArguments.Contains(typeof(TSource))); 

     // we have a generic implementation 
     if (genericEnumerableOfTSource.Any()) 
     { 
      return (IEnumerable<TSource>) source; 
     } 

     return new[] { (TSource)source }; ; 
    } 
} 

[TestFixture] 
public class Tests 
{ 
    [Test] 
    public void should_return_string_an_enumerable() 
    { 
     const string aString = "Hello World"; 
     var wrapped = aString.WrapAsEnumerable<string>(); 
     wrapped.ShouldAllBeEquivalentTo(new[] {"Hello World"}); 
    } 

    [Test] 
    public void should_return_generic_enumerable_unwrapped() 
    { 
     var aStringList = new List<string> { "Hello", "World" }; 
     var wrapped = aStringList.WrapAsEnumerable<string>(); 
     wrapped.ShouldAllBeEquivalentTo(new[] { "Hello", "World" }); 
    } 

    [Test] 
    public void should_return_non_generic_enumerable_unwrapped() 
    { 
     var aStringArray = new[] {"Hello", "World"}; 
     var wrapped = aStringArray.WrapAsEnumerable<string>(); 
     wrapped.ShouldAllBeEquivalentTo(new[] { "Hello", "World" }); 
    } 
}