Che cos'è il codice gestito o non gestito nella programmazione?

Sto usando un comando specifico nel mio codice C #, che funziona bene. Tuttavia, si dice che si comporti male nel codice "non gestito".

Cos'è il codice gestito o non gestito?

Ecco del testo di MSDN sul codice non gestito .

Alcuni codici di libreria devono essere richiamati in codice non gestito (ad esempio, API di codice nativo, come Win32). Poiché ciò significa uscire dal perimetro di sicurezza per il codice gestito, è necessaria la dovuta attenzione.

Ecco alcune altre spiegazioni gratuite sul codice gestito:

• Codice eseguito dal CLR.
• Il codice destinato al Common Language Runtime, la base di .NET Framework, è noto come codice gestito.
• Il codice gestito fornisce i metadati necessari affinché il CLR fornisca servizi come la gestione della memoria, l'integrazione tra più lingue, la sicurezza dell'accesso al codice e il controllo automatico della durata degli oggetti. Tutto il codice basato su IL viene eseguito come codice gestito.
• Codice che viene eseguito nell'ambiente di esecuzione della CLI.

Per il tuo problema:

Penso che sia perché NUnit esegue il tuo codice per UnitTesting e potrebbe avere una parte di esso non gestita. Ma non ne sono sicuro, quindi non prenderlo per l'oro. Sono sicuro che qualcuno sarà in grado di darti maggiori informazioni a riguardo. Spero che sia d'aiuto!

Questo è un buon articolo sull'argomento.

Riassumere,

1. Il codice gestito non viene compilato in codice macchina ma in un linguaggio intermedio che viene interpretato ed eseguito da alcuni servizi su una macchina e che quindi opera all'interno di un framework sicuro (si spera!) Che gestisce cose pericolose come memoria e thread per te. Nell'uso moderno ciò spesso significa .NET ma non è necessario.

Un programma applicativo che viene eseguito all'interno di un motore di runtime installato nella stessa macchina. L'applicazione non può essere eseguita senza di essa. L'ambiente di runtime fornisce la libreria generale di routine software che il programma utilizza e in genere esegue la gestione della memoria. Può anche fornire la conversione just-in-time (JIT) dal codice sorgente al codice eseguibile o da una lingua intermedia al codice eseguibile. Java, Visual Basic e Common Language Runtime (CLR) di .NET sono esempi di motori di runtime. ( Leggi di più )

2. Il codice non gestito viene compilato in codice macchina e quindi eseguito direttamente dal sistema operativo. Ha quindi la capacità di fare cose dannose / potenti. Il codice gestito non lo fa. Ecco come funzionava tutto, quindi in genere è associato a cose vecchie come .dlls.

Un programma eseguibile che funziona da solo. Lanciato dal sistema operativo, il programma richiama e utilizza le routine software nel sistema operativo, ma non richiede l'utilizzo di un altro sistema software. I programmi di linguaggio assembly che sono stati assemblati in linguaggio macchina e programmi C / C ++ compilati in linguaggio macchina per una particolare piattaforma sono esempi di codice non gestito. (Altre informazioni )

3. Il codice nativo è spesso sinonimo di Unmanaged, ma non è identico.

Quando pensi a unmanaged , pensa a un codice specifico per la macchina. Come il linguaggio assembly x86. Il codice non gestito (nativo) viene compilato e collegato per essere eseguito direttamente sul processore per cui è stato progettato, escludendo per il momento tutte le cose del sistema operativo. Non è portatile, ma è veloce. Codice molto semplice, ridotto.

Il codice gestito è qualsiasi cosa, da Java al vecchio BASIC interpretativo, o tutto ciò che viene eseguito in .NET. Il codice gestito viene generalmente compilato in un codice P di livello intermedio o in un set di istruzioni di codice byte. Queste non sono istruzioni specifiche per la macchina, sebbene siano simili al linguaggio assembly. Il codice gestito isola il programma dalla macchina su cui è in esecuzione e crea un limite sicuro in cui tutta la memoria è allocata indirettamente e, in generale, non si ha accesso diretto alle risorse della macchina come porte, spazio di indirizzi di memoria, stack, ecc. L'idea è di funzionare in un ambiente più sicuro.

Per convertire da una variabile gestita, diciamo, a una non gestita, devi arrivare all'oggetto reale stesso. Probabilmente è avvolto o confezionato in una confezione aggiuntiva. Le variabili non gestite (come un 'int', per esempio) - su una macchina a 32 bit - occupano esattamente 4 byte. Non ci sono spese generali o imballaggi aggiuntivi. Il processo di passaggio da codice gestito a codice non gestito - e viceversa - si chiama " marshalling ". Permette ai tuoi programmi di oltrepassare i confini.

Nel minor numero di parole possibile:

• codice gestito = programmi .NET
• codice non gestito = programmi "normali"

Il codice gestito è ciò che creano i compilatori C # .Net, VB.Net, F # .Net ecc. Funziona con il CLR, che tra l'altro offre servizi come la garbage collection, il controllo dei riferimenti e molto altro. Quindi pensalo come, il mio codice è gestito dal CLR.

D'altra parte, il codice non gestito viene compilato direttamente nel codice macchina. Non gestisce da CLR.

Fondamentalmente il codice non gestito è il codice che non viene eseguito in .NET CLR (ovvero non VB.NET, C #, ecc.). La mia ipotesi è che NUnit abbia un runner / wrapper che non è un codice .NET (aka C ++).

Codice gestito:
codice che viene eseguito nell'ambito di un "contratto di cooperazione" con Common Language Runtime. Il codice gestito deve fornire i metadati necessari per il runtime per fornire servizi come la gestione della memoria, l'integrazione tra più lingue, la sicurezza dell'accesso al codice e il controllo automatico della durata degli oggetti. Tutto il codice basato sul linguaggio intermedio Microsoft (MSIL) viene eseguito come codice gestito.

Codice non gestito:
codice creato indipendentemente dalle convenzioni e dai requisiti di Common Language Runtime. Il codice non gestito viene eseguito nell'ambiente di runtime di linguaggio comune con servizi minimi (ad esempio, nessuna garbage collection, debug limitato e così via).

Riferimento: http://www.dotnetspider.com/forum/11612-difference-between-managed-and-unmanaged-code.aspx

NUnit carica i test unitari in un AppDomain separato e suppongo che il punto di ingresso non venga chiamato (probabilmente non necessario), quindi l'assemblaggio di voce è nullo.

Il codice gestito viene eseguito all'interno dell'ambiente di CLR, ovvero .NET runtime. In breve, tutti gli IL sono codici gestiti, ma se si utilizza un componente software di esempio VB6 o VC ++ di terze parti, si tratta di codice non gestito poiché .NET runtime (CLR) non ha controllo sull'esecuzione del codice sorgente della lingua.

Codice gestito: - Codice che forma MSIL (linguaggio intermedio) viene sviluppato dopo la compilazione del compilatore di linguaggio ed eseguito direttamente dal CLRcodice gestito. ad es .: - Tutti i 61 codici di lingua supportati da .net framework

Codice non gestito: - il codice sviluppato in precedenza .netper il quale non è disponibile il modulo MSIL e che viene eseguito CLRdirettamente CLR, reindirizzerà al sistema operativo, questo è noto come codice non gestito.

es: -COM, API Win32

• Gestito Code: codice scritto in linguaggio .NET come C #, VB.NET.
• Codice non gestito : codice non scritto in linguaggio .NET e MSIL non capisce di cosa si tratta e non può essere eseguito in CLR; come i controlli di terze parti che abbiamo usato nelle nostre applicazioni .NET che non sono create nei linguaggi .NET.

Prima di tutto capire questo, prima .NET framework, Microsoftstavano fornendo prodotti autonomi comeMFC (Visual C++), VB, FoxPro ecc.

Nel 2002, Microsoft ha unito i suoi prodotti e creato .NET framework. Ora c'è una differenza tra il modo in cui il codice è stato eseguito in precedenza e il modo in cui il codice viene gestito ed eseguito in .NET framework. Microsoft ha introdotto il concetto di CLR.NET Framework che compila il codice proveniente da qualsiasi lanugague supportato di .NET framework e fornisce funzionalità aggiuntive come memory mangement, garbage collectionecc. Ma tali funzionalità CLR non erano disponibili direttamente prima.

Quindi, se si sta creando una libreria / codice in .NET framework (compilato con CLR), viene chiamato Managed code. Puoi usare questa libreria ulteriormente in altre applicazioni / progetti .NET e anche lì CLR capirà come è stata compilata in precedenza, ed è per questo che rimane il tuo codice di gestione.

OTOH se vuoi usare le librerie che sono state scritte prima di .NET framework, allora puoi fare con alcune limitazioni, ma ricorda, dato che CLR non era lì in quel momento, quindi ora CLR non capirà e compilerà di nuovo questo codice . E questo sarà chiamatounmanaged code . Si noti che anche le librerie / assiemi creati da terze parti per fornire determinate funzionalità / strumenti possono essere considerati come codice non gestito se non compatibile con CLR.

In parole povere, Gestisci codice è qualcosa che il tuo CLR comprende e può compilarlo da solo per ulteriori esecuzioni. In .NET framework, (da qualsiasi lingua che funziona su .NET framework) Quando il codice passa a CLR, il codice fornisce alcune informazioni sui metadati, in modo che CLR possa fornire le funzionalità specificate qui . Pochi di loro sono Garbage collection, Performance improvements, cross-language integration, memory managementecc.

OTOH, il codice non modificato è qualcosa di specifico per la macchina e pronto per l'uso, non è necessario elaborarlo ulteriormente.

Da Pro C # 5 e .NET 4.5 Framework:

Managed vs. Unmanaged Code: forse il punto più importante da capire sul linguaggio C # è che può produrre codice che può essere eseguito solo all'interno del runtime .NET (non puoi mai usare C # per creare un server COM nativo o un C / C ++ non gestito applicazione). Ufficialmente parlando, il termine usato per descrivere il codice destinato al runtime .NET è codice gestito. L'unità binaria che contiene il codice gestito viene definita assembly (ulteriori dettagli sugli assembly in poco tempo). Al contrario, il codice che non può essere ospitato direttamente dal runtime .NET è definito codice non gestito.