Ciao a tutti, stò cercando un aiuto per risolvere il seguente problema:
Stò utilizzando in un'applicazione asp.net il pattern Provider Model per eseguire il caricamento a runtime dei provider specificati nel file di configurazione, attraverso la dependency Injection.

Di norma il Provider Model è basato su una classe astratta che può derivare direttamente o indirettamente dalla classe ProviderBase e contiene tutti i metodi e le proprietà astratte che verranno condivise da tutti i provider che erediteranno da essa.

Quindi se nella classe astratta io scrivessi un metodo del tipo

public abstract string GetUser(string userName);

tutti i provider implementeranno il metodo GetUser in maniera speculare firma compresa.

Quello che stò cercando di fare, è si ereditare il metodo GetUser, ma poter definire il tipo di ritorno asseconda del provider che viene inizzializzato.

Mi spiego meglio:
Supponiamo di avere la classe astratta di cui sopra con il metodo GetUser.
Supponiamo ancora di avere tre provider concreti che derivano da essa.

ProviderA
ProviderB
ProviderC

tutti e tre erediteranno il metodo astratto GetUser.
Io vorrei poter dire (e non so come fare) il metodo GetUser implemetato nel ProviderA restituirà un tipo string, quello del ProviderB un tipo List<Object> e quello del ProviderC un int.

Sono sicuro che attraverso i Generic si possa fare, ma non so come procedere.

Potete darmi un consiglio.

Grazie mille

Ciao Matteo, grazie un migliardo di volte per avermi risposto. Si sono daccordo con te finchè il metodo da sovrascrivere ha una firma ben definita, ma se invece di venir dichiarato con una firma del genere:

public abstract string GetUser(string username)

fosse dichiarato come:

public abstract T GetUser(string username)

magari le cose sarebbero diverse.

Perdonami se scrivo delle minchia......., ma non ho molta dimestichezza in questo genere di cose, semplicemente perchè è da poco che mi ci sono avvicinato e comunque mi sembrano costrutti molto potenti.

Non trovi?

Daniele

L'uso dei generics come nel tuo esempio non risolve il problema ma lo complica! Nel senso che (al di là di eventuali vincoli su T) dovresti implementare ogni provider affinché restituisca T (quindi senza che a lui sia noto che si tratti di stringa, intero o classe user)
Se provi a buttar giù un po' di codice te ne accorgi immediatamente.

Detto questo ti consiglierei di rivedere la tua architettura e il modo in cui stai applicando i pattern: che senso ha che lo stesso metodo possa restituire tre oggetti così diversi (int, string e User)? Mi aspetterei sempre di ottenere un'istanza di User o, quanto meno, di IUser (un'eventuale interfaccia comune agli utenti gestiti dai 3 provider)
In caso contrario devi rinunciare alla possibilità di applicare pattern architetturali com abstract factory o provider model.

Sono pienamente d'accordo con i post fatti da m.casati e Cradle poiche implementare un'architettura a provider serve proprio a rendere il codice client indipendente dalle implementazioni del provider ,

Es.
0)Interfaccia Alfa
1)Provider A che utilizza file xml ed implemeta Alfa
2)Provider B che utilizza DB ed implemeta Alfa


Codice Client utilizza un porvider A o B (in maniera intercambiabile utilizzando l'interfaccia Alfa)

Adesso però secondo me si puo fare qualcosa nel tuo caso ad esempio

Il tipo di ritorno del tuo Provider GetUser(...) ritorna un tipo che deve implemetare un certa interfaccia Beta il codice Client utilizza l'interfaccia Beta dei tipi di ritorno (Discorso praticamente analogo al precedente).

Il mio discorso è del tutto genrale non so se sia poi effettivamente la strada giusta per risolvere il tuo problema specifico.

Saluti =)

---

Modificato da claudio_dg il 30 giugno 2010 15.03 -