What Is Managed or Unmanaged Code in Programming

What is managed or unmanaged code in programming?

Here is some text from MSDN about unmanaged code.

Some library code needs to call into unmanaged code (for example, native code APIs, such as Win32). Because this means going outside the security perimeter for managed code, due caution is required.

Here is some other complimentary explication about Managed code:

• Code that is executed by the CLR.
• Code that targets the common language runtime, the foundation of the .NET Framework, is known as managed code.
• Managed code supplies the metadata necessary for the CLR to provide services such as memory management, cross-language integration, code access security, and automatic lifetime control of objects. All code based on IL executes as managed code.
• Code that executes under the CLI execution environment.

For your problem:

I think it's because NUnit execute your code for UnitTesting and might have some part of it that is unmanaged. But I am not sure about it, so do not take this for gold. I am sure someone will be able to give you more information about it. Hope it helps!

managed code vs unmanaged code

From annakata's answer:

Managed code is not compiled to machine code but to an intermediate language which is interpreted and executed by some
service on a machine and is therefore operating within a (hopefully!)
secure framework which handles dangerous things like memory and
threads for you. In modern usage this frequently means .NET but does
not have to.

Unmanaged code is compiled to machine code and therefore executed by the OS directly. It therefore has the ability to do
damaging/powerful things Managed code does not. This is how everything
used to work, so typically it's associated with old stuff like .dlls

Now, what's going on under the hood?
Managed vs unmanaged is all about memory.

In managed code, the code itself doesn't directly manipulate the memory. It gives instructions to a runtime that does it on the code's behalf. That way, unsafe or illegal operations can be blocked, and the code operates in a semi-sandbox. Managed languages can and often do have unmanaged code - such is the nature of computing.

Visualize memory like a giant parking lot. The difference between a managed and unmanaged language is like this:

In a managed language, you walk up to the valet and explain that you want 10 cars parked. You don't know exactly where they're parked, but you know that the valet will gladly retrieve them for you any time you want. You also don't get to decide where they're parked - you just get to tell the valet that they need to be parked.

In an unmanaged language, it's your job to pick the spots. You could drive into other cars, park in handicapped spots, whatever- this gives you better performance (you don't have to constantly relay instructions to a valet) but you can also make a lot of stupid/dangerous mistakes.

What is managed and unmanaged code?

You can read this Wikipedia article, Managed code. Basically managed code is a Microsoft term, but the concept is not new. Consider the following definition:

An application program that is executed within a runtime engine installed in the same machine. The application cannot run without it. The runtime environment provides the general library of software routines that the program uses and typically performs memory management. It may also provide just-in-time (JIT) conversion from source code to executable code or from an intermediate language to executable code. Java, Visual Basic and .NET's Common Language Runtime (CLR) are examples of runtime engines.

Now contrast that to this definition of unmanaged code:

An executable program that runs by itself. Launched from the operating system, the program calls upon and uses the software routines in the operating system, but does not require another software system to be used. Assembly language programs that have been assembled into machine language and C/C++ programs compiled into machine language for a particular platform are examples of unmanaged code.

Difference between managed and unmanaged

Managed Code

Managed code is what Visual Basic .NET and C# compilers create. It runs on the CLR (Common Language Runtime), which, among other things, offers services like garbage collection, run-time type checking, and reference checking. So, think of it as, "My code is managed by the CLR."

Visual Basic and C# can only produce managed code, so, if you're writing an application in one of those languages you are writing an application managed by the CLR. If you are writing an application in Visual C++ .NET you can produce managed code if you like, but it's optional.

Unmanaged Code

Unmanaged code compiles straight to machine code. So, by that definition all code compiled by traditional C/C++ compilers is 'unmanaged code'. Also, since it compiles to machine code and not an intermediate language it is non-portable.

No free memory management or anything else the CLR provides.

Since you cannot create unmanaged code with Visual Basic or C#, in Visual Studio all unmanaged code is written in C/C++.

Mixing the two

Since Visual C++ can be compiled to either managed or unmanaged code it is possible to mix the two in the same application. This blurs the line between the two and complicates the definition, but it's worth mentioning just so you know that you can still have memory leaks if, for example, you're using a third party library with some badly written unmanaged code.

Here's an example I found by googling:

#using <mscorlib.dll>
using namespace System;

#include "stdio.h"

void ManagedFunction()
{
    printf("Hello, I'm managed in this section\n");
}

#pragma unmanaged
UnmanagedFunction()
{
    printf("Hello, I am unmanaged through the wonder of IJW!\n");
    ManagedFunction();
}

#pragma managed
int main()
{
    UnmanagedFunction();
    return 0;
}

What is the difference in managed and unmanaged code, memory and size?

Short answer:

• Managed code is .NET code (VB.NET, C# etc.) that you write and compile to .NET CIL.
• Unmanaged code is code that is not under .NET that compiles to direct machine code.

Long answer:

What Is Managed Code?

Managed Code is what Visual Basic .NET and C# compilers create. It compiles to Intermediate Language (IL), not to machine code that could run directly on your computer. The CIL is kept in a file called an assembly, along with metadata that describes the classes, methods, and attributes (such as security requirements) of the code you've created. This assembly is the one-stop-shopping unit of deployment in the .NET world. You copy it to another server to deploy the assembly there—and often that copying is the only step required in the deployment.

Managed code runs in the Common Language Runtime. The runtime offers a wide variety of services to your running code. In the usual course of events, it first loads and verifies the assembly to make sure the CIL is okay. Then, just in time, as methods are called, the runtime arranges for them to be compiled to machine code suitable for the machine the assembly is running on, and caches this machine code to be used the next time the method is called. (This is called Just In Time, or JIT compiling, or often just Jitting.)

As the assembly runs, the runtime continues to provide services such as security, memory management, threading, and the like. The application is managed by the runtime.

Visual Basic .NET and C# can produce only managed code. If you're working with those applications, you are making managed code. Visual C++ .NET can produce managed code if you like: When you create a project, select one of the application types whose name starts with .Managed., such as .Managed C++ application..

What Is Unmanaged Code?

Unmanaged code is what you use to make before Visual Studio .NET 2002 was released. Visual Basic 6, Visual C++ 6, heck, even that 15-year old C compiler you may still have kicking around on your hard drive all produced unmanaged code. It compiled directly to machine code that ran on the machine where you compiled it—and on other machines as long as they had the same chip, or nearly the same. It didn't get services such as security or memory management from an invisible runtime; it got them from the operating system. And importantly, it got them from the operating system explicitly, by asking for them, usually by calling an API provided in the Windows SDK. More recent unmanaged applications got operating system services through COM calls.

Unlike the other Microsoft languages in Visual Studio, Visual C++ can create unmanaged applications. When you create a project and select an application type whose name starts with MFC, ATL, or Win32, you're creating an unmanaged application.

This can lead to some confusion: When you create a .Managed C++ application., the build product is an assembly of CIL with an .exe extension. When you create an MFC application, the build product is a Windows executable file of native code, also with an .exe extension. The internal layout of the two files is utterly different. You can use the Intermediate Language Disassembler, ildasm, to look inside an assembly and see the metadata and CIL. Try pointing ildasm at an unmanaged exe and you'll be told it has no valid CLR (Common Language Runtime) header and can't be disassembled—Same extension, completely different files.

What about Native Code?

The phrase native code is used in two contexts. Many people use it as a synonym for unmanaged code: code built with an older tool, or deliberately chosen in Visual C++, that does not run in the runtime, but instead runs natively on the machine. This might be a complete application, or it might be a COM component or DLL that is being called from managed code using COM Interop or PInvoke, two powerful tools that make sure you can use your old code when you move to the new world. I prefer to say .unmanaged code. for this meaning, because it emphasizes that the code does not get the services of the runtime. For example, Code Access Security in managed code prevents code loaded from another server from performing certain destructive actions. If your application calls out to unmanaged code loaded from another server, you won't get that protection.

The other use of the phrase native code is to describe the output of the JIT compiler, the machine code that actually runs in the runtime. It's managed, but it's not CIL, it's machine code. As a result, don't just assume that native = unmanaged.

(Source)

What's the difference between Managed/Byte Code and Unmanaged/Native Code?

Managed Code == "Mansion House with an entire staff or Butlers, Maids, Cooks & Gardeners to keep the place nice"

Unmanaged Code == "Where I used to live in University"

What is the difference between managed and unmanaged DLL

The term "managed code" usually refers to code written in a managed language, such as Java or C#. The term "unmanaged code" usually refers to code written in an unmanaged language, such as C or C++. If you're coming from the .NET world, "managed" probably means C# or VB.NET, and "unmanaged" probably means C or C++.

What is Managed/Unmanaged .net code and what difference does it make to me?

Managed code is code that needs the .NET framework to run... unmanaged code doesn't. If you are writing code in C# you are writing managed code. You might interface with unmanaged code if you use Pinvoke, but if you stick to pure C# your application will be all managed code.

Is FileStream a managed or unmanaged code?

According to ILSpy, FileStream contains an awful lot of managed code, so you could argue that it is managed. However, ultimately all file I/O must resolve down to Win32 P/Invoke calls, so you could argue that it is a wrapper round unmanaged code. It rather depends on your definitions.

---

Related Topics