Dart pour C# Développeurs
Tags: dart, csharp, dotnet, darklang
Published: 2021-04-11 21:46:46

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ilgx3salqi8el2ddo1jt.png)
Bonjour à tous et bienvenue dans un nouvel article, dans cette occasionne, je vous enseignerais comment commencer programmer en **Dartlang** étant un développeur C#. Comme d’habitude je commencerais avec les requis, cependant, je supposerais que vous ayez installé asdf avec les plugins nécessaires pour travailler avec [.NET](https://github.com/emersonsoares/asdf-dotnet-core) et [Dart](https://github.com/PatOConnor43/asdf-dart).

Pour commencer avec les choses plus basiques de Dart, on va faire une comparaison entre les deux langues de programmation, puisqu’ls partagent certaines similitudes, pourtant, j’ai divisé cet article en 2 parties afin de vous donner une meilleure compression parmi les deux codes.

## Création des projets de type Console.

Premièrement on va créer les projets de console pour Dart et C#. Pour créer un projet de console avec dart, il faut exécuter dans un Terminal la commande `dart create -t console-full SampleConsoleApp`, ensuite on va entrer dans le dossier crée avec le commande `cd SampleConsoleApp`. On peut regarder qu'il y a trois dossiers, or, le plus important sont **bin** et **lib** puisqu'ils contiendront notre code.

![En créant notre première Project Dart](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/calk4cvt11s0pjwkhowv.PNG)

* **bin**: Il contient le point d'exécution de l'application Dart. Il semble à **Program.cs** mais ici le fichier principal s'appellera avec le nom que nous le donnons pendant son création **SampleConsoleApp.dart**.
* **lib**: Sur ce dossier, on va trouver les fichiers dart qui auront nos fonctions et clases. Par default, on trouve également un fichier avec le même nom que le fichier de bin, cependant, il contient le méthode `calculate` qui est appelé dans le point d'entrée de l'autre fichier.
* **test**: Il contient tous les test qu'on va faire dans notre code. Par default, il contient un exemple. 
* **pubspec.yml** : Il contient les packages qu'on va utiliser dans notre projet. Il semble un peu à **nuget**, mais, tous les packages seraient télécharger de [pub.dev](https://pub.dev/)

```dart
// Structure basique d'une application de console en Dart
// main.dart
void main(List<String> args) {
  print("Hello World!");
}
// Pour exécuter, il faut exécuter le suivante instruction: `dart run`
```
Créer une application de console dans Visual Studio, il sera facile, cependant, je vous laisse le contenu de **Program.cs**:

```csharp
using System;

namespace CsharpToDart
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}
```
> En Dart, il n'existe pas le namespace comme en C#.
> Pour pouvoir appeller les methodes de dossier lib, il faut suivre la syntaxe:
> import 'package:<Nom project>/<nom fichier>.dart'
> Par exemple :
> import 'package:SampleConsoleApp/SampleConsoleApp.dart'

## Déclaration des variables et types de donnés.

En C#, on peut déclarer les variables en utilisant la syntaxe :
> [type de donné] {nom de variable} = <valeur>;
> Par exemple:
> string message = "Bonjour";

Aussi si nous ne connaissons le type de donné, on peut utiliser `var`, pourtant, quand la valeur soit assignée, il obtiendra le type de donné, par exemple :
> var {nom de variable} = <valeur>;
> var name = "Joaquin"; // type string
> var prix = 12.5; // type double ou float

Pour Dart, les choses sont similaires, seulement on va ajouter `dynamic` , `const` et `final` qui sont un peu semblables à `var` mais avec certains règles. Par exemple :
> **Dart**
> String message = "I'm a Dalek !!!";
> var name = "The Doctor";
> const prix = 12.5;
> final message2 = "E X T E R M I N A T E !!!!"; // Même cas que const.
> dynamic companyName = "Torchwood";

* **const**: Une fois assignée, on ne peut changer la valeur de ce variable
* **final**: Même cas que **const**, une fois assigné, la valeur ne pourra pas changer.
* **dynamic**: Il est similaire à var, puisque celui-ci est utilisé quand on ne connait pas le type de donné. Il est utilisé beaucoup dans le type Map.

Désormais on va faire une petite comparaison entre les deux langues afin de connaitre quels sont les types des donnés les plus familials :

| C# type         | .NET type     | Dart type |  Dartlang type |
| --------------- | ------------- | --------- | -------------- |
| bool            | System.Boolean| bool      | dart:core      |
| byte            | System.Byte   | ByteBuffer| dart:typed_data|
| char            | System.Char   | String    | dart:io        |
| double          | System.Double | double    | dart:core      |
| int             | System.Int32  | int       | dart:core      |
| uint            | System.UInt32 | Uint8     | dart:ffi       |
| nint            | System.IntPtr | IntPtrPointer | dart:ffi   |
| object	  | System.Object | Object    | dart:core      |
| string	  | System.String | String    | dart:core      |
| dynamic	  | System.Object | dynamic   | dart:core      |
| void            |               | void      |                |

## List, Maps, Sets
En C#, on a Arrays et Dictionary, cependant, si on a besoin de travailler avec Set, on requit d'installer `Iesi Collections` en cas d'utiliser .NET 4, tandis que la version 5, il vient avec `HashSet`.

Bien que C# ait ces structures des donnés, Dart a aussi les propres, cependant, pour le type array, il devient List, pour le Dictionary, il sera Map. Bien que C# n'ait pas supporté le type Set jusqu'à la version 5 de .NET, en Dart, on a le type Set.

Ici quelques exemples :
```dart
// List
List<String> names = ['Wanda', 'Pietro', 'Vision', 'Agatha', 'Mephisto'];
var names2 = <String>['Wanda', 'Pietro', 'Vision', 'Agatha', 'Mephisto'];

// Maps
var data = {'name': 'Wanda', 'lastname': 'Maximoff'};
var person = <String, String>{'name': 'Wanda', 'lastname': 'Maximoff'};
Map<String, String> data2 = {'name': 'Wanda', 'lastname': 'Maximoff'};

// Set
var names3 = {'Wanda', 'Pietro', 'Vision', 'Agatha', 'Mephisto'};
var persons = <String>{'Wanda', 'Pietro', 'Vision', 'Agatha', 'Mephisto'};
Set<String> characters= {'Wanda', 'Pietro', 'Vision', 'Agatha', 'Mephisto'};
```

Bref, on a vu les types de donnés qui ont pu trouver parmi les deux langues de programmation, cependant, il manque quelques structures et méthodes qu'on verra dans le suivant article. Si vous aimez cet article n'oublié de donner votre like et le partager, à bientôt.