Cette définition est tirée de MSDN

.NET (lire dotnet) Framework est le modèle de programmation de la plate-forme .NET. Les principaux composants de .NET Framework sont le Common Language Runtime et la bibliothèque de classes .NET Framework, qui contient ADO.NET, ASP.NET et Windows Forms. .NET Framework fournit un environnement d'exécution managé, un développement et un déploiement simplifiés et l'intégration à une grande variété de langages de programmation.
Consulter MSDN en ligne pour plus d'informations.

Les systèmes d'exploitations suivant supportent la conception et le déploiement d'applications .NET développées avec Delphi .NET. Les plates-formes Windows 98, Windows 98 Deuxième Édition et Windows ME, Microsoft Windows NT 4.0 ne sont pas prises en charge pour la conception et le développement avec Delphi 2005.

Vous aussi pouvez déployer des applications dans les environnements de plates-formes Windows 98 et Windows ME, Microsoft Windows NT 4.0 (Service Pack 6a requis).
L'installation du runtime Framework.NET est indispensable sur le poste cible.

• Microsoft Windows Server 2003
• Windows XP Professionnel
• Windows XP Édition familiale (Sans possibilité de création d'applications Web et de services WEB XML)
• Windows 2000 Professionnel (Service Pack 3 ou version ultérieure requis)
• Windows 2000 Server (Service Pack 3 ou version ultérieure requis)

Vous trouverez dans l'article, indiqué dans la zone lien, les bases sur les nouveautés du langage Delphi sous .NET.
De nombreuses informations n'ont pas été reportées dans cette FAQ.

Vous trouverez de nombreuses informations également dans la faq Delphi Win32/VCL, leur adaptation sous .NET est relativement aisée.

Delphi .NET supporte le passage d'un nombre de paramètre variable, et de type varié, à une procédure. La syntaxe utilisée est :

					Procedure NOM(Arguments: array of const);

L'appel se faisant par :

					{$AutoBox on}
					NOM(['String', 90, 3.14159, True, 's']);
					{$AutoBox off}

Le compilateur passe chaque élément comme un type System.Object.
La directive AutoBox, de portée locale, permet d'éviter le transtypage explicite nécessaire pour chaque élément du tableau.

					program TableauConst;
					{$APPTYPE CONSOLE}

					uses
					SysUtils;

					type
					TObjectDynArray = array of TObject;

					Procedure TabObjet(Args : array of TObject);
					var i: Integer;
					begin
					Writeln('Dans la procédure TabObjet');
					for i := Low(Args) to High(Args) do
					WriteLn('L''élément ', I, ' est du type ', Args[i].GetType.FullName,' sa valeur est ''',Args[i],'''');
					ReadLn;
					end;

					procedure TabConst(A: array of const);
					var i: Integer;
					begin
					Writeln('Dans la procédure TabConst');
					for i := Low(A) to High(A) do
					// WriteLn('Index ', I, ': ', A[i].GetType.FullName);
					WriteLn('L''élément ', I, ' est du type ', A[i].GetType.FullName,' sa valeur est ''',A[i],'''');
					ReadLn;
					end;

					// Déclare et initialise qq variables
					Var S1    : String='Une chaîne';
					I     : Integer=90;
					D1    : Double=5.6;
					D2    : Double=3.14159;
					Etat  : Boolean=True;
					S2    : String='s';

					TbObj : Array of TObject;

					begin
					// Passage d'un nombre de paramètre variable sans préciser le type, uniquement des constantes
					TabConst(['Une chaîne', 90, 5.6, 3.14159, True, 's']);
					// Passage d'un nombre paramètre variable sans préciser le type, mixte constantes et variables
					TabConst([S1, I, 5.6, D2, Etat, 's']);
					// Dans le second appel le type du 2 éme paramètre est différent
					// A la compilation 90 est vu comme un type Byte et I est de type Integer

					// Création dynamique d'un tableau
					TbObj:=New(TObjectDynArray,6);
					// La directive AutoBox permet d'éviter le transtypage explicite nécessaire pour chaque élément du tableau
					// Cette directive effectue implicitement le cast
					{$AutoBox on}
					// Renseigne le tableau avec des variables
					TbObj:= New(array[] of TObject, (S1, I, D1, D2, Etat, S2));
					{$AutoBox off}
					TabObjet(TbObj);

					{$AutoBox on}
					// Renseigne le tableau avec des variables et des constantes
					TbObj:= New(array[] of TObject, (S1, I, 5.6, D2, Etat, 's'));
					{$AutoBox off}
					TabObjet(TbObj);
					end.

Bien que cela soit déconseillé, vous pouvez utiliser les mots-clés dans vos applications. Pour cela, vous devez les faire précéder de l'opérateur perluète (&).

					Procedure &begin;
					begin
					writeln('Comment utiliser un mot-clé : &mot-clé');
					end ;

					begin
					&begin
					end.

L'initialisation des variables locales n'est plus nécessaire dans une méthode :

					var Lecteur  : StreamReader ;
					begin
					Lecteur:=nil;
					...

le code précédent n'a plus lieu d'être sous Delphi .NET étant donné que le compilateur génére le code d'initialisation des variables locales à votre place :

					L'instruction IL .locals déclare des variables locales pour la méthode courante.
					Si init (.locals init) est indiqué, les variables sont initialisées à leurs valeurs par défaut selon
					leur type.
					Les types référence sont initialisés à nulle (NIL) et les types valeur sont mis à zéro.

Vous trouverez plus d'informations en recherchant .locals dans le document suivant :
...\Microsoft.NET\SDK\v1.1\Tool Developers Guide\docs\Partition II Metadata.doc

Vous pouvez le vérifier avec le désassembleur IL Dasm.

Les énumérations du framework .NET se manipulent de la même manière qu'une énumération déclarée sous Delphi .NET.
Vous trouverez dans le tutoriel cité dans la section lien, les manipulations de base sur les énumérations du framework.