70 messaggi dal 12 settembre 2010
Ciao a tutti,
vorrei provare a realizzare un'applicazione MVC organizzando il codice in moduli.

Quello che vorrei fare è questo:
- avere il progetto principale nel quale risiedono le risorse condivise da tutti i moduli esterni (ad es. file statici, connessione DB, configurazione dell'applicazione (Startup.cs), etc...)
- gli altri moduli organizzarli (mantenendo la struttura MVC) in modo tale che ognuno realizzi una parte funzionale del progetto sfruttando le risorse del progetto principale

Ho provato a realizzare una soluzione dove all'interno:
- ho aggiunto un progetto ASP.NET Core MVC vuoto
- ho aggiunto una libreria di classi di ASP.NET Core (primo modulo)

Nel primo modulo poi ho aggiunto la cartella "Controllers" e "Views" dove all'interno ho realizzato un banalissimo controller per richiamare una semplice view da far visualizzare.

Purtroppo non ho capito come faccio a "leggere" dall'applicazione principale tutti i moduli che devono essere inclusi?

Probabilmente mi sfugge qualcosa a livello concettuale o forse è sbagliato l'approccio.

Spero che qualcuno possa aiutarmi.

Vi ringrazio in anticipo!!!

Grazie.
11.511 messaggi dal 09 febbraio 2002
Contributi
Ciao,
prova le application parts che permettono all'applicazione di scoprire e caricare risorse situate in altri assembly.
https://docs.microsoft.com/en-us/aspnet/core/mvc/advanced/app-parts?view=aspnetcore-2.2

Se devi anche registrare dei servizi o aggiungere fonti di configurazione, prova questo:
https://docs.microsoft.com/en-us/aspnet/core/fundamentals/host/platform-specific-configuration?view=aspnetcore-2.2


risorse condivise da tutti i moduli esterni (ad es. file statici, connessione DB,

Almeno le interfacce (es. IProductRepository) dovresti inserirle in un progetto class library molto snello che tutti i moduli referenzieranno, così non li obblighi a referenziare il progetto "principale". Le implementazioni di quelle interfacce poi le metti dove vuoi, anche nel progetto principale stesso.

ciao,
Moreno

Enjoy learning and just keep making
70 messaggi dal 12 settembre 2010
Ciao Moreno,
ho scaricato la demo disponibile nel link che mi hai passato:
- https://docs.microsoft.com/en-us/aspnet/core/mvc/advanced/app-parts?view=aspnetcore-2.2

Ho fatto partire il progetto di esempio ed ho iniziato a fare qualche piccola modifica per capire come funziona il tutto.

Mi sembra di aver capito che nel file "Program.cs" tramite il seguente codice:
var pluginAssembly = Assembly.Load(new AssemblyName("Plugin"));
                    services.AddMvc()
                        .AddApplicationPart(pluginAssembly)
                        .ConfigureApplicationPartManager(p =>
                            {
                                var dependentLibrary = p.ApplicationParts
                                    .FirstOrDefault(part => part.Name == "DependentLibrary");
                                if (dependentLibrary != null)
                                {
                                    p.ApplicationParts.Remove(dependentLibrary);
                                }
                            })
                        .ConfigureApplicationPartManager(p => p.FeatureProviders.Add(new GenericControllerFeatureProvider()));


l'assembly relativo "DependentLibrary" non venga reso disponibile nel progetto principale e quindi raggiungibile.

Ho provato a commentare questa parte di codice:
.ConfigureApplicationPartManager(p =>
                            {
                                var dependentLibrary = p.ApplicationParts
                                    .FirstOrDefault(part => part.Name == "DependentLibrary");
                                if (dependentLibrary != null)
                                {
                                    p.ApplicationParts.Remove(dependentLibrary);
                                }
                            })


ed ora anche il modulo "DependentLibrary" è disponibile e quindi il controller che è stato definito al suo interno.

Non capisco però una cosa...nel codice vedo il seguente richiamo:
var pluginAssembly = Assembly.Load(new AssemblyName("Plugin"));


dove "Plugin" fa riferimento ad una delle due librerie...ma commentando il codice di prima comunque riesco ad accedere alla libreria "DependentLibrary"...qualcosa non mi torna o sbaglio? Questo comando non sta indicando che deve essere caricato un determinato assembly in base al nome che passiamo?

Grazie.
11.511 messaggi dal 09 febbraio 2002
Contributi
Ciao,
scusa, non sono sicuro di aver capito la domanda. Stai chiedendo perché è necessario fare questo per Plugin ma non per DependentLibrary?
var pluginAssembly = Assembly.Load(new AssemblyName("Plugin"));
                    services.AddMvc()
                    .AddApplicationPart(pluginAssembly);


Se riesco a interpretare correttamente l'intento di chi ha scritto la documentazione, forse voleva dimostrare come i controller vengano cercati automaticamente in assembly come DependentLibrary, da cui l'applicazione ASP.NET Core ha una dipendenza a compile time. Gli altri assembly, come Plugin, da cui l'applicazione NON dipende, li puoi caricare nel modo illustrato qui sopra. Nella documentazione infatti è scritto:

By default MVC will search the dependency tree and find controllers (even in other assemblies). To load an arbitrary assembly (for instance, from a plugin that isn't referenced at compile time), you can use an application part.


Poi però vedo che l'applicazione ASP.NET Core dell'esempio referenzia pure il progetto Plugin, quindi boh.
https://github.com/aspnet/Docs/blob/e0c5affa182128a26a32dd4b43a7346e3a8a5618/aspnetcore/mvc/advanced/app-parts/sample/AppPartsSample/AppPartsSample.csproj#L13

ciao,
Moreno
Modificato da BrightSoul il 09 gennaio 2019 23.26 -

Enjoy learning and just keep making
70 messaggi dal 12 settembre 2010
Buongiorno Moreno,
esatto non capivo con quale logica era stato presentato l’esempio.

Comunque mettiamo che voglia referenziare N assembly caricandoli come è stato illustrato nell’esempio, quale sarebbe la soluzione migliore per fare in modo che l’assemblyName venga definito automaticamente? Cioè senza dover specificare puntualmente ogni assembly che voglio referenziare?

Grazie,
Alessio.
11.511 messaggi dal 09 febbraio 2002
Contributi
Ciao Alessio,
anziché Assembly.Load, usa Assembly.LoadFrom che ti permette di indicare il percorso del file dll.
https://docs.microsoft.com/it-it/dotnet/api/system.reflection.assembly.loadfrom?view=netcore-2.2#System_Reflection_Assembly_LoadFrom_System_String_

I nomi dei file li puoi ottenere enumerando una directory. Magari li posizioni dentro una sottodirectory /plugin e li leggi da lì.

ciao,
Moreno

Enjoy learning and just keep making

Torna al forum | Feed RSS

ASPItalia.com non è responsabile per il contenuto dei messaggi presenti su questo servizio, non avendo nessun controllo sui messaggi postati nei propri forum, che rappresentano l'espressione del pensiero degli autori.