Czy istnieje ogólne ograniczenie typu dla "skąd NIE pochodzi od"?

Question

Możemy określić „pochodzi od” ograniczenia na parametry typu rodzajowego jak ten:

class Bar<T> where T : IFooGenerator 

Czy istnieje sposób, aby określić NIE pochodzi od?

---

My use-case: Mam kilka FooGenerator s, które są parallelizable, z tym samym kodem Zrównoleglanie dla każdego, ale nie chcemy ich do zawsze być parallelized.

public class FooGenerator : IFooGenerator 
{ 
    public Foo GenerateFoo() { ... } 
} 

Zatem utworzyć rodzajowe klasy kontenera do generowania Foo równolegle:

public class ParallelFooGenerator<T> : IFooGenerator where T : IFooGenerator 
{ 
    public Foo GenerateFoo() 
    { 
     //Call T.GenerateFoo() a bunch in parallel 
    } 
} 

Ponieważ chcę FooGenerator i ParallelFooGenerator<FooGenerator> być stosowane zamiennie, robię ParallelFooGenerator : IFooGenerator. Jednak wyraźnie nie chcę, aby ParallelFooGenerator<ParallelFooGenerator> było legalne.

Tak więc, jako pytanie pomocnicze, istnieje prawdopodobnie lepszy sposób zaprojektowania tego, jeśli ograniczenia "nie pochodzą od" są niemożliwe?

Answer 1

Można użyć coś jak poniżej:

public interface IFooGenerator 
{ 
    Foo GenerateFoo(); 
} 

interface ISerialFooGenerator : IFooGenerator { } 

interface IParallelFooGenerator : IFooGenerator { } 

public class FooGenerator : ISerialFooGenerator 
{ 
    public Foo GenerateFoo() 
    { 
     //TODO 
     return null; 
    } 
} 

public class ParallelFooGenerator<T> : IParallelFooGenerator 
    where T : ISerialFooGenerator, new() 
{ 
    public Foo GenerateFoo() 
    { 
     //TODO 
     return null; 
    } 
} 

Answer 2

ParallelFooGenerator<ParallelFooGenerator> już nie jest możliwe, ponieważ ParallelFooGenerator jest typem ogólnym i nie podano ogólnego argumentu.

Na przykład, ParallelFooGenerator<ParallelFooGenerator<SomeFooGenerator>> jest możliwe - i czy pozwolenie na taki typ naprawdę będzie takie złe?

Answer 3

Prosta odpowiedź brzmi: nie.

Długa odpowiedź (jeszcze nie):

Microsoft stawia go dobrze w ich explanation of type constrains: „kompilator musi mieć jakąś gwarancję, że operator lub metoda musi zadzwonić będą wspierane przez dowolny rodzaj argumentu, który może być określony przez kod klienta. "

Podstawowym celem ograniczeń nie jest zabronienie używania niektórych typów, ale raczej umożliwienie kompilatorowi informacji o obsługiwanych operatorach lub metodach. W trakcie wykonywania można jednak wykonać check if a type implements/inherits a specific interface/base class i podać wyjątek. Z tym jednak nie będziesz w stanie uzyskać błędu w czasie projektowania od intellisense.

Mam nadzieję, że to pomoże.