Come compilare un'applicazione .NET in codice nativo?

Se voglio eseguire un'applicazione .NET in una macchina in cui il framework .NET non è disponibile; C'è un modo per compilare l'applicazione in codice nativo?

Microsoft ha un articolo che descrive come è possibile compilare MSIL in codice nativo

Puoi usare Ngen .

Native Image Generator (Ngen.exe) è uno strumento che migliora le prestazioni delle applicazioni gestite. Ngen.exe crea immagini native, che sono file contenenti codice macchina compilato specifico del processore e le installa nella cache dell'immagine nativa sul computer locale. Il runtime può utilizzare immagini native dalla cache invece utilizzando il compilatore just-in-time (JIT) per compilare l'assembly originale.

Sfortunatamente, hai ancora bisogno delle librerie dal framework per eseguire il tuo programma. Non ci sono funzionalità che io sappia con MS .Net framework SDK che ti permetta di compilare tutti i file richiesti in un unico eseguibile

RemoteSoft crea uno strumento che compila un'applicazione .NET in un pacchetto che può essere eseguito senza .NET installato. Non ho alcuna esperienza con esso:

RemoteSoft Salamander

Come alcune delle altre risposte qui hanno menzionato, puoi usare lo strumento .NET Native per compilare la tua app in codice macchina nativo. A differenza di quelle risposte, tuttavia, ti spiegherò come farlo.

Passaggi:

1. Installa lo strumento dotnet CLI (interfaccia della riga di comando), che fa parte della nuova toolchain .NET Core. Lo useremo per compilare la nostra app; puoi trovare un buon articolo a riguardo qui.

2. Apri un prompt della shell e cdnella directory della tua app.

3. Digita questo:

   dotnet compile --native
   

Questo è tutto! Quando hai finito, la tua app verrà compilata in un singolo binario, in questo modo:

Sarà un eseguibile autonomo; nessun PDB, assembly o file di configurazione inclusi (evviva!).

In alternativa, se desideri un programma ancora più veloce, puoi eseguire questo:

dotnet compile --native --cpp

Ciò ottimizzerà il tuo programma utilizzando il generatore di codice C ++ (al contrario di RyuJIT), quindi la tua app è ancora più ottimizzata per gli scenari AOT.

Puoi trovare maggiori informazioni su questo nel repository GitHub della CLI dotnet .

Ne ho testati diversi e in questo momento l'unico che supporta .NET 3.5 e ha anche un ottimo stack di virtualizzazione è Xenocode Postbuild

Con ngen è ancora necessario avere il framework .NET installato, ma utilizzando uno strumento in quanto tale tutto il codice gestito viene compilato in codice nativo in modo da poterlo distribuire su macchine senza la presenza del framework.

Microsoft ha annunciato la sua .NET Native Preview che consentirà di eseguire applicazioni .NET senza avere il framework installato.

Dai un'occhiata: http://blogs.msdn.com/b/dotnet/archive/2014/04/02/announcing-net-native-preview.aspx

Domande frequenti: http://msdn.microsoft.com/en-US/vstudio/dn642499.aspx

Puoi scaricare Microsoft .NET Native per VS2013 da qui: http://msdn.microsoft.com/en-US/vstudio/dotnetnative

Sì, utilizzando Ngen , il generatore di immagini native. Ci sono, tuttavia, una serie di cose di cui devi essere consapevole:

• Hai ancora bisogno del CLR per eseguire il tuo eseguibile.
• Il CLR non ottimizzerà dinamicamente gli assembly in base all'ambiente in cui viene eseguito (ad esempio 486 vs 586 vs 686, ecc.)

Tutto sommato, vale la pena usare Ngen solo se è necessario ridurre il tempo di avvio dell'applicazione.

Puoi! Tuttavia sei limitato a .NET 1.1 (nessun generico per te): Mono Ahead-Of-Time compilation (AOT)

Tuttavia, questo significa che la compilazione è davvero nativa, quindi non sarai più in grado di distribuire un singolo assembly bytecode, ne avrai bisogno uno per piattaforma.

È stato originariamente progettato perché non esiste .NET o Mono per iPhone, quindi è così che hanno realizzato MonoTouch.

Puoi farlo utilizzando la nuova tecnologia di precompilazione denominata .NET Native. Controllalo qui: http://msdn.microsoft.com/en-US/vstudio/dotnetnative

Attualmente è disponibile solo per le app di Windows Store. Esegue il collegamento di un singolo componente. Quindi le librerie .NET Framework sono collegate staticamente alla tua app. Tutto viene compilato in modo nativo e gli assembly IL non vengono più distribuiti. Le app non vengono eseguite su CLR ma su un runtime ottimizzato e ridotto chiamato Managed Runtime (Mrt.dll)

Come affermato sopra, NGEN ha utilizzato un modello di compilation mix e si è affidato a IL e JIT per scenari dinamici. .NET Native non utilizza JIT ma supporta vari scenari dinamici. Gli autori del codice dovrebbero utilizzare le direttive di runtime per fornire suggerimenti al compilatore .NET Native sugli scenari dinamici che desiderano supportare.

È possibile utilizzare ngen.exe per generare un'immagine nativa, ma è comunque necessario distribuire anche il codice non nativo originale e necessita ancora del framework installato sulla macchina di destinazione.

Il che non risolve il tuo problema, davvero.

Risposta 2019: usa dotnet / corert . Può compilare progetti .NET Core in .exefile autonomi . Nessuna dipendenza (ad eccezione di librerie di sistema come kernel32.dll). Scommetto che questo è esattamente ciò di cui ha bisogno l'OP.

Dalla sua home page di GitHub:

Il compilatore CoreRT può compilare un'applicazione .NET Core gestita in un eseguibile a file singolo nativo (specifico dell'architettura) facile da distribuire. Può anche produrre librerie dinamiche o statiche autonome che possono essere utilizzate da applicazioni scritte in altri linguaggi di programmazione.

La natura di .NET è quella di poter installare app che sono state compilate in MSIL, quindi da JIT o Ngen, MSIL viene compilato in codice nativo e memorizzato localmente in una cache. Non è mai stato concepito per la generazione di un vero file .exe nativo che può essere eseguito indipendentemente dal framework .NET.

Forse c'è qualche hack che fa questo, ma non mi sembra sicuro. Ci sono troppe dinamiche che richiedono il framework, come: caricamento dinamico dell'assembly, generazione di codice MSIL, ecc.

Il motivo principale per compilare in Native è proteggere i codici, altrimenti l'MSIL compilato è come distribuire i codici sorgente nella macchina del client.

NGEN si compila in nativo ma necessita anche di implementare codici IL, questo scopo è solo quello di ridurre il tempo di avvio ma è anche inutile.

CoreRt è la versione alpha e funziona solo con semplici app di tipo helloworld.

.Net Core compila in singoli file eseguibili ma non è nemmeno un exe nativo, questo è solo un file zippato di codici IL e decomprimerà i codici nella cartella temp durante l'esecuzione.

La mia semplice domanda da parte di Microsoft è: se RyuJIT può compilare IL in nativo al volo, perché non puoi compilare lo stesso IL prima del tempo (AOT).

Sembra che soluzioni realizzabili con core RT; presto tutte le app andranno su .net core; https://www.codeproject.com/Articles/5262251/Generate-Native-Executable-from-NET-Core-3-1-Proje?msg=5753507#xx5753507xx https://docs.microsoft.com/en-us / archivio / msdn-magazine / 2018 / novembre / net-core-publishing-options-with-net-core

non testato forse con il vecchio win .net sdk possibile fare simili.

prova questo ( http://www.dotnetnative.online/ ) per compilare .net compilato exe in exe nativo, l'ho provato, è nuovo ma buono.

Penso che non sia possibile. Dovrai anche distribuire .NET FW. Se vuoi compilare l'app .NET in codice nativo, usa lo strumento NGen