Présentation de .NETTour of .NET

.NET est une plateforme de développement généraliste..NET is a general purpose development platform. Elle comporte plusieurs fonctionnalités clés, telles que la prise en charge de plusieurs langages de programmation, des modèles de programmation asynchrone et simultanée et une interopérabilité native, qui permettent un large éventail de scénarios sur plusieurs plateformes.It has several key features, such as support for multiple programming languages, asynchronous and concurrent programming models, and native interoperability, which enable a wide range of scenarios across multiple platforms.

Cet article propose une visite guidée de certaines fonctionnalités principales de .NET.This article offers a guided tour through some of the key features of the .NET. Consultez la rubrique Composants architecturaux de .NET pour en savoir plus sur les parties architecturales de .NET et sur leur finalité.See the .NET Architectural Components topic to learn about the architectural pieces of .NET and what they're used for.

Guide pratique pour exécuter les exemples de codeHow to run the code samples

Pour savoir comment configurer un environnement de développement pour exécuter les exemples de code, consultez la rubrique Bien démarrer.To learn how to set up a development environment to run the code samples, see the Getting Started topic. Copiez et collez les exemples de code à partir de cette page dans votre environnement pour les exécuter.Copy and paste code samples from this page into your environment to execute them.

Langages de programmationProgramming languages

.NET prend en charge plusieurs langages de programmation..NET supports multiple programming languages. Les implémentations de .NET implémentent le Common Language Infrastructure (CLI), qui, entre autres, spécifie un runtime indépendant du langage et une interopérabilité des langages.The .NET implementations implement the Common Language Infrastructure (CLI), which among other things specifies a language-independent runtime and language interoperability. Cela signifie que vous choisissez n’importe quel langage .NET pour générer des applications et services sur .NET.This means that you choose any .NET language to build apps and services on .NET.

Microsoft développe et prend en charge activement trois langues .NET : C, F et Visual Basic.Microsoft actively develops and supports three .NET languages: C#, F#, and Visual Basic.

  • C# est simple, puissant, de type sécurisé et orienté objet, tout en conservant l’expressivité et l’élégance des langages de style C.C# is simple, powerful, type-safe, and object-oriented, while retaining the expressiveness and elegance of C-style languages. Les utilisateurs familiarisés avec le langage C et les langages similaires ont peu de difficultés à s’adapter à C#.Anyone familiar with C and similar languages finds few problems in adapting to C#. Consultez le Guide C# pour en savoir plus sur C#.Check out the C# Guide to learn more about C#.

  • F# est un langage de programmation multiplateforme et fonctionnel qui prend également en charge la programmation orientée objet et impérative traditionnelle.F# is a cross-platform, functional-first programming language that also supports traditional object-oriented and imperative programming. Consultez le Guide F# pour en savoir plus sur F#.Check out the F# Guide to learn more about F#.

  • Visual Basic est un langage facile à apprendre que vous utilisez pour créer une variété d’applications qui s’exécutent sur .NET.Visual Basic is an easy language to learn that you use to build a variety of apps that run on .NET. Parmi les langues .NET, la syntaxe de Visual Basic est la plus proche du langage humain ordinaire, ce qui rend souvent plus facile pour les personnes nouvelles au développement de logiciels.Among the .NET languages, the syntax of Visual Basic is the closest to ordinary human language, often making it easier for people new to software development.

Gestion automatique de la mémoireAutomatic memory management

.NET utilise le garbage collection (GC) pour fournir une gestion automatique de la mémoire pour les programmes..NET uses garbage collection (GC) to provide automatic memory management for programs. Le récupérateur de mémoire opère avec une approche différée de la gestion de la mémoire, préférant le débit de l’application à la collecte immédiate de la mémoire.The GC operates on a lazy approach to memory management, preferring app throughput to the immediate collection of memory. Pour plus d’informations sur le garbage collector .NET, consultez Notions de base du garbage collection (GC).To learn more about the .NET GC, check out Fundamentals of garbage collection (GC).

Les deux lignes suivantes allouent de la mémoire :The following two lines both allocate memory:

var title = ".NET Primer";
var list = new List<string>();

Il n’existe aucun mot clé analogue pour libérer de la mémoire, car la libération de mémoire se produit automatiquement quand le récupérateur de mémoire réclame la mémoire dans son exécution planifiée.There's no analogous keyword to de-allocate memory, as de-allocation happens automatically when the garbage collector reclaims the memory through its scheduled run.

Le garbage collector est un des services qui garantissent la sûreté de la mémoire.The garbage collector is one of the services that help ensure memory safety. Un programme est sûr du point de vue de la mémoire s’il accède uniquement à la mémoire allouée.A program is memory safe if it accesses only allocated memory. Par exemple, le runtime garantit qu’une application n’accède pas à la mémoire non allouée au-delà des limites d’un tableau.For instance, the runtime ensures that an app doesn't access unallocated memory beyond the bounds of an array.

Dans l’exemple suivant, le runtime lève une exception IndexOutOfRangeException pour appliquer la sûreté de la mémoire :In the following example, the runtime throws an IndexOutOfRangeException exception to enforce memory safety:

int[] numbers = new int[42];
int number = numbers[42]; // Will throw an exception (indexes are 0-based)

Utilisation des ressources non managéesWorking with unmanaged resources

Certains objets font référence à des ressources non managées.Some objects reference unmanaged resources. Les ressources non managées sont des ressources qui ne sont pas automatiquement gérées par le runtime .NET.Unmanaged resources are resources that aren't automatically maintained by the .NET runtime. Par exemple, un handle de fichier est une ressource non managée.For example, a file handle is an unmanaged resource. Un objet FileStream est un objet managé, mais il fait référence à un handle de fichier qui ne l’est pas.A FileStream object is a managed object, but it references a file handle, which is unmanaged. Quand vous avez fini d’utiliser l’objet FileStream, vous devez libérer le handle de fichier.When you're done using the FileStream, you need to release the file handle.

Dans .NET, les objets qui font référence à des ressources non managées implémentent l’interface IDisposable.In .NET, objects that reference unmanaged resources implement the IDisposable interface. Quand vous avez fini d’utiliser l’objet, vous appelez la méthode Dispose() de l’objet qui est chargée de libérer les ressources non managées.When you're done using the object, you call the object's Dispose() method, which is responsible for releasing any unmanaged resources. .Les langues NET fournissent une using déclaration pratique pour ces objets, comme le montre l’exemple suivant :.NET languages provide a convenient using statement for such objects, as shown in the following example:

using System.IO;

using (FileStream stream = GetFileStream(context))
{
    // Operations on the stream
}

Une fois que le bloc using est fini, le runtime .NET appelle automatiquement la méthode Dispose() de l’objet stream qui libère le handle de fichier.Once the using block completes, the .NET runtime automatically calls the stream object's Dispose() method, which releases the file handle. Le runtime agit également ainsi quand une exception entraîne le contrôle à laisser le bloc.The runtime also does this if an exception causes control to leave the block.

Pour plus de détails, consultez les rubriques suivantes :For more details, see the following topics:

Cohérence des typesType safety

Un objet est une instance d’un type spécifique.An object is an instance of a specific type. Les seules opérations autorisées pour un objet donné sont celles de son type.The only operations allowed for a given object are those of its type. Un type Dog peut avoir des méthodes Jump et WagTail, mais pas une méthode SumTotal.A Dog type may have Jump and WagTail methods but not a SumTotal method. Un programme appelle uniquement les méthodes appartenant à un type donné.A program only calls the methods belonging to a given type. Tous les autres appels entraînent une erreur au moment de la compilation ou une exception au moment de l’exécution (en cas d’utilisation de fonctionnalités dynamiques ou du type object).All other calls result in either a compile-time error or a run-time exception (in case of using dynamic features or object).

Les langages .NET sont orientés objet avec des hiérarchies de classes de base et dérivées..NET languages are object-oriented with hierarchies of base and derived classes. Le runtime .NET autorise uniquement les casts et les appels d’objet qui s’alignent sur la hiérarchie d’objets.The .NET runtime only allows object casts and calls that align with the object hierarchy. N’oubliez pas que chaque type défini dans un langage .NET dérive du type Object de base.Remember that every type defined in any .NET language derives from the base Object type.

Dog dog = AnimalShelter.AdoptDog(); // Returns a Dog type.
Pet pet = (Pet)dog; // Dog derives from Pet.
pet.ActCute();
Car car = (Car)dog; // Will throw - no relationship between Car and Dog.
object temp = (object)dog; // Legal - a Dog is an object.

La cohérence des types est également utilisée pour aider à appliquer l’encapsulation en garantissant la fidélité des mots clés d’accesseur.Type safety is also used to help enforce encapsulation by guaranteeing the fidelity of the accessor keywords. Les mots clés d’accesseur sont des artefacts qui contrôlent l’accès aux membres d’un type donné par un autre code.Accessor keywords are artifacts which control access to members of a given type by other code. Ils servent généralement à différentes sortes de données dans un type utilisées pour gérer son comportement.These are usually used for various kinds of data within a type that are used to manage its behavior.

private Dog _nextDogToBeAdopted = AnimalShelter.AdoptDog()

C#, Visual Basic et F# prennent en charge l’inférence de type locale.C#, Visual Basic, and F# support local type inference. L’inférence de type signifie que le compilateur déduit le type de l’expression à gauche à partir de l’expression à droite.Type inference means that the compiler deduces the type of the expression on the left-hand side from the expression on the right-hand side. Cela ne signifie pas que la cohérence des types est interrompue ou évitée.This doesn't mean that the type safety is broken or avoided. Le type résultant a un type fort avec tout ce que cela implique.The resulting type does have a strong type with everything that implies. À partir de l’exemple précédent, dog est réécrit pour présenter l’inférence de type, et le reste de l’exemple reste inchangé :From the previous example, dog is rewritten to introduce type inference, and the remainder of the example is unchanged:

var dog = AnimalShelter.AdoptDog();
var pet = (Pet)dog;
pet.ActCute();
Car car = (Car)dog; // will throw - no relationship between Car and Dog
object temp = (object)dog; // legal - a Dog is an object
car = (Car)temp; // will throw - the runtime isn't fooled
car.Accelerate() // the dog won't like this, nor will the program get this far

F a encore plus de capacités d’inférence de type que l’inférence de type type type méthode-locale trouvée dans C et Visual Basic.F# has even further type inference capabilities than the method-local type inference found in C# and Visual Basic. Pour plus d’informations, consultez Type Inference (Inférence de type).To learn more, see Type Inference.

Délégués et expressions lambdaDelegates and lambdas

Un délégué est représenté par une signature de méthode.A delegate is represented by a method signature. Toute méthode avec cette signature peut être assignée au délégué et est exécutée quand celui-ci est appelé.Any method with that signature can be assigned to the delegate and is executed when the delegate is invoked.

Les délégués sont semblables aux pointeurs de fonction C++, à la différence qu’ils sont de type sécurisé.Delegates are like C++ function pointers except that they're type safe. Ils représentent une sorte de méthode déconnectée au sein du système de type CLR.They're a kind of disconnected method within the CLR type system. Les méthodes classiques sont attachées à une classe et peuvent être appelées directement uniquement par des conventions d’appel statiques ou d’instance.Regular methods are attached to a class and are only directly callable through static or instance calling conventions.

Dans .NET, les délégués sont souvent utilisés dans les gestionnaires d’événements, dans la définition des opérations asynchrones et dans les expressions lambda, qui sont la pierre angulaire de LINQ.In .NET, delegates are commonly used in event handlers, in defining asynchronous operations, and in lambda expressions, which are a cornerstone of LINQ. Pour en savoir plus, consultez la rubrique Délégués et expressions lambda.Learn more in the Delegates and lambdas topic.

GénériquesGenerics

Les génériques permettent au programmeur d’introduire un paramètre de type quand il désigne leurs classes qui permet au code client (les utilisateurs du type) de spécifier le type exact à utiliser à la place du paramètre de type.Generics allow the programmer to introduce a type parameter when designing their classes that allows the client code (the users of the type) to specify the exact type to use in place of the type parameter.

Les génériques ont été ajoutés pour aider les programmeurs à implémenter des structures de données génériques.Generics were added to help programmers implement generic data structures. Avant leur arrivée, pour qu’un List type tel que le type soit générique, objectil faudrait travailler avec des éléments de type .Before their arrival, in order for a type such as the List type to be generic, it would have to work with elements that were of type object. Cela a eu diverses performances et problèmes sémantiques, ainsi que d’éventuelles erreurs subtiles de temps de course.This had various performance and semantic problems, along with possible subtle run-time errors. Une erreur de temps de ruissellement commune est lorsqu’une structure de données contient, par exemple, des intégraux et des cordes, et qu’une InvalidCastException erreur est lancée pendant le traitement des membres de la liste.A common run-time error is when a data structure contains, for example, both integers and strings, and an InvalidCastException is thrown while processing the list's members.

L’exemple suivant montre une exécution de programme de base utilisant une instance des types List<T> :The following sample shows a basic program running using an instance of List<T> types:

using System;
using System.Collections.Generic;

namespace GenericsSampleShort
{
    public static void Main(string[] args)
    {
        // List<string> is the client way of specifying the actual type for the type parameter T
        List<string> listOfStrings = new List<string> { "First", "Second", "Third" };

        // listOfStrings can accept only strings, both on read and write.
        listOfStrings.Add("Fourth");

        // Below will throw a compile-time error, since the type parameter
        // specifies this list as containing only strings.
        listOfStrings.Add(1);
    }
}

Pour plus d’informations, consultez la rubrique Vue d’ensemble des types génériques (Génériques).For more information, see the Generic types (Generics) overview topic.

Programmation asynchroneAsync programming

La programmation asynchrone est un concept de première classe dans .NET avec prise en charge asynchrone dans le runtime, des bibliothèques de framework et des constructions de langage .NET.Async programming is a first-class concept within .NET with async support in the runtime, framework libraries, and .NET language constructs. En interne, ils sont basés sur des objets (comme Task), qui tirent parti du système d’exploitation pour effectuer aussi efficacement que possible des tâches utilisant des E/S.Internally, they're based on objects (such as Task), which take advantage of the operating system to perform I/O-bound jobs as efficiently as possible.

Pour en savoir plus sur la programmation asynchrone dans .NET, commencez par la rubrique Vue d’ensemble d’Async.To learn more about async programming in .NET, start with the Async overview topic.

LINQ (Language-Integrated Query)Language Integrated Query (LINQ)

LINQ est un ensemble puissant de fonctionnalités pour C et Visual Basic qui vous permet d’écrire un code simple et déclaratif pour l’exploitation de données.LINQ is a powerful set of features for C# and Visual Basic that allow you to write simple, declarative code for operating on data. Les données peuvent se présenter sous plusieurs formes (comme des objets en mémoire, une base de données SQL ou un document XML), mais le code LINQ que vous écrivez ne diffère généralement pas d’une source de données à l’autre.The data can be in many forms (such as in-memory objects, a SQL database, or an XML document), but the LINQ code you write typically doesn't differ by data source.

Pour en savoir plus et obtenir des exemples, consultez la rubrique LINQ (Language Integrated Query).To learn more and see some samples, see the LINQ (Language Integrated Query) topic.

Interopérabilité nativeNative interoperability

Chaque système d’exploitation inclut une interface de programmation d’application (API) qui fournit des services système.Every operating system includes an application programming interface (API) that provides system services. .NET offre plusieurs moyens d’appeler ces API..NET provides several ways to call those APIs.

Le principal moyen d’effectuer une interopérabilité native est via l’« appel de code non managé » ou P/Invoke, en forme abrégée, fonctionnalité prise en charge sur les plateformes Linux et Windows.The main way to do native interoperability is via "platform invoke" or P/Invoke for short, which is supported across Linux and Windows platforms. Un moyen de faire une interopérabilité native sur Windows uniquement est connu sous le nom de « COM Interop », utilisé pour travailler avec des composants COM dans du code managé.A Windows-only way of doing native interoperability is known as "COM interop," which is used to work with COM components in managed code. Il est basé sur l’infrastructure de P/Invoke, mais fonctionne légèrement différemment.It's built on top of the P/Invoke infrastructure, but it works in subtly different ways.

Une grande partie de la prise en charge d’interopérabilité dans Mono (et donc dans Xamarin) pour Java et Objective-C est générée de la même façon, autrement dit, ils utilisent les mêmes principes.Most of Mono's (and thus Xamarin's) interoperability support for Java and Objective-C are built similarly, that is, they use the same principles.

Pour plus d’informations sur l’interopérabilité native, consultez l’article Interopérabilité native.For more information about native interoperability, see the Native interoperability article.

Code unsafeUnsafe code

En fonction de la prise en charge du langage, le CLR vous permet d’accéder à la mémoire native et d’effectuer une opération arithmétique de pointeur par le biais de code unsafe.Depending on language support, the CLR lets you access native memory and do pointer arithmetic via unsafe code. Ces opérations sont nécessaires pour certains algorithmes et pour l’interopérabilité du système.These operations are needed for certain algorithms and system interoperability. L’utilisation de code unsafe, bien que puissante, est déconseillée, sauf si elle est nécessaire pour assurer l’interopérabilité avec les API système ou implémenter l’algorithme le plus efficace.Although powerful, use of unsafe code is discouraged unless it's necessary to interop with system APIs or implement the most efficient algorithm. Le code unsafe peut ne pas s’exécuter de la même façon dans différents environnements et perd les avantages d’un récupérateur de mémoire et de la cohérence des types.Unsafe code may not execute the same way in different environments and also loses the benefits of a garbage collector and type safety. Nous vous recommandons de restreindre et centraliser le code unsafe autant que possible et de tester ce code de manière approfondie.It's recommended to confine and centralize unsafe code as much as possible and test that code thoroughly.

L’exemple suivant est une version modifiée de la méthode ToString() à partir de la classe StringBuilder.The following example is a modified version of the ToString() method from the StringBuilder class. Il illustre comment l’utilisation de code unsafe peut implémenter efficacement un algorithme en déplaçant directement des segments de mémoire :It illustrates how using unsafe code can efficiently implement an algorithm by moving around chunks of memory directly:

public override String ToString()
{
    if (Length == 0)
        return String.Empty;

    string ret = string.FastAllocateString(Length);
    StringBuilder chunk = this;
    unsafe
    {
        fixed (char* destinationPtr = ret)
        {
            do
            {
                if (chunk.m_ChunkLength > 0)
                {
                    // Copy these into local variables so that they are stable even in the presence of ----s (hackers might do this)
                    char[] sourceArray = chunk.m_ChunkChars;
                    int chunkOffset = chunk.m_ChunkOffset;
                    int chunkLength = chunk.m_ChunkLength;

                    // Check that we will not overrun our boundaries.
                    if ((uint)(chunkLength + chunkOffset) <= ret.Length && (uint)chunkLength <= (uint)sourceArray.Length)
                    {
                        fixed (char* sourcePtr = sourceArray)
                            string.wstrcpy(destinationPtr + chunkOffset, sourcePtr, chunkLength);
                    }
                    else
                    {
                        throw new ArgumentOutOfRangeException("chunkLength", Environment.GetResourceString("ArgumentOutOfRange_Index"));
                    }
                }
                chunk = chunk.m_ChunkPrevious;
            } while (chunk != null);
        }
    }
    return ret;
}

Étapes suivantesNext steps

Si vous êtes intéressé par une présentation des fonctionnalités de C#, consultez Tour of C# (Présentation de C#).If you're interested in a tour of C# features, check out Tour of C#.

Si vous êtes intéressé par une présentation des fonctionnalités de F#, consultez Visite guidée de F#.If you're interested in a tour of F# features, see Tour of F#.

Si vous voulez vous familiariser avec l’écriture de votre propre code, visitez la page Bien démarrer.If you want to get started with writing code of your own, visit Getting Started.

Pour obtenir des informations sur les composants importants de .NET, consultez Composants architecturaux de .NET.To learn about important components of .NET, check out .NET Architectural Components.