[C#] Applicazioni AnyCPU, x86, x64

[Debiru]

Salve ragazzi, vorrei capire se è possibile fare una determinata cosa.

Ho un mio applicativo compilato in modalità AnyCPU che referenzia alcune dll sempre compilate AnyCPU.

Dovrei includere in questo progetto una dll (SQLite) che però è x86 esclusiva, finché l'eseguibile viene usato su macchine a 32bit va tutto bene, ma quando lo uso su macchine a 64bit non riesce a caricare la dll x86 e quindi va in errore.

Siccome non posso cambiare tutto l'ambiente per una singola dll (infatti se tutto l'applicativo fosse x86 comprese le dll referenziate non ci sarebbe problema), mi chiedevo, avendo la stessa dll SQLite x86 anche in versione x64, è possibile fare in modo che il progetto a seconda dell'ambiente utilizza una o l'altra dll?

Grazie!

[alka]

Originariamente inviato da Debiru
è possibile fare in modo che il progetto a seconda dell'ambiente utilizza una o l'altra dll?

Come vengono "collegate" (o caricate) le DLL dalla tua applicazione?

[Debiru]

Al momento con il semplice aggiungi riferimento -> sfoglia -> scegli la dll

[alka]

Originariamente inviato da Debiru
Al momento con il semplice aggiungi riferimento -> sfoglia -> scegli la dll

Se la DLL in questione è un assembly .NET, mi sembra strano che sia stata compilata in modalità x86, a meno che non vi sia una libreria nativa associata.

In questo caso, non credo ci sia un modo per fare quanto chiedi direttamente nell'IDE di Visual Studio, ma compilando da riga di comando (quando è necessario fare il deploy) si possono definire le librerie a cui fare riferimento, e in quel contesto puoi referenziare la libreria corretta.

[Debiru]

Purtroppo non è così semplice in quanto non facciamo deploy, passiamo i file direttamente, comunque ho trovato una soluzione, ora la scrivo, magari può essere utile.

La soluzione è affidarsi al sistema di System.Reflection e caricare da codice la dll giusta, ho creato per fare degli esperimenti due soluzioni, la prima di tipo libreria si chiama TestClass, con una classe di nome Classe, che ha il costruttore e un metodo:

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

namespace TestClass
{
    public class Classe
    {
        private string Stringa = "Prova";
        
        public Classe(string[] args)
        {
            if (args.Length > 0)
                Stringa = args[0];
        }

        public string GetStringa()
        {
            return Stringa;
        }
    }
}

Ho compilato questa soluzione in x86 e x64.

Poi ho creato la soluzione TestCaricaClasse di tipo eseguibile a console:

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

namespace TestCaricaClasse
{
    class Program
    {
        static void Main(string[] args)
        {
            Assembly ere = null;
            bool bCaricata = false;
            try
            {
                ere = Assembly.LoadFrom("TestClassx86.dll");
                bCaricata = true;
            }
            catch
            {
                try
                {
                    ere = Assembly.LoadFrom("TestClassx64.dll");
                    bCaricata = true;
                }
                catch { }
            }
            if (bCaricata)
            {
                object eee = ere.CreateInstance("TestClass.Classe", false, BindingFlags.Default | BindingFlags.CreateInstance, null, new object[] { new string[] { "PROVA" } }, null, new object[] { });
                Type ogttype = ere.GetType("TestClass.Classe");
                object[] bb = new object[0];
                object prova = ogttype.InvokeMember("GetStringa", BindingFlags.Default | BindingFlags.InvokeMethod, null, eee, new object[] { });
            }
        }
    }
}

Assicurarsi che le due dll TestClass create (le ho chiamate TestClassx86.dll e TestClassx64.dll) si trovino dove si trova TestCaricaClasse.exe.

Se si debugga TestCaricaClasse in modalita AnyCPU su una macchina a 32bit verrà caricata TestClassx86.dll, mentre su una macchina a 64bit darà errore il caricamento della versione x86 ma caricherà quella x64.

Se eseguite queste prove su una macchina a 64bit potete forzare TestCaricaClasse in modalità x86 e vedrete che caricherà la dll x86 invece di quella x64.

Saluti!

[alka]

Originariamente inviato da Debiru
La soluzione è affidarsi al sistema di System.Reflection e caricare da codice la dll giusta

In realtà, io ti avevo specificatamente chiesto come caricavi le DLL, e tu mi avevi risposto
Al momento con il semplice aggiungi riferimento -> sfoglia -> scegli la dll

Io supponevo che tu volessi una soluzione valida in questo scenario (te l'ho chiesto apposta); se carichi la libreria tramite Reflection, è del tutto ovvio che - dovendo specificare la libreria - puoi scegliere quella che vuoi (invece di intercettare l'eccezione, sarebbe sufficiente verificare il numero di bit del sistema e caricare la libreria appropriata), ma tu hai cambiato lo scenario.

[Debiru]

Sisi, ma io ero aperto a tutto, anche cambiare scenario

Il mondo è bello perché è vario, cmq ho adattato la mia teoria alla dll che utilizza SQLite, è stato un bagno di sangue perché convertire una dll già ben consolidata con N metodi è faticoso, ma sembra funzionare bene, stasera, quando potrò usare il pc di casa a 64bit, testerò anche l'interarchitetturalità (che termine che ho sfornato, esiste?)

[alka]

Originariamente inviato da Debiru
Sisi, ma io ero aperto a tutto, anche cambiare scenario

Ok, semplicemente non lo sapevo.