Dichiarazione di una variabile di tipo generico astratto

Question

il mio problema è il seguente. Ho realizzato un progetto di codice per un progetto di casa che apparentemente non funziona. Forse puoi aiutarmi a capire da dove viene il "codice odore".

Ok cominciamo: ho definito alcune classi per avvolgere diversi tipi di tipi di archivio:

public abstract class Archive { } 
public class ZipArchive : Archive { } 
public class TarArchive : Archive { } 

da maneggiare con quegli archivi, ho definito le classi Manager. Un uno astratto che definisce il comportamento necessario,

public abstract class ArchiveManager<T> where T : Archive 
{ 
    public abstract void OpenArchive(T archive); 
} 

E quelli concreti, che in realtà attuare il behaiour specifica:

public class ZipArchiveManager : ArchiveManager<ZipArchive> 
{ 
    public override void OpenArchive(ZipArchive archive) { /* .. */ } 
} 

public class TarArchiveManager : ArchiveManager<TarArchive> 
{ 
    public override void OpenArchive(TarArchive archive) { /* .. */ } 
} 

Quello che succede ora è che durante la fase di compilazione, non so che tipo degli archivi che elaborerà, così ho provato la seguente:

class Program 
{ 
    static void Main(string[] args) 
    { 
     ArchiveManager<Archive> archiveManager = null; 

     if (/*some condition*/) {    
      archiveManager = new ZipArchiveManager(); 
     } 
     else { 
      archiveManager = new TarArchiveManager(); 
     } 
    } 
} 

che ha finito il seguente errore:

012.

Cannot implicitly convert type 'ZipArchiveManager' to 'ArchiveManager'

Per quanto ho capito, l'argomento generico non può essere convertito implicitamente. C'è un modo per aggirare questo? Questo codice/design "annusa"?

Grazie mille in anticipo.

Answer 1

È possibile utilizzare un'interfaccia controvariante anziché una classe astratta che non implementa alcuna funzionalità. In questo caso, è possibile utilizzare solo il parametro di tipo come valore di ritorno di un metodo, non come un argomento:

public interface IArchiveManager<out T> 
    where T : Archive 
{ 
    T OpenArchive(Stream stream); 
} 

Quindi, è sufficiente implementare l'interfaccia nelle classi di gestione:

public class ZipArchiveManager : IArchiveManager<ZipArchive> 
{ 
    public ZipArchive OpenArchive(Stream stream) 
    { 
     // ... 
    } 
} 

public class TarArchiveManager : IArchiveManager<TarArchive> 
{ 
    public TarArchive OpenArchive(Stream stream) 
    { 
     // ... 
    } 
} 

Answer 2

I trovato un altro modo utilizzando la parola chiave "dinamica" di C# .NET 4.0 ...

class Program 
{ 
    static void Main(string[] args) 
    { 
     dynamic archiveManager = null; 

     if (/*some condition*/) {    
      archiveManager = new ZipArchiveManager(); 
     } 
     else { 
      archiveManager = new TarArchiveManager(); 
     } 
    } 
} 

funziona come un fascino per me;)