Czy istnieje możliwość zastosowania ogólnej metody do listy pozycji?

Question

Powiedzmy, że napisałem własną metodę odwrócenia listy w miejscu.

public static void MyReverse<T>(List<T> source) 
{ 
    var length = source.Count; 
    var hLength = length/2; 
    for (var i = 0; i < hLength; i++) 
    { 
     T temp = source[i]; 
     source[i] = source[length - 1 - i]; 
     source[length - 1 - i] = temp; 
    } 
} 

Ja to tak nazywam i działa.

var fooList = new List<Foo>(); 
MyReverse(fooList); 

Jeśli chcę cofnąć wiele list, nazywam to tak.

var fooList = new List<Foo>(); 
var barList = new List<Bar>(); 
var bazList = new List<Baz>(); 
MyReverse(fooList); 
MyReverse(barList); 
MyReverse(bazList); 

Jeśli chcę, aby odwrócić dowolną liczbę list, będę próbować:

public static void Main(string[] args) 
{ 
    var lists = new List<object> 
    { 
     new List<Foo>(), 
     new List<Bar>(), 
     new List<Bar>() 
    }; 

    ReverseLists(lists); 
} 

public static void ReverseLists(List<object> sourceLists) 
{ 
    foreach (var sourceList in sourceLists) 
    { 
     MyReverse(sourceList); // Error: Type arguments cannot be inferred from usage 
    } 
} 

Ale to generuje błąd czasu kompilacji. Czy to, co próbuję zrobić, czy możliwe jest wdrożenie metody ReverseLists?

Answer 1

Zakładając, że statycznej metody jak ten

public static class ReverseHelper 
{ 
    public static void MyReverse<T>(IList<T> source) 
    { 
     var length = source.Count; 
     var hLength = length/2; 
     for (var i = 0; i < hLength; i++) 
     { 
      T temp = source[i]; 
      source[i] = source[length - 1 - i]; 
      source[length - 1 - i] = temp; 
     } 
    } 
} 

za pomocą interfejsu rodzajowego i non rodzajowego klasy można to zrobić.

public interface IReverser 
{ 
    void Reverse(); 
} 
public class ListReverser<T> : IReverser 
{ 
    private readonly IList<T> source; 
    public ListReverser(IList<T> source) 
    { 
     this.source = source; 
    } 
    public void Reverse() 
    { 
     ReverseHelper.MyReverse<T>(source); 
    } 
} 
static void Main(string[] args) 
{ 
    var lists = new List<IReverser> 
    { 
     new ListReverser<Foo>(new List<Foo>()), 
     new ListReverser<Bar>(new List<Bar>()), 
     new ListReverser<Bar>(new List<Bar>()) 
    }; 

    foreach (var reverser in lists) 
    { 
     reverser.Reverse(); 
    } 
} 

Użyłem IList<T> w przeciwieństwie do List<T> wspierać szerszą liczbę typów; Jeśli chcesz List<T>, możesz go odłożyć.

Answer 2

Jeśli zmienisz ReverseLists podpis metody do

public static void ReverseLists<T>(IEnumerable<object> sourceLists) 
{ 
    foreach (var sourceList in sourceLists.OfType<List<T>>()) 
    { 
     MyReverse(sourceList); 
    } 
} 

Następnie można nazwać to dla każdego typu listy:

ReverseLists<Foo>(lists); 
ReverseLists<Bar>(lists); 

Może nie idealne konieczności wzywania go raz od rodzaju listy, ale stosunkowo niewielka zmiana w istniejącym kodzie.

Answer 3

Jak na mój komentarz powyżej ...

Kompilator nie może przekształcać wywnioskować typ T, gdy przeszedł object (który jest skutecznie, co się dzieje)

jednak jest znacznie prostsza opcja - co jest po prostu zrezygnować z użyciem leków generycznych i zmień podpis swojej MyReverse metody public static void MyReverse(IList source) (i gdzie indziej zastąpić List<object> z IList)

tj:

public static void Main(string args[]) 
{ 
    var lists = new List<IList> 
    { 
     new List<Foo>(), 
     new List<Bar>(), 
     new List<Bar>() 
    }; 

    ReverseLists(lists); 
} 

public static void MyReverse(IList source) 
{ 
    var length = source.Count; 
    var hLength = length/2; 
    for (var i = 0; i < hLength; i++) 
    { 
     var temp = source[i]; 
     source[i] = source[length - 1 - i]; 
     source[length - 1 - i] = temp; 
    } 
} 

public static void ReverseLists(List<IList> sourceLists) 
{ 
    foreach (var sourceList in sourceLists) 
    { 
     MyReverse(sourceList); // Error: Type arguments cannot be inferred from usage 
    } 
} 
public class Foo 
{ 
} 
public class Bar 
{ 
} 

Answer 4

Aby uzupełnić odpowiedź Srirama Sakthivela, kluczem do problemu jest to, że Typu nie można wywnioskować z tego, co przekazujesz.Warto zauważyć, że List<T> realizuje IList więc kwestia powyżej można przeformułować używając tablicy parametru listę:

void Main() 
{ 
    var fooList = new List<string>(); 
    var barList = new List<string>(); 
    var bazList = new List<string>(); 
    ReverseLists(fooList, barList, bazList); 
} 

public static void ReverseLists(params IList [] sourceLists) 
{ 
    foreach (var sourceList in sourceLists) 
    { 
     MyReverse(sourceList); 
    } 
} 

public static void MyReverse(IList source) 
{ 
    var length = source.Count; 
    var hLength = length/2; 
    for (var i = 0; i < hLength; i++) 
    { 
     var temp = source[i]; 
     source[i] = source[length - 1 - i]; 
     source[length - 1 - i] = temp; 
    } 
} 

Answer 5

zmiany tej linii w oryginalnym post:

MyReverse(sourceList); // Error: Type arguments cannot be inferred from usage 

do tego:

MyReverse(((System.Collections.IList)sourceList).Cast<object>().ToList());