[C#] Dll modulari

[Debiru]

Salve ragazzi, mi serviva un piccolo aiutino.

Ho fatto un'applicazione che racciude in essa il richiamo a determinate DLL.

Il discorso è che ogni DLL fa capo ad un prodotto diverso e non necessariamente devono essere tutte presenti.

Esiste un modo pulito per eseguire lo stesso l'applicazione senza che essa va in errore se non trova una delle DLL?

Tnx

[MItaly]

http://stackoverflow.com/questions/2...-in-the-system

[Debiru]

Purtroppo sono fermo ad un punto che non riesco a capire....

Allora, ho provato a fare una dll semplice con un solo metodo static:

public static void Avviatore(string[] args){
    //Codice
}

Poi nell'applicazione ho chiamato:

class Test
{
    [DllImport(PercorsoCompletoDLL)]
    private static extern void Avviatore(string[] args);
    static void Main(string[] args)
    {
        Avviatore(args);
    }
}

Ma purtroppo quando cerca di lanciare Avviatore mi esce una EntryPointNotFoundException.

Dovrei quindi fare in modo che Avviatore sia visto come entry point, ma per quanto stia googlando non riesco a trovare una soluzione...

[MItaly]

Aspetta, ma le dll in questione sono dll managed (scritte ad esempio in C#/VB.NET/C++-CLI/...) o dll unmanaged "classiche" (ad esempio scritte in C++ nativo)?

[Debiru]

Roba mia, quindi in C#

In sostanza quello che devo ottenere è che se il mio EXE centrale è distribuito senza tutti i suoi moduli perché gliene bastano solo certi non s'incavoli se non li trova ma solo se cerca di eseguirli.

[gibra]

Scusa, Debiru,
ma proprio tu avevi già aperto una discussione sullo stesso argomento qui
http://forum.html.it/forum/showthrea...ghlight=plugin

ed io ti ho risposto:
http://forum.html.it/forum/showthrea...2#post12932602
indicandoti dei link di riferimento.

Tra l'altro non hai più risposto, né continuato la discussione...

[Debiru]

Sto proprio messo male, me scordo le cose

Pensa che ieri ero convinto che era giovedì e invece era venerdì, se non me lo diceva nessuno oggi andavo a lavorare

Grazie Gibra per questa e l'altra risposta, poi ti faccio sapere se mi ha funzionato.

Probabilmente mi sono scordato di controllare il thread perché quella volta non m'è più servito di modularizzare e ho dovuto continuare lo sviluppo così com'era, ma ora s'è riproposto il problema... non so se è possibile chiudere questo post che al limite continuo sull'altro, gh!

[gibra]

Direi che l'altra discussione è ormai troppo vecchia (7-8 mesi fa) quindi mi pare più pratico continuare con questa.

Riposto il link del mio progetto:

Gestione moduli Plugin
http://nuke.vbcorner.net/Progetti/V...04/Default.aspx

Comunque il metodo funziona, e pure molto bene.

Nel mio progetto mostro cosette che ritengo assai interessanti, i vantaggi sono enormi e ne riassumo alcuni (nel link li descrivo più dettagliatamente):
1 - il vantaggio di modularizzare applicazioni in modo estremamente semplice
2 - il riconoscimento dei moduli DLL presenti nella cartella \Plugin è automatico
3 - i moduli DLL non vanno registrati, basta solo che siano presenti nella cartella [2]
4 - Sul form principale si creano automaticamente menu, toolbar, listview e, logicamente, tutti gli eventi relativi per accedere ai form di ogni modulo. Questo grazie agli 'attributi' che si danno ai form dei moduli DLL (posso decidere di mostrare o meno un determinato form)
5 - Le DLL possono contenere form ma anche MDIForm, quindi si può creare un'applicazione in cui vengono utilizzati più MDIForm (cosa impossibile in un progetto 'normale')
6 - si possono passare quanti parametri si vuole sia tra applicazione principale e modulo DLL, sia tra moduli diversi (ovvero, i moduli possono interagire tra loro).
Pensiamo, ad esempio, ad un programma modulare in cui le anagrafiche (clienti, fornitori, ecc...) sono gestite dall'applicazione principale, mentre le fatture, bolle, note di credi, ... sono gestite da un modulo.
In questo caso è sufficiente passare i parametri 'chiave' tra le due come: ID del soggetto, ANNO di gestione, e altri parametri utili (non vi sono limiti!).

- ......

Riguardo al punto [2] è ovvio che in un applicazione reale, se il modulo non è gratuito, si dovrà implementare una qualche modalità di registrazione della licenza, in modo che lo possano utilizzare solo i clienti che non l'hanno regolarmente acquistato.

Essendo il progetto realizzato in VB.NET dovrai 'tradurlo' in C#, ma non sarà una grande difficoltà.

[Debiru]

Salve gibra, sto testando il tuo sistema in C# ma ho dei problemi che proprio non capisco.

Premessa, la mia DLL non contiene form, è una DLL con semplici metodi.

Ho creato una soluzione con tre progetti, TestModulare che sarebbe il lanciatore, Attributi che è come il tuo ProgramsAttribute e infine Plugin che è come il tuo Form1.

In sostanza alla chiamata chiave Attribute[] atr = (Attribute[])t.GetCustomAttributes(typeof(Attributi), true); (l'equivalente del tuo Dim atr() As Attribute = t.GetCustomAttributes(GetType(ProgramsAttribute), True)) quando nel ciclo sta analizzando Plugin.dll non produce un array di attributi...

Posto il codice così puoi controllare.

TestModulare:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using AttributiGroup;
using System.Collections;

namespace TestModulare
{
    class Test
    {
        private ArrayList al=new ArrayList();

        static void Main(string[] args)
        {
            Test test = new Test();
        }

        public Test()
        {
            string sDir = @"D:\TEMP\plugin";
            foreach (string s in System.IO.Directory.GetFiles(sDir))
                CaricaAssembly(s);
        }

        private void CaricaAssembly(string pAssemblyName)
        {
            if (System.IO.File.Exists(pAssemblyName))
            {
                try
                {
                    Assembly asmb = Assembly.LoadFrom(pAssemblyName);
                    foreach (Type t in asmb.GetTypes())
                    {
                        Console.WriteLine("Namespace" + t.Namespace + " Name: " + t.Name + " GetName: " + asmb.GetName() + " BaseType: " + t.BaseType.ToString());
                        Attribute[] atr = (Attribute[])t.GetCustomAttributes(typeof(Attributi), true);
                        if (atr.Length != 0)
                        {
                            Attributi at = (Attributi)atr[0];
                            al.Add(at);
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Impossibile caricare " + pAssemblyName + Environment.NewLine + ex.Message + Environment.NewLine + ex.StackTrace);
                }
            }
        }
    }
}

Attributi:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace AttributiGroup
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = true)]
    public class Attributi : Attribute
    {
        private string mGruppo;
        private string mModulo;
        private string mDescrizione;
        public Attributi(string pGruppo, string pModulo, string pDescrizione)
        {
            Gruppo = pGruppo;
            Descrizione = pDescrizione;
            Modulo = pModulo;
        }

        private Attributi() { }
        public string Gruppo
        {
            get { return mGruppo; }
            set { mGruppo = value; }
        }
        public string Modulo
        {
            get { return mModulo; }
            set { mModulo = value; }
        }
        public string Descrizione
        {
            get { return mDescrizione; }
            set { mDescrizione = value; }
        }
    }
}

Plugin:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using AttributiGroup;

namespace Plugins
{
    [Attributi("Gruppo1", "Prima Form", "Descrizione Prima Form")]
    public class Plugin
    {
        public Plugin()
        {
            Console.WriteLine("Si dai");
        }

        public Plugin(string Str)
        {
            Console.WriteLine(Str);
        }
    }
}

[alpynet]

Originariamente inviato da gibra
....
Gestione moduli Plugin
http://nuke.vbcorner.net/Progetti/V...04/Default.aspx
....

Ciao, molto interessante questo discorso dei moduli/plugin.
Scusate se approfitto di questa discussione, vorrei chiedervi un consiglio, secondo voi, dovendo sviluppare un'applicazione gestionale, conviene seguire questa strada con moduli/plugin, oppure meglio procedere creando un unico programma? In definitiva, quando sviluppo senza plugin, creo delle classi per gestire clienti, bolle, fatture ecc..., seguendo il vostro esempio dovrei creare una dll (modulo) per i clienti, una per le bolle, una per le fatture ecc.. giusto? Ora i vantaggi dei plugin mi sembrano ovvi, aggiungere funzionalità al programma principale distribuendo/aggiungendo soltanto il modulo per quella funzione, ad esempio se voglio aggiungere la possibilità di fare preventivi, basta che aggiungo il plugin per i preventivi, mentre nel metodo classico, dovrei ricompilare il programma con la classe per i preventivi.
Ma in termini di efficenza e/o risorse impegnate, conviene il metodo classico o plugin?
Grazie