Dart pour C# Développeurs - Part 2
Tags: dart, csharp, dotnet, darklang
Published: 2021-06-16 04:16:39

Bonjour à tous et bienvenue à la deuxième partie de « Dart pour C# Développeurs «. La dernière fois, on a vu comment créer un projet Dart de type console en utilisant la ligne de commande, aussi on a vu la syntaxe basique et quelques types de donnés.

D’abord, on va commencer avec les types « **classe** «, ensuite les « **Délégués** «, « **Interfaces** » et « **mixins**.

## Classes
Définir une classe en Dart, celle-ci ne devrait pas être une chose très difficile, puisqu’il semble beaucoup aux classes codé en C#.
Pour donner un peu de contexte, je vais utiliser comme un exemple une classe laquelle j'appellerai « **Pokemon** « :

```csharp
// C# Code
public class Pokemon
{
        public int Id { get; set; }
        public string Name { get; set; }

        public Pokemon(int id, string name)
        {
            Id = id;
            Name = name;
        }
}
```

Utilisant Dart, celle-ci deviens:
```dart
class Pokemon {
  String Name = '';
  int Id = 0;

  Pokemon(int id, String name) {
    Name = name;
    Id = id;
  }
}
```

Bien que déclarer une classe soit facile, il est indispensable de remarquer que Dart n'a pas d'accesseurs comme en C#, c'est-à-dire que on ne doit pas indiquer si la classe est publique ou privé avec `public` ou `private`, or, il faut ajouter que ce type de déclaration existe d'une autre maniere, par exemple, pour le type privé, il est nécessaire d'ajouter `_` avant du nom de notre variable, par exemple:

```dart
class Person {
  String _Name = '';

  String get Name {
    return _Name;
  }

  Person(String name) {
    _Name = name;
  }
}

var person = Person("Clara");
print(person.Name); // "Clara"
print(person._Name); // throws error
```

D'autre part, si nous avons besoins les bondis de l’héritage sur notre classe, c’est simple de donner cette compétence, par exemple en utilisant la classe Pokemon, on va ajouter la propriété ‘Type’ en utilisant cette caractéristique d’héritier.

```csharp
// C# Code
public class Pokemon2: Pokemon
{
     public string Type { get; set; }

     Pokemon2(int id, string name, string type)
       : base(id, name)
     {
         Id = id;
         Name = name;
         Type = type;
     }
}
```

Pour faire cela en Dart, on doit utiliser le mot réservé : "*extended*".

```dart
// Dart code
class Pokemon2 extends Pokemon {
  String Type = '';
  Pokemon2(int id, String name, String type) : super(id, name) {
    Type = type;
  }
}
```

Très facile ! Désormais, vous pouvez créer vos propres classes et utiliser l'héritage, maintenant on va apprendre sur les interfaces.

## **Interfaces**
En C#, nous pouvons définir la structure et les méthodes qui vont avoir nos classes, grâce aux interfaces, on peut faire un brouillon ou skeleton. Définir une interface en C# est très simple puisque on crée un fichier avec le code de l’interface, c’est-à-dire que ceux-ci suivent comment règle principal d’avoir le préfix «I« avant le nom, par exemple, l’interface de la classe « Pokemon » serait «IPokemon«.

```csharp
// Code C#
interface IPokemon
{
   void Attack();
}

// Utilisation
public class PokemonWithInterface: IPokemon
{
     public void Attack()
     {
         Console.WriteLine("Attack !!!!");
     }
}
```

Néanmoins, Dart n’a pas d’interfacés, or, on peut utiliser une classe de type abstract pour donner un effet similaire en suivant les mêmes règles de définition. Par exemple :

```dart
// Code dart
abstract class IPokemon {
  void attack();
}

// utilisation
class PokemonWithInterface implements IPokemon {
  @override
  void attack() {
    print('Attack !!!!');
  }
}
```

## **Mixins**
Avant de continuer avec le type **Délégués**, c’est important de savoir sur l’existence de **mixins**, lesquels permettent réutiliser parties de code sur multiples hiérarchies de classes. Ceux-ci sont pareils aux interfaces mais ils implémentent une fonctionnalité.  

```dart
// création
class PokeMixin {
  void Attack2() => print("Attack Mixin");
}

// implementation
class Pokemon with PokeMixin implements IPokemon {
  String Name = '';
  int Id = 0;

  Pokemon(int id, String name) {
    Name = name;
    Id = id;
  }

  @override
  void attack() {
    print('Attack Method');
  }
}

// Exemple
var poke = Pokemon(25, 'Pikachu');
print(poke.Name); // Pikachu
poke.Attack2(); // Attack Mixin
```

> Faites attention ! Je n'ai pas donner un exemple en C# puisque les mixins ne semblent pas aux mixins de Dart.

## Délégués

Un **délégué** est un type qui représente des références aux méthodes avec une liste de paramètres et un type de retour particuliers. Lorsque vous instanciez un délégué, vous pouvez associer son instance à toute méthode ayant une signature et un type de retour compatibles.

```csharp
// C# Code - Déclaration d'un délégué
public delegate void InfoDelegate(Pokemon pokemon);

// On doit définir un méthode qui corresponde à la signature du délégué.

public static void InfoMethod(Pokemon pokemon)
{
     Console.ForegroundColor = ConsoleColor.Cyan;
     Console.WriteLine("----------------");
     Console.WriteLine($"#{pokemon.Id} - {pokemon.Name}");
     Console.WriteLine("----------------");
}

// Utilisation
var pokemon = new Pokemon(25, "Pikachu");
InfoDelegate handler = InfoMethod;
handler(pokemon);
```

En Dart, nous pouvons utiliser le mot réservé **typedef** pour avoir le même effet.

```dart
// Dart Code - Déclaration d'un délégué
typedef InfoDelegate = void Function(Pokemon pokemon);

// Définition de méthode
void InfoMethod(Pokemon pokemon) {
  print('----------------');
  print('#${pokemon.Id} - ${pokemon.Name}');
  print('----------------');
}

// Exemple d'utilisation
var pokemon = Pokemon(25, 'Pikachu');
InfoDelegate handler = InfoMethod;
handler(pokemon);
```

Voila !! Désormais, on peut déclarer une classe, une interface, un mixin et un délégué. Pour le suivant et dernier article, on verra quelques exemples d'Async et Await et quelques exemples d'Events.
Finalement, Si vous aimez cet article, n'oubliez pas de donner votre like et du partager, à bientôt.