Использование генериков в интерфейсах в C#

Question

У меня есть приложение, написанное на C#. У моего приложения есть класс, который выглядит следующим образом:

public class FinderA 
{ 
    public IEnumerable<FinderA> GetItems() 
    { 
    return FinderA.FindAll(); 
    } 
} 

Я хочу, чтобы другие классы делали что-то подобное. Я не могу использовать базовый класс, потому что моя фактическая реализация уже использует базовый класс. По этой причине я хочу создать интерфейс. В настоящее время я пытаюсь следующее:

public interface IFinder 
{ 
    IEnumerable<T> GetItems(); 
} 

Когда я использую этот подход, я получаю ошибку во время компиляции, который говорит: «Тип или пространство имен имя„T“не может быть найдено (вы пропали без вести. .. «чтобы преодолеть это, я добавляю <T> к концу имени интерфейса, так это выглядит следующим образом:

public interface IFinder<T> 
{ 
    IEnumerable<T> GetItems(); 
} 

Это в свою очередь порождает другую ошибку во время компиляции, который говорит:» ​​Использование универсального типа «IFinder «требует 1 аргумент типа». Моя задача: я хочу, чтобы интерфейс был общим. Я не хочу передавать тип. Есть ли способ обойти это? Если да, то что/как?

Answer 1

Нет никакого способа обойти это; вам нужно будет фактически предоставить аргумент generic type при объявлении того, что класс реализует интерфейс.

Answer 2

Если вы хотите, чтобы ваш интерфейс был общим, но вы не хотите указывать аргумент типа, вы можете вернуть IEnumerable<object>.

public interface IFinder { 
    IEnumerable<object> GetItems(); 
} 

Все типы класса простираются от System.Object, так что должно хватить для любого типа в вашем applicacion (перечислений и Структуры бы получить коробочный)

Пожалуйста, обратите внимание, что этот подход требует потребителя интерфейса, чтобы бросить общие экземпляры object для соответствующих типов.

Альтернативный (и рекомендуется) подход, чтобы сделать параметры интерфейс использования типа, но для этого необходимо предоставить аргументы типа, соответствующий ему

Answer 3

Вы можете сделать это на уровне метода, а не как общий тип на самом интерфейсе.

public interface IFinder 
{ 
    IEnumerable<T> GetItems<T>(); 
} 

Ваш код может затем вызвать его, как, например:

IFinder finder = // Create finder instance 
IEnumerable<MyClass> discoveredClasses = finder.GetItems<MyClass>(); 

Если вы хотите, чтобы убедиться, что MyClass это класс, который реализует IFinder, вы можете ограничить метод.

public interface IFinder 
{ 
    IEnumerable<T> GetItems<T>() where T : IFinder; 
} 

Это вызовет следующее генерировать ошибку компилятора:

public class Foo 
{ 
} 

public class Bar 
{ 
    Bar() 
    { 
     IFinder finder = // Create finder. 
     // This fails because <T> (Foo) does not implement IFinder. 
     IEnumerable<Foo> fooItems = finder.GetItems<Foo>(); 
    } 
} 

, но это позволит следующее скомпилировать

public class MyFinderA : IFinder 
{ 
    IEnumerable<T> GetItems<T>() where T : IFinder 
    { 
     return // Create collection of T 
} 

public class Bar 
{ 
    Bar() 
    { 
     IFinder finder = // Create finder. 
     // This works as <T> (MyFinderA) is an IFinder implementation 
     IEnumerable<MyFinderA> finderItems = finder.GetItems<MyFinderA>(); 
    } 
}