dmcs - Online nel cloud

PROGRAMMA:

NOME

mcs - Compilatore mono C#

SINOSSI

mcs [opzione] [file-sorgente]

DESCRIZIONE

mcs è il compilatore Mono C#, un'implementazione della specifica del linguaggio ECMA-334.
Puoi passare una o più opzioni per guidare il compilatore e un insieme di file sorgente. Extra
opzioni o argomenti possono essere forniti in un file di risposta. I file di risposta sono referenziati da
anteponendo il simbolo @ al nome del file di risposta.

I mcs il compilatore viene utilizzato per compilare rispetto all'ultima versione della libreria di classi di base Mono e
implementa completamente le specifiche C# 1.0, 2.0, 3.0 e 4.0.

Vedi la sezione sui pacchetti per maggiori informazioni.

Il compilatore Mono C# accetta le stesse opzioni della riga di comando del compilatore Microsoft C#
fa. Queste opzioni possono iniziare con una barra o un trattino (/checked è uguale a -checked).
Inoltre sono supportate alcune opzioni simili a GNU, che iniziano con "--". Tutto specifico per MCS
i flag che non sono disponibili nel compilatore Microsoft C# sono disponibili solo con il
Opzioni in stile GNU.

I file sorgente C# devono terminare con l'estensione ".cs". La compilazione del codice sorgente C# richiede
tutti i file che compongono una libreria, modulo o eseguibile da fornire sul comando
linea. Non c'è supporto per la compilazione parziale. Per ottenere i benefici del parziale
compilazione, dovresti compilare i programmi nei loro assembly e riferimenti successivi
loro con il flag "-r".

Il compilatore Mono C# genera immagini (file .exe) che contengono codice byte CIL che può essere
eseguito da qualsiasi sistema che implementa una macchina virtuale Common Language Infrastructure
come il motore di runtime Microsoft .NET su Windows o il motore di runtime Mono su Unix
sistemi. Gli eseguibili non sono legati a una specifica CPU o sistema operativo.

Il compilatore Mono C# per impostazione predefinita fa riferimento solo a tre assembly: mscorlib.dll, System.dll
e System.Xml.dll. Se vuoi fare riferimento a librerie extra devi specificare manualmente
utilizzando l'opzione -pkg: della riga di comando o l'opzione -r: della riga di comando. In alternativa se
vuoi ottenere tutte le librerie di sistema, puoi usare la riga di comando -pkg:dotnet
opzione.

VERSIONI

--di
Visualizza le informazioni sul compilatore Mono C#

--addmodule:MODULO1[,MODULO2]
Include i moduli specificati nell'assieme risultante. I moduli sono creati da
chiamare il compilatore con l'opzione -target:module

-controllato, -selezionato+
Imposta la modalità di compilazione predefinita su "selezionata". Questo rende tutte le operazioni matematiche
selezionato (l'impostazione predefinita è deselezionata).

-controllato-
Imposta la modalità di compilazione predefinita su "non selezionata". Questo rende tutta la matematica
operazioni deselezionate (questa è l'impostazione predefinita).

-clscheck-, -clscheck+
Disabilita o abilita i controlli Common Language Specification (CLS) (è abilitato
per impostazione predefinita).

La Common Language Specification (CLS) definisce un sottoinsieme interoperabile di tipi come
così come le convenzioni che i compilatori (produttori CLS) e gli sviluppatori devono seguire per
esporre il codice ad altri linguaggi di programmazione (consumatori CLS).

-codepage:ID
Specifica la tabella codici utilizzata per elaborare i file di input dal punto in cui si trova
specificato su. Per impostazione predefinita, i file verranno elaborati in base all'ambiente
pagina di codice nativa. Il compilatore rileverà automaticamente anche i file Unicode che
hanno un byte mark incorporato all'inizio.

Altre codifiche popolari sono 28591 (Latin1), 1252 (iso-8859-1) e 65001 (UTF-8).

MCS supporta un paio di scorciatoie: "utf8" può essere usato per specificare utf-8 invece di
utilizzando il criptico 65001 e "reset" si ripristina la gestione automatica delle code page.
Queste abbreviazioni non sono disponibili nel compilatore Microsoft.

-definire: SIMLISTA, -d: SIMLISTA
Definisce il simbolo elencato dall'elenco separato da punto e virgola SYMLIST SYMBOL. Questo
può essere testato nel codice sorgente dal preprocessore o può essere utilizzato con metodi
che sono stati contrassegnati con l'attributo Conditional.

-debug, -debug+
Genera informazioni di debug. Per ottenere le tracce dello stack con informazioni di debug,
è necessario invocare il runtime mono con il flag `--debug'. Il debug
le informazioni sono memorizzate in un file MDB situato nella stessa cartella di output come prodotto
montaggio.

-debug-
Non generare informazioni di debug.

-segno di ritardo+
Incorpora solo la chiave pubblica del nome sicuro nell'assembly. La firma effettiva deve essere
fatto in una fase successiva utilizzando lo strumento SN. Questo è utile per proteggere la chiave privata
durante lo sviluppo. Nota che la firma ritardata può essere eseguita solo utilizzando una chiave con nome sicuro
file (non un contenitore di chiavi). L'opzione equivale a includere [assembly:
AssemblyDelaySign (true)] nel codice sorgente. L'opzione del compilatore ha la precedenza
sopra gli attributi.

-ritardo-
Predefinito. Nome sicuro (firma) l'assieme utilizzando il file chiave del nome sicuro (o
contenitore). L'opzione equivale a includere [assembly: AssemblyDelaySign
(false)] nel codice sorgente. L'opzione del compilatore ha la precedenza sugli attributi.

-doc:FILE
Estrae la documentazione C#/XML dal codice sorgente e la memorizza nel dato
FILE.

-rapporto di errore
Questo flag viene ignorato dal compilatore C# di Mono ed è presente solo per consentire a MCS di essere
usato come sostituto CSC per msbuild/xbuild.

--fatale
Questo è usato per il debug del compilatore. Questo fa sì che l'emissione di errore generi un
eccezione che può essere rilevata da un debugger.

-filealign
Questo flag viene ignorato dal compilatore C# di Mono ed è presente solo per consentire a MCS di essere
usato come sostituto CSC per msbuild/xbuild.

-percorsi completi
Qualsiasi errore del codice sorgente o avviso emesso dal compilatore include il nome del file solo da
predefinito. Questa opzione fa sì che il compilatore emetta invece il percorso assoluto del file.

-file chiavi:FILE CHIAVE
Strongname (firma) l'assembly di output usando la coppia di chiavi presente nella specificata
file chiave con nome sicuro (snk). Per impostazione predefinita è richiesta una coppia di chiavi completa (o quando si utilizza
segno di ritardo-). Un file contenente solo la chiave pubblica può essere utilizzato con delaysign+. Il
è equivalente a includere [assembly: AssemblyKeyFile ("KEYFILE")] nel tuo
codice sorgente. L'opzione del compilatore ha la precedenza sugli attributi.

-contenitore chiavi:CONTENITORE
Strongname (firma) l'assembly di output usando la coppia di chiavi presente nella specificata
contenitore. Si noti che delaysign+ viene ignorato quando si utilizzano i contenitori di chiavi. L'opzione è
equivalente a includere [assembly: AssemblyKeyName ("CONTAINER")] nella tua fonte
codice. L'opzione del compilatore ha la precedenza sugli attributi.

-versione lang: TESTO
L'opzione specifica la versione della lingua da utilizzare. Il set di funzionalità è
diverso in ogni versione di C#. Questa opzione può essere utilizzata per forzare il compilatore a
consentire solo un sottoinsieme delle funzionalità. I valori possibili sono:

Predefinito
Indica al compilatore di utilizzare l'ultima versione. Equivalente è omettere il
switch (attualmente per impostazione predefinita è la specifica del linguaggio C# 4.0).

ISO-1 Limita il compilatore a utilizzare solo le prime funzionalità standardizzate ISO. L'uso di
caratteristiche come generici, classi statiche, metodi anonimi porteranno a
errore.

ISO-2 Limita il compilatore a utilizzare solo le seconde funzionalità standardizzate ISO. Questo
consente l'uso di generici, classi statiche, iteratori e metodi anonimi
per esempio.

3 Limita il compilatore a utilizzare solo le funzionalità disponibili in C# 3.0 (a
superset di ISO-1 e ISO-2).

4 Limita il compilatore a utilizzare solo le funzionalità disponibili in C# 4.0
specificazione.

sperimentale
Abilita le funzioni instabili dalle prossime versioni della lingua.

Nota che questo flag limita solo le funzionalità linguistiche disponibili per il
programmatore. Una versione degli assiemi prodotti può essere controllata utilizzando SDK opzione.

-lib:LISTA PERCORSI
Ogni percorso specificato nell'elenco separato da virgole indirizzerà il compilatore a cercare
per le librerie in quel percorso specificato.

-L PERCORSO
Indica al compilatore di cercare le librerie nel percorso specificato. Percorsi multipli
può essere fornito utilizzando l'opzione più volte.

-principale:CLASS
Indica al compilatore quale CLASS contiene il punto di ingresso. Utile quando sei
compilazione di più classi con un metodo Main.

-nostlib, -nostdlib+
Usa questo flag se vuoi compilare la libreria principale. Questo rende il compilatore
caricare i suoi tipi interni dall'assembly in fase di compilazione.

-noconfig, -noconfig+
Disabilita il caricamento della configurazione predefinita del compilatore. Il compilatore di default
ha riferimenti agli assembly di sistema.

-nowarn:LISTA AVVISI
Fa in modo che il compilatore ignori gli avvisi specificati nell'elenco separato da virgole WARNLIST>

-ottimizzare, -ottimizzare+, -ottimizzare-
Controlla le ottimizzazioni della generazione del codice del compilatore sul codice. Usando -ottimizzare o
-optimize+ attiverà le ottimizzazioni, -optimize- le disattiverà. L'impostazione predefinita in
mcs è quello di ottimizzare-. L'opzione può essere mischiata con -debug ma per il miglior debug
esperienza si consiglia di lasciare le opzioni disattivate.

-out:FNOME, -o NOME
Denomina il file di output da generare.

--analisi
Utilizzato per il benchmarking. Il compilatore analizzerà solo i suoi file di input.

-pkg:pacchetto1[,pacchettoN]
Assiemi di riferimento per i pacchetti dati.

Il compilatore invocherà pkg-config --libs sull'insieme di pacchetti specificato nella
riga di comando per ottenere librerie e directory per compilare il codice.

Questo è in genere utilizzato con componenti di terze parti, come questo:

$ mcs -pkg: gtk-sharp demo.cs

-pkg:puntonet
Questo indicherà al compilatore di fare riferimento alle librerie System.*
disponibile su una tipica installazione di framework dotnet, notare che questo non lo fa
non include tutte le librerie Mono, solo quelle System.*. Questo è un
comoda scorciatoia per chi porta il codice.

-piattaforma:ARCH
Utilizzato per specificare la piattaforma di destinazione. I valori possibili sono: anycpu,
anycpu32bitpreferred, arm, x86, x64 o itanium. L'opzione predefinita è anycpu.

-risorsa:RISORSA[,ID]
Incorpora nel file di risorse specificato. L'ID opzionale può essere utilizzato per dare un diverso
nome alla risorsa. Se non specificato, il nome della risorsa sarà il nome del file.

-linkresource:RISORSA[,ID]
Collegamenti alla RISORSA specificata. L'ID opzionale può essere utilizzato per dare un nome al
risorsa collegata.

-r:ASSEMBLAGGIO1[,ASSEMBLAGGIO2], -riferimento ASSEMBLAGGIO1[,ASSEMBLAGGIO2]
Fare riferimento agli assembly denominati. Usalo per usare le classi dall'assembly denominato in
il tuo programma. L'assieme verrà caricato dalla directory di sistema dove
tutti gli assembly live, o dal percorso fornito esplicitamente con l'opzione -L.

È inoltre possibile utilizzare un punto e virgola per separare gli assembly anziché una virgola.

-riferimento:ALIAS=ASSEMBLAGGIO
Supporto per riferimenti esterni alias per C#.

Se hai diversi assembly che forniscono gli stessi tipi, l'alias extern
il supporto ti consente di fornire nomi che il tuo software può utilizzare per dirlo
appart. I tipi da ASSEMBLY verranno esposti come ALIAS, quindi sull'origine C#
codice, devi fare:

alias esterno ALIAS;
Per portarlo nel tuo spazio dei nomi. Ad esempio, per far fronte a due librerie grafiche
che definiscono "Graphics.Point", uno in "OpenGL.dll" e uno in "Postscript.dll", tu
invocherebbe il compilatore in questo modo:

mcs -r:Postscript=Postscript.dll -r:OpenGL=OpenGL.dll

E nel tuo codice sorgente, dovresti scrivere:

alias esterno Postscript;
alias esterno OpenGL;

classe X {
// Questo è un Graphics.Point da Postscrip.dll
Postscript.Point p = nuovo Postscript.Point ();

// Questo è un Graphics.Point da OpenGL.dll
OpenGL.Point p = nuovo OpenGL.Point ();
}

-ricorso: MODELLO, --ricorso MODELLO
Esegue la compilazione ricorsiva utilizzando il modello specificato. In Unix la shell lo farà
eseguire il globbing, quindi potresti volerlo usare in questo modo:

$ mcs -recurse:'*.cs'

-sdk:VERSIONE
Utilizzato per specificare la versione degli assembly della libreria di classi di base utilizzati per la compilazione.
Sono validi i seguenti valori predefiniti: 2, 4 (predefinito) e qualsiasi valore personalizzato.
Il numero di versione predefinito indica quale valore personalizzato è specificato mcs proverà a
trova le librerie di classi base nella posizione di installazione mono PREFIX/lib/mono/ .

--conchiglia
Avvia il compilatore in modalità interattiva, fornendo una shell C# per le istruzioni e
espressioni. Una scorciatoia è usare il nitido comando direttamente.

--stacktrack
Genera una traccia dello stack nel momento in cui viene segnalato l'errore, utile per il debug del
compilatore.

-target:TIPO, -t:TIPO
Utilizzato per specificare il target desiderato. I valori possibili sono: exe (plain
eseguibile), winexe (eseguibile Windows.Forms), libreria (librerie componenti) e
modulo (libreria parziale).

--marca temporale
Un altro flag di debug. Utilizzato per visualizzare i tempi in vari punti del
processo di compilazione.

-non sicuro, -non sicuro+
Consente la compilazione di codice non sicuro.

-v Debug. Attiva l'analisi dettagliata di yacc.

--versione
Mostra la versione del compilatore.

-avviso di errore, -warnaserror+
Tutti gli avvisi del compilatore verranno segnalati come errori.

-warnaserror:W1,[Wn], -warnaerrore+:W1,[Wn]
Tratta uno o più avvisi del compilatore come errori.

-warnaserror-:W1,[Wn]
Imposta uno o più avvisi del compilatore in modo che vengano sempre minacciati come avvisi. diventa
utile se usato insieme a -warnaserror.

-warn:LIVELLO
Imposta il livello di avviso. 0 è il livello di avviso più basso e 4 è il più alto. Il
il valore predefinito è 4.

-win32res:FILE
Specifica un file di risorse Win32 (.res) da raggruppare nell'assembly risultante.

-win32icona:FILE
Associa l'icona specificata in FILE sull'output nell'assieme risultante.

-- Usalo per interrompere l'analisi delle opzioni e consentire il passaggio di parametri che sembrano opzioni
sulla riga di comando.

PACCHETTI E BIBLIOTECHE

Quando si fa riferimento a un assembly, se il nome dell'assembly è un percorso, il compilatore proverà
per caricare l'assembly specificato nel percorso. In caso contrario, il compilatore proverà
caricando l'assembly dalla directory corrente, la directory di base del compilatore e se il
assembly non si trova in nessuno di quei posti nelle directory specificate come argomenti per
il -lib: argomento del comando.

Il compilatore utilizza il percorso della libreria per individuare le librerie ed è in grado di fare riferimento alle librerie
da un particolare pacchetto se quella directory viene utilizzata. Per semplificare l'uso dei pacchetti, il
Il compilatore C# include l'opzione -pkg: della riga di comando che viene utilizzata per caricare specifici
raccolte di biblioteche.

Le librerie visibili al compilatore sono memorizzate in relazione al prefisso di installazione sotto
PREFIX/lib/mono/ chiamato PACKAGEBASE e le impostazioni predefinite per mcs, gmcs e smcs sono come
segue:

mcs Fa riferimento alla directory PACKAGEBASE/1.0

gmc Fa riferimento alla directory PACKAGEBASE/2.0

SMC Fa riferimento alla directory PACKAGEBASE/2.1

Questi sono gli unici profili di runtime esistenti. Sebbene esistano altre directory (come
3.0 e 3.5) quelli non sono realmente profili di runtime, sono semplicemente segnaposto per extra
librerie che si basano sulle fondamenta 2.0.

I fornitori di software distribuiranno il software installato relativo al PACKAGEBASE
directory. Questo è integrato nel gacutil strumento che non solo installa pubblico
assembly nella Global Assembly Cache (GAC), ma li installa anche nel
Directory PACKAGEBASE/PKG (dove PKG è il nome passato al flag -package a gacutil).

Come sviluppatore, se vuoi consumare le librerie Gtk#, invocherai il compilatore
come questo:

$ mcs -pkg:gtk-sharp-2.0 main.cs

L'opzione -pkg: indica al compilatore di recuperare le definizioni per gtk-sharp-2.0 da
pkg-config, questo equivale a passare al compilatore C# l'output di:

$ pkg-config --libs gtk-sharp-2.0

Di solito questo fa semplicemente riferimento alle librerie di PACKAGEBASE/PKG.

Sebbene ci siano nomi di directory per 3.0 e 3.5, ciò non significa che ci siano 3.0
e 3.5 edizioni o profili del compilatore. Quelle sono semplicemente nuove librerie che devono essere
referenziato manualmente o con l'appropriato -pkg: invocazione, o facendo riferimento a
direttamente le biblioteche.

SPECIALE DEFINISCE

I TRACCIA ed DEBUG defines hanno un significato speciale per il compilatore.

Per impostazione predefinita, le chiamate a metodi e proprietà nella classe System.Diagnostics.Trace non lo sono
generato a meno che il simbolo TRACE non sia definito (attraverso un "#define TRACE") nel tuo
codice sorgente, o utilizzando il --definire TRACCIA nella riga di comando.

Per impostazione predefinita, le chiamate a metodi e proprietà nella classe System.Diagnostics.Debug non lo sono
generato a meno che il simbolo DEBUG non sia definito (attraverso un "#define DEBUG") nel tuo
codice sorgente, o utilizzando il --definire DEBUG nella riga di comando.

Nota che l'effetto della definizione di TRACE e DEBUG è un'impostazione globale, anche se lo sono
definito solo in un singolo file.

DEBUG SUPPORTO

Quando si utilizza il flag "-debug", MCS genererà un file con estensione .mdb che
contiene le informazioni di debug per l'assembly generato. Questo file è consumato da
il debugger Mono (mdb).

AMBIENTE VARIABILI

MCS_COLORI
Se questa variabile è impostata, contiene una stringa nella forma "primo piano,sfondo"
che specifica quale colore utilizzare per visualizzare gli errori su alcuni terminali.

Lo sfondo è facoltativo e per impostazione predefinita è lo sfondo corrente del terminale. Il
i colori possibili per il primo piano sono: nero, rosso, rosso brillante, verde, verde acceso,
giallo, giallo acceso, blu, brightblue, magenta, brightmagenta, ciano, brightcyan,
grigio, bianco e bianco brillante.

I colori possibili per lo sfondo sono: nero, rosso, verde, giallo, blu, magenta,
ciano, grigio e bianco.

Ad esempio, puoi impostare queste variabili dalla tua shell:
esporta MCS_COLORS
MCS_COLORS=errors=bianco brillante,rosso

Puoi disabilitare la combinazione di colori incorporata impostando questa variabile su "disabilita".

NOTE

Durante la compilazione il compilatore MCS definisce il simbolo __MonoCS__, questo può essere usato da
istruzioni del pre-processore per compilare codice specifico del compilatore Mono C#. Si prega di notare che
questo simbolo serve solo per verificare il compilatore e non è utile per distinguere la compilazione
o piattaforme di distribuzione.

AUTORI

Il compilatore Mono C# è stato scritto da Miguel de Icaza, Ravi Pratap, Martin Baulig, Marek
Safar e Raja Harinath. Lo sviluppo è stato finanziato da Ximian, Novell e Marek Safar.

Usa dmcs online utilizzando i servizi onworks.net