Wording in .NET

In every profession there is some specific wording. The language used in .NET conversations is no different.

Here is a try to capture it in this glossary. The aim is to provide descriptions which can even be understood by inexperienced developers or people with a little technical background.

Expect this glossary to be extended over time.

.NET Glossary

Allocating

Reserving a part of memory.

Architecture

The conceptual structure of something.

In .NET this usually means one of 2 things:

• How to structure your solution
• Which CPU architecture your program supports

While setting up your solution, the first meaning is more likely meant.
While developing and coding, the last one is more likely.

Argument

The actual value passed to a method’s parameter.

Array

A list of elements, where all elements are in a consecutive block in memory (= no gaps between elements).

Application

See program.

Assembly

A .NET project compiled into a file with IL-bytecode and some informational data (aka. metadata).

This is the desired output when programming something.

Usually, the file extensions of such files are .dll or .exe (at least on Windows).

https://en.wikipedia.org/wiki/Assembly_(CLI)

Assignment

Assigning a value to a variable.

Example

Assign the value "10" to the variable "startNumber":

startNumber = 10;

Base Class Library (BCL)

The out-of-the-box code available to every .NET developer who is using .NET or .NET Core or .NET Framework. This code is provided by Microsoft.

Bool

A type that can only have the value true or false.

Byte

See numbers.

Bytecode

Low-level instructions like loading or saving a value in memory.

For the .NET-Runtime it is IL, for computer CPUs it is machine code.

https://en.wikipedia.org/wiki/Bytecode

Caller

The method that called the current method (callee).

Also paraphrased as "the calling method" or "the parent method".

Callee

The method that is called by the parent method (caller).

Also paraphrased as "the called method".

Char

A single character like ‘A’ or ‘{‘, ‘0’ or ‘$’.

See string.

Code

See sourcecode.

Code Path

When a block of code gets executed, it gets executed top to bottom. Some code blocks get skipped (conditions), some get run multiple times (loops) and some are just executed as they appear in code. At the end of every path the execution returns to the parent code path (caller).

Conditions, loops and return statements change the way of the execution.

Code Block

A section of sourcecode, usually enclosed in curly braces ({ and });

Condition

A check whether a condition is true or false.

See if, for, while for concrete examples.

Console

A textual UI.

Console programs display their information to the user by only using text.
Almost always, consoles only support keyboard input, not mouse or touch.

Especially newer consoles support displaying colorful content and updating already shown content.

Console Application

A program which uses a text UI.

Class

A reference type.

Compiler

A program that compiles a project.

https://en.wikipedia.org/wiki/Compiler

Compiling

Process when a compiler translates from developer-readable sourcecode to bytecode.

For .NET the bytecode is the .NET Runtime-readable IL-bytecode.

Constructor

A special method without a return type, that gets executed while instantiating a new instance.

There is no way around a constructor. This is the initialization code you can define for your types.

A type can have multiple constructors.

CPU

CPU stands for Central Processing Unit.
Also known as processor.

Is the "brain" of the computer which reads and executes machine code.

Most desktop processors are from Intel or AMD like the Intel Core i9-12900K or AMD Ryzen 7 5800X.

Declaration

Announcing a variable, type, field, property, method, parameters.

In C# declaration and definition are pretty much the same.
See https://stackoverflow.com/questions/4064668/declarations-vs-definitions.

Decimal

See numbers.

Definition

Defining the content of types, methods or variables.

In C# declaration and definition are pretty much the same.
See https://stackoverflow.com/questions/4064668/declarations-vs-definitions.

Desktop

Desktop can mean 3 things:

• Windows Desktop
• PC UI
• PC (platform)

When .NET developers speak about "Desktop" they usually mean the second one: the PC UI.

Also see desktop application.

Desktop Application

Refers to UI programs running on Windows, MacOS, and/or Linux.
Also known as "desktop program".

Double

See numbers.

GC or Garbage Collector

A garbage collector cleans up memory from formerly used, but now unused instances.

In .NET, the developer most of the time only cares about creating instances, but doesn’t have to care about releasing them again. This is because .NET is a managed platform, which means it manages your needed memory resources automatically.

Else

See if.

Expression

Something that can be reduced to a value.

Example

The expression 1 + 1 can be reduced to the value 2.

Extension Method

A static method which can be attached to types different from the one this method is defined on.

Extension methods must be defined in a static class and must itself be static. But this would make it only a regular static method.

To signal that this is a extension method, one must write this before the first parameter in the parameter list. The first parameter also defines on which type this method gets attached.

Example C#

public static class StringExtensions
{
    public static int GetLength(this string text)
    {
        return text.Length;
    }
}
...
// The extension method StringExtensions.GetLength can be used now on any string:
var name = "Peter";
var nameLength = name.GetLength();
// nameLength is 5

Field

A variable belonging to a class or struct.

It has a type and a name, and optionally an initialization value.
It’s used to store values belonging to a type.

Example C#

public class Example
{
    // defines a publicly accessible text field (type string) on the type Example called "Name",
    // initialized with the value "Peter"
    public string Name = "Peter";
}

Float

See numbers.

For

A loop with an initialization, condition and after-iteration-step slots, and a code block which gets executed multiple times.

Also known as for-loop.

In the initialization slot you can initialize 0 or more variables with start values. Usually, 1 counter variable gets initialized here, eg. var i = 0.

In the condition slot you define what condition must be true to execute the for-loop’s code-block, eg. i < 10.
Usually the condition checks if the counter variable is below a target value.
Before each iteration – including before the first – this check gets evaluated.

In the after-iteration slot you define code that is executed after each execution of the code block.
Usually the counter variable gets incremented, eg. i++.

Example C#

// initialize the new counter variable "i" to "0"
// check before every iteration if "i" is still below "10"
// increment "i" after every iteration
for (var i = 0; i < 10; i++)
{
    // code-block that gets executed - in this case - 10 times
}

Function

Basically a method, but not attached to a type.

As every function in C# needs to be attached to a type, C# does not support "real" functions. But static methods and extension methods ease this omission.

GUI

A graphical UI.

The program’s information is displayed using icons, colors, rectangles, images, etc.
Usually controlled by a mouse and keyboard (PC), or a touchscreen (mobile).

Modern operating systems like Windows and MacOS are examples of using a GUI, although text UIs are also supported there.

Linux is special: it has optional GUIs (yes multiple) and a first-class console.

Guid

A alpha-numeric value which is universally unique.

No other program on any computer will generate this value again!

Heap

TODO

IDE

IDE stands for Integrated Development Environment.

As sourcecode files are just regular text files, IDEs on-the-fly add coloring, suggestions, refactorings to guide and support the developer reading and writing code.

If

Checks whether a condition is true or false.

Also known as if-check, if-condition.

If the condition is true, the associated code-block gets executed.
If false, it gets skipped.

Else

The (optional) counterpart of if is else. Its code-block gets executed in the case the condition of the if-statement is false.

Example C#

var number1 = 5;
// if number1 is less than 10, then execute the code within the curly braces `{ ... }`
if (number1 < 10) // in this example this condition is always true, because 5 is less than 10
{
    // do something in this code-block
}
else
{
    // would contain code that is executed if the condition is false
}

Framework

A framework is something like a library, but it’s usually bigger in size and scope. Also the components within are more aligned to each other, so one part fits nicely to another.

The first .NET was called .NET Framework" which was provided out of the box with Windows. The "Framework" part of the name already showed, that it provided huge functionality which also was highly integrated within its parts.

The code available inside all .NETs is called Base Class Library (BCL), which also shows the line between frameworks and libraries is blurry.

Int or Integer

See numbers.

Interface

A special type that defines a common expected shape of a type.

You can think of it as of a contract where one side describes what it expects of something, and the other side providing the requested functionality.

Interfaces can be implemented by classes. A class can implement multiple interfaces.

Metaphor: A Car

A car has

• steering wheel
• gas pedal
• brake pedal
• a clutch (if not a automatic transmission)
• a gear shift

This is the contract.

Now all car brands can make cars, be it BMW, Toyota, Kia, VW, GM – it doesn’t matter: they all implement everything that’s required for their product to be considered a car.

This is an advantage also for you, the driver: You don’t have to learn to drive every "car-ish" thing from every brand, you just need to learn to drive "a car". If it has a steering wheel, gas pedal, brake pedal and a gear shift, you know what to do.

IL or CIL or MSIL Bytecode

• IL stands for Intermediate Language.
• CIL stands for Common Intermediate Language.
• MSIL stands for Microsoft Intermediate Language.

All mean the same and usually it’s just called "IL".

It’s the one and only bytecode-format the .NET-Runtime understands.

This is the main thing the .NET compiler writes into an assembly after compiling your sourcecode.

Instance

An individual "thing" that got instantiated by using the information of a given type.

One type can have any desired number of instances.

Metaphor: Built by Blueprint

If a type is a blueprint, instances are built using this blueprint.

Instantiating

Creating a concrete "thing" in memory, appropriate for the given type provided by the developer.

Metaphor: Building

If a type is a blueprint, creating something by this blueprint is instantiating.

With a given type the program knows how much memory it needs to allocate.

JSON

A textual data format which can be read by humans.

Often used for getting and returning data over the internet via web-services (i.e. ASP.NET Core).

Example: JSON Data For A Person

{
    "firstName": "John",
    "lastName": "Doe",
    "age": 40
}

Library

"Code you don’t have to write yourself".

A library can be a project in your solution, or an external project or assembly created by someone else.

Usually, external libraries are consumed via the NuGet package manager.

One library, that is always available to you, is the Base Class Library (BCL) every .NET provides out-of-the-box.

See https://en.wikipedia.org/wiki/Library_(computing)

Lambda

A succinct form of writing methods.
It consists of a (optional empty) parameter list, an arrow symbol (written as =>) and a method body.

If a lambda is just one expression, the return value is implicitly the resulting value of the line.
Eg. () => 2 is a lambda that returns 2.

If a lambda contains only 1 parameter, and the compiler can infer the type, the parenthesis can be omitted.
Eg. listOfNumbers.Where(item => item < 10) (see LINQ).

LINQ

LINQ stands for Language Integrated Query.

It’s a very powerful feature of .NET.

It is used on lists of objects. It allows to succinctly write filters and value-transformations ("map-reduce"), which would otherwise require much more code.

Example

Find all numbers in the list called aListofNumbers which are greater than 2 and less than 100, and then use these numbers, multiply them by 2, and then save the result in a new list called subListofDoubledNumbers.

var aListOfNumbers = new int[] { 1, 2, 43, 21, 600 };
var subListOfDoubledNumbers = aListOfNumbers.Where(number => number > 2 && number < 100).Select(number => number * 2).ToList()

https://en.wikipedia.org/wiki/Language_Integrated_Query

Inheritance

Inheriting fields, properties and methods from another "parent type" or "base type".

Also used to enable "is-a" semantics, eg. "Dog is an Animal and Cat is an Animal", where Animal is the base type, while Dog and Cat inherit from it.
Animal can have a method MakeSound() which then Dog and Cat implement differently:

• Dogs sound like "Wuff"
• Cats sound like "Miao".

Often used with classes.

Example: Animals

public class Animal
{
    public string Name { get; set; } // an animal has a name
    public string SoundFilepath { get; set; } // path to an mp3 with the correct sound

    public void MakeSound()
    {
        PlaySound(SoundFilepath); // play whatever path is in SoundFilepath, hopefully something meaningful
    }
}

public class Dog : Animal // ":" means "inherits from"
{
    public Dog()
    {
        SoundFilepath = "wuff.mp3"; // set the sound path when a new dog instance gets created
    }
}

public class Cat : Animal // ":" means "inherits from"
{
    public Cat()
    {
        SoundFilepath = "miao.mp3"; // set the sound path when a new cat instance gets created
    }
}

Loop

A loop repeats a code-block while a condition is still true.

See for-loop and while-loop.

Low-Level

Very basic and generic functionality that has almost no or no abstraction of the underlying hardware.

Machine Language

The bytecode a computer "speaks" natively.
Also known as machine code.

Usually, computers speak x86/x64 (on Intel or AMD PCs), or ARM64 (on mobile devices).

https://en.wikipedia.org/wiki/Machine_code

Managed

In .NET it means that the memory is not managed by the developer but by the .NET Runtime.

The developer only allocates instances in memory, the .NET Runtime with the Garbage Collector tracks if they’re still used and finally cleans up the previously used memory.

Member

A member of a type.

Members are:

• Fields
• Properties
• Methods

Method

A named code-block (belonging to a type).

A method has a name, 0 or more parameters, a method-body and a return type.

Also often referred to as functions.
The difference between functions and methods is the implicit thisparameter that is automatically provided to every method. This is only possible because methods – different from functions – are always attached to a type.

Method Body

A method body contains instructions written in a programming language like C#.

These instructions get executed top to bottom, with 1 or more code paths.
At the end of the code-paths there is a return statement, but only if the method should return some value, like the result of adding two numbers.
If the method has no return value – void– then no explicit return statement is needed and can be omitted.

Metadata

Additional (and often optional) secondary information appended to a file or object.

For example image files’ primary purpose is to store image data. But many image formats like .jpg, .png,… support metadata to include the GPS-location, the date when the picture was taken, the used camera and so on.

So metadata is used to enrich the main data.

https://en.wikipedia.org/wiki/Metadata

Modifier

Lets a developer specify the visibility and accessibility of members and types.

Also known as "Access Modifiers".

Available modifiers

Modifier	Description Type Members	Description Types
private	Only visible within the current type	Only visible within the current assembly
protected	Only visible within the current type and derived types	❌
internal	Public within assembly, private outside of assembly	Public within assembly, private for other assemblies
private internal	Public in current assembly, private for other assemblies	❌
protected internal	Public in current assembly, protected for other assemblies	❌
public	Public for all assemblies	Public for all assemblies

.NET

The name of the new .NET versions starting with version 5.

Previously it was called .NET Core, and before that there was a Windows-only version called .NET Framework.

.NET Core

The name of the re-written version of .NET Framework.

Its development started in 2016.
This version runs on Windows, Linux, MacOS, iOS, Android and Tizen.
It is many times faster and more efficient than .NET Framework.

In 2020 .NET Core got renamed to just .NET", to indicate that this version of .NET superseded .NET Framework and is the way forward.

The last version having "Core" suffix was ".NET Core 3.1" and it’s next version was simply called ".NET 5". It’s "5" because the number should be also higher than 4.8, the last version of .NET Framework – naming is hard.

.NET Framework

The first version of .NET which only ran on Windows.

The last version of .NET Framework is 4.8, and is in maintainance mode.

.NET Framework was superseded by .NET Core, now .NET.

.NET Runtime

Loads, translates and executes IL-bytecode on a computer.

It translates the already low-level IL-bytecode to the more low-level machine language, which is the lowest a program can be translated to.

Why this intermediate step? This way you compile your project 1 time and execute the produced assembly on different computers speaking different machine languages.

.NET Standard

While .NET Core was developed, it was lacking features the old .NET Framework already had. This was a problem for libraries that needed to work for the old .NET Framework and the new .NET Core.

.NET Standard was introduced to be a contract between the various .NET BCL variants, namely .NET Framework, Mono, .NET Core.

As .NET Core catched up, new versions of .NET Standard got introduced where each version extended the previous version.
Nowadays only .NET Standard 2.0 is considered relevant.
Code which only needs to run on .NET 5 or higher must not care about .NET Standard anymore but should just directly target the minimal required .NET version.

NuGet

A package manager platform for .NET.

Provides a way to easily download/update external libraries. It also supports downloading/using older versions of a package.

NuGet is integrated into Visual Studio.

NuGet consists of:

• NuGet Package Manager
• NuGet Repository
• NuGet Packages

NuGet Package Manager

A utility program which lets you install, update or uninstall a NuGet package to/of/from a project.

There is the old NuGet.exe, which was required for .NET Framework.
Since .NET Core, the NuGet functionality is built-in into .NET SDK.
Most-used commands are

• dotnet add package <packagename> --version <version>
  Adding a new package with the given version to your project.
• dotnet restore
  Restoring already added packages (eg. after checking-out your code)

NuGet Package

An external library available to you via a NuGet repository.

It’s a standard ZIP-archive, but with a special folder- and file-structure.
Its file extension is .nupkg.

Packages contain at least the library binaries (dll files) and most documentation. But they can also contain build targets/props and native binaries.
The contents are also segregated by optionally multiple target frameworks, so the compiler pick the best matching one.

NuGet Repository

A central location where you can find thousands of NuGet packages with their current and previous released versions.

The default and main NuGet repository is found at https://nuget.org.
But it can also be as simple as a local directory with .nupkg files in it.

Numbers

.NET supports numbers with dedicated types. Some have little memory size, some need to be able to hold big numbers, some support only whole numbers, some support decimal places.

Whole Numbers

Types supporting whole numbers only:

Short Name	Type Name	Bytes	Range	Target Processor Agnostic
byte	Byte	1	0 – 255	✔️
sbyte	SByte	1	-128 – 127	✔️
short	Int16	2	-32768 – 32767	✔️
ushort	UInt16	2	0 bis 65535	✔️
int	Int32	4	-2147483648 – 2147483647	✔️
uint	UInt32	4	0 – 4294967295	✔️
long	Int64	8	-9223372036854775808 – 9223372036854775807	✔️
ulong	UInt32	8	0 – 18446744073709551615	✔️
nint	IntPtr	4 or 8	Depends on target processor	❌
nuint	UIntPtr	4 or 8	Depends on target processor	❌

See https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/integral-numeric-types.

Floating Point Numbers

Types supporting whole and floating point numbers:

Short Name	Type Name	Bytes	Digits	Range	Target Processor Agnostic
float	Single	4	~6–9	±1.5 × 10−45 – ±3.4 × 1038	✔️
double	Double	8	~15–17	±5.0 × 10−324 – ±1.7 × 10308	✔️
decimal	Decimal	2	28-29	±1.0 × 10-28 to ±7.9228 × 1028	✔️

See https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/floating-point-numeric-types

Object

See instance.

Parameter

A parameter is defines an input slot to a method.

It contains a type and a name, and optionally a default value.

It is often also referred to as an argument, but that’s actually not correct. An argument is the actual value passed in an input slot (aka. parameter).

PCL or Portable Class Library

PCL was the predecessor of .NET Standard, but was not very developer friendly and rather confusing.

Nowadays it’s mostly irrelevant.

Program

A file a user can execute (start) on a computer to do some work/tasks.

On Windows programs are files with the .exe file-extension.

Programming Language

A written language which humans use to express their orders and requests to computers.

Although IDEs thankfully make them look more colorful, this written language is just plain text with grammar.

In .NET we have

• C# (pronounced "see sharp") – most used language in .NET
• F# (pronounced "eff sharp")
• Visual Basic aka. VB (pronounced "we be")

Processor

See CPU.

Project

A group of sourcecode that is related.

Maps 1-to-1 to an assembly after it is compiled.

Usually each project has its own directory in your project-directory-structure.

A project is defined by its project-file.

Project-File

A file that defines the settings and dependencies of a project.

A C# project has the .csproj file-extension.

It defines the required target framework (which minimal .NET version you need to run this code), wheater it is a library or a program, what files belong to this project (only required in old .NET Framework projects), what dependencies on other projects or external libraries (see NuGet) are required.

Property

A variable in a class with read and write methods.

Properties consist of a getter and a setter method. This allows to run code when writing (set) or reading (get) a value from a field. Both are optional, but at least one is required.

C# has a nice concise syntax for the standard case.

Examples

public string Name { get; set; } // auto-property with getter and setter being public

private string _name = "";
public string Name // property written the old verbose way, only used if the getter or setter needs to run more code than this
{ 
    get
    {
        return _name;
    }
    set
    {
        _name = value;
    }
}

Refactoring

Rewriting and/or restructuring a part of your sourcecode to improve it.

Improvements can be:

• Readability
• Maintainability
• Improve expressiveness

Techniques:

• Rename variables or methods or types
• Moving code to better suiting places
• Breaking code
• Merge code together

Reference

A reference can mean multiple things

• A location in memory
• A reference to another project ("project reference")
• A reference to a library

Reference Type

Instances of reference types are passed around by their reference (memory), therefore the name. As such everyone who got a reference can change the values of the referenced instance (when writable).

Return Type

The required type of the value a method returns.

Returned values must be convertable to the specified type, like

• Exact type match
• Sub type
• Interface implementator

Return Statement

In a method-body a special statement that instantly exits the current method execution, causing the calling method to proceed with its own method-body execution.

Software Development Kit (SDK)

Contains all files and programs necessary to build and run your own coded program. In .NETs case it’s the .NET SDK.

.NET SDK can be installed with Visual Studio or via its standalone setup which you can find at https://dot.net.

https://en.wikipedia.org/wiki/Software_development_kit

Setup

A program which knows how to install another program correctly on a computer.

Also known as Installer.

Short

See numbers.

Software-Project

The term "software-project" often refers to what .NET developers would call a solution.

Solution

A group of projects to "solve a problem" (here comes the term "solution" in .NET speak).

Usually encompasses one or more main programs with some supporting projects and/or libraries.

A solution often has its own directory with the project folders located beneath it.

Solution-File

File to specify which projects belong to this software-project and where to find them.
It also links build configurations of its projects to solution wide build configuration names like "Debug x64".

This is in an not human-friendly format and should be managed by an IDE (i.e. Visual Studio) or SDK programs.

Sourcecode

Human-readable text-files containing a programming language.

Sourcecode files are just plain text files. You don’t need a special program to view and edit them – you can even open it in the simplest text editors like Notepad (Windows).

Most sourcecode in .NET is using C# as programming language.

https://en.wikipedia.org/wiki/Source_code

Stack

TODO

Statement

Actions a program executes, like method calls, loops, definitions, assignments.

Contrary to an expression it in itself doesn’t resolve to a value.

Examples

Assigning a value to a variable: number = 10
Calling a method: Console.WriteLine(10)

Static

Specifies a member of a type to be bound to the type and not to the instances.

This means all instances share the exact same member (field, property, method).
For fields and properties this can be problematic.

Static Method

A method which has no implicit this variable.

Static methods are not bound to an instance of a type, but only to the type itself.

Struct

A type whose instances are copied around.

This means when passing a struct variable as a method argument, the code of the method may try to change it, but as it only got a copy, the original variable will still remain be unaffected. This may be a desirable behavior for certain use-cases.

A struct has the value-object semantics.

Examples of common used structs are Guid and DateTime.

Classes are vastly more used than structs because the copy behavior of structs is often not as desired as the reference behavior of classes.

String

The type for texts.

Strings are called strings, because it strings together a series characters (char) to form a text.

In many programming languages (and also in C#) strings are expressed with a start quotation mark and a end quotation mark.
I.e. "It was a dark and stormy night."

This

A variable automatically available in a method that points to the current instance of a type.

Static methods don’t have a this variable.

Type

A struct or class.

Defines which values (fields, properties) and behaviors (methods) a "thing" has.

You can think of it as a blueprint. With this blueprint you can create new objects in memory called instances. Instances built by a type are often called "Instances of <typename>", i.e. "Instances of String".

In C#, most types are reference types, like String or Console.

UI

UI stands for User Interface.

The way a program shows its information to users and gets input from them.

There are 2 types of UI:

• Text UI
• GUI

x64

A processor architecture which has its own machine language.

Although the number is lower, it is an extension to the x86 architecture and its successor.

It is used by all current Intel and AMD processors.

x86

A processor architecture which has its own machine language.

It is supported by all Intel and AMD processors.

XML

A textual data format which can be read by humans.

Often used in the old days for getting and returning data over the internet via web-services (i.e. ASP.NET).

Example: XML Data For A Person Using XML-Tags

<?xml version="1.0" encoding="UTF-8"?>
<Person>
    <FirstName>John</FirstName>
    <LastName>Doe</LastName>
    <Age>40</Age>
</Person>

Example 2: XML Data For A Person Using XML-Attributes

<?xml version="1.0" encoding="UTF-8"?>
<Person firstName="John" lastName="Doe" age="40">
</Person>

Value Object

An read-only object that is defined by the values it holds.

Think of money: if the cashier has 2 10$ bills, you don’t care which bill you get as change – they both have the same value.

Variable

A name for a location in memory.

The name of a variable may only contain letters, underscores and numbers (but not start with numbers).

Multiple variables can point to the same location in memory.

Visual Studio

An IDE from Microsoft itself to ease the developers life while developing software.

It supports some platforms and programming languages. In our case .NET and C#.

Visual Studio comes in 3 editions

• Professional – First-class support for .NET development
• Community – virtually the same as professional but free (if less than 5 developers AND revenue less than 1 million USD)
• Enterprise – extra features that are nice but often not needed even for experienced professionals

https://visualstudio.microsoft.com/

VM or Virtual Machine

In tech this means one of two things:

• A whole operating system running in a virtual computer, emulated by software
• A software managing the memory for programs

In .NET most of the time the 2nd is meant. The .NET Runtime is the virtual machine for .NET programs.

2 features are important:

• Translating IL to machine language
• Allocating and releasing memory for a .NET program while the program does its work

While

A loop which checks a condition before every loop iteratation.

If you need an initialization or an after-iteration section, use the for-loop.

Example

var number = 0;
while (number < 10)
{
    number = number + 1;
}