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

https://stackoverflow.com/questions/334326

22-07-2019
|

Domanda

Sto usando un comando specifico nel mio codice C #, che funziona bene. Tuttavia, si dice che si comportino in modo errato in "non gestito". codice.

Che cos'è il codice gestito o non gestito?

Soluzione

Ecco del testo di MSDN su 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 cautela.

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!

Altri suggerimenti

Questo è un buon articolo sull'argomento.

Per riassumere,

Codice gestito non è compilato in codice macchina ma in un linguaggio intermedio che viene interpretato ed eseguito da un servizio su una macchina e quindi opera all'interno di un framework sicuro (si spera!) che gestisce cose pericolose come memoria e fili 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 software routine che il programma utilizza e di solito esegue la memoria gestione. Può anche fornire la conversione just-in-time (JIT) da codice sorgente in codice eseguibile o da una lingua intermedia a codice eseguibile. Common Language Runtime di Java, Visual Basic e .NET (CLR) sono esempi di motori di runtime. ( Ulteriori informazioni )

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 funzionamento sistema, il programma richiama e utilizza le routine software nel sistema operativo, ma non richiede un altro sistema software Usato. Programmi di linguaggio assembly che sono stati assemblati nella macchina programmi in linguaggio e C / C ++ compilati in linguaggio macchina per a piattaforma particolare sono esempi di codice non gestito. ( Leggi più )

nativo è spesso sinonimo di Unmanaged, ma non è identico.

Quando pensi a non gestito , pensa al 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 variabile non gestita, devi arrivare all'oggetto reale stesso. Probabilmente è avvolto o imballato 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 - è chiamato " marshalling " ;. Permette ai tuoi programmi di oltrepassare il confine.

Nel minor numero di parole possibile:

codice gestito = programmi .NET
codice non gestito = " normale " programmi

Il codice sostanzialmente non gestito è un 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 eseguito in base a un "contratto di collaborazione" con   il Common Language Runtime. Il codice gestito deve fornire i metadati   necessario per il runtime per fornire servizi come la memoria   gestione, integrazione linguistica, sicurezza dell'accesso al codice e   controllo automatico della durata degli oggetti. Tutto il codice basato su Microsoft   linguaggio intermedio (MSIL) viene eseguito come codice gestito.

Codice non gestito:
  Codice che viene creato indipendentemente da   convenzioni e requisiti del Common Language Runtime. Non gestito   il codice viene eseguito nell'ambiente di runtime di linguaggio comune con un valore minimo   servizi (ad esempio, nessuna garbage collection, debugging 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 presumo che il punto di ingresso non sia stato chiamato (probabilmente non necessario), quindi l'assembly di entrata è nullo.

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 è gestito da CLR.

Il codice gestito viene eseguito all'interno dell'ambiente di CLR, ovvero .NET runtime. In breve, tutti gli IL sono gestiti code.Ma se stai usando alcuni software di terze parti esempio VB6 o VC ++ che sono codice non gestito come .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 da CLR chiamato codice gestito. ad es .: - Tutti i 61 codici di lingua supportati da .net framework

Codice non gestito: - codice sviluppato prima di .net per il quale il modulo MSIL non è disponibile ed è eseguito direttamente da CLR piuttosto che CLR reindirizzerà al sistema operativo, questo è noto come codice non gestito.

es: -COM, API Win32

Managed : codice scritto in linguaggio .NET come C #, VB.NET.
non gestito : codice non scritto in linguaggio .NET e MSIL lo fa non capisco di cosa si tratta e non può funzionare sotto CLR; come i controlli di terze parti che abbiamo utilizzato nelle nostre applicazioni .NET che non sono state create nei linguaggi .NET.

Prima di tutto capire questo, prima che .NET framework , Microsoft fornissero i prodotti autonomi come MFC (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 con .NET framework che compila il codice proveniente da qualsiasi lanugague supportata di .NET framework e fornisce funzionalità aggiuntive come gestione della memoria, garbage collection ecc. Ma, tali funzionalità CLR non erano disponibili direttamente prima.

Quindi se stai creando libreria / codice in .NET framework (compilato con CLR) quindi si chiama Codice gestito . Puoi usare questa libreria ulteriormente in altre applicazioni / progetti .NET, e anche lì, CLR lo farà capire come è stato compilato prima, ed è per questo che rimane tuo gestire il codice.

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à chiamato codice non gestito . 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 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 essi sono Garbage collection, miglioramenti delle prestazioni, integrazione linguistica, gestione della memoria ecc.

OTOH, 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:

Codice gestito e non gestito: Forse il punto più importante da capire sul linguaggio C # è che può produrre questo codice può essere eseguito solo all'interno del runtime .NET (non è mai possibile utilizzare C # per creare un server COM nativo o un applicazione C / C ++ non gestita). Ufficialmente parlando, il termine usato per descrivere il codice destinato al Il runtime .NET è un codice gestito. L'unità binaria che contiene il codice gestito è definita un assembly (maggiori dettagli sugli assiemi tra poco). Al contrario, codice che non può essere ospitato direttamente da .NET il runtime è definito codice non gestito.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow