1. Sous le volet "Projet", dans le groupe "Projet", déroulez "Importer" et sélectionnez "Un assemblage .NET".
   
2. Dans la fenêtre qui s'affiche, sélectionnez les différents assemblages .NET à intégrer dans le projet en cours.
   
   • Une zone "Recherche" permet de trouver plus rapidement l'assemblage voulu.
   • Le bouton "Sélectionner sur le disque" permet de sélectionner un assemblage n'apparaissant pas dans la liste. L'assemblage sélectionné par le bouton "Sélectionner sur le disque" est automatiquement placé en début de liste et sélectionné.
   • Le bouton "Compléter la liste automatiquement" permet de rechercher tous les assemblages disponibles sur le poste.
   • Indiquez si nécessaire le framework .NET ciblé. La liste propose les différentes versions de Microsoft. Par défaut, l'option "Automatique" est sélectionnée.
     Remarque : Selon le framework .Net ciblé, la liste des assemblages peut varier.
3. Validez. Les assemblages sélectionnés sont importés.

Utilisation des éléments de l'assemblage .NET

• Delegates : les delegates peuvent être manipulés grâce à la fonction WLangage DotNetDélégué.
  Il est également possible d'ajouter un delegate avec l'opérateur += :
  clDotNet est un ClasseGestionEvenement
  // Branchement de l'événement
  clDotNet:m_LogHandler += Proc_Test
  // ...
  // Déclenche l'événement
  clDotNet:EnvoiUnMessage("Chaine envoyée")
  
  //-------------------------------------------------
  // Gestion de l'événement
  PROCÉDURE Proc_Test(src, args)
  Info("La chaîne passée en paramètre via le délégué est " + args:get_Message())
  
• NestedType de plus de 1 niveau
• Référence
• Properties
• Tableau de plus de 1 dimension
• Structures.
• Enums.
  Il est possible de combiner des Enum provenant d'assemblages .Net à l'aide des opérateurs &, | , ||, ~ . Il est possible de convertir des enums vers des entiers ou de les construire depuis des entiers.
• Classes internes : la syntaxe à utiliser est la suivante :
  
  <Nom de l'objet> est "<Nom de la classe>"
  
  La syntaxe sans guillemets est également disponible :
  
  <Nom de l'objet> est <Nom de la classe>
  
  Exemple :
  
  O est "ClasseExterne.ClasseInterne"
  
  
  
  O est ClasseExterne.ClasseInterne
  
• Génériques :
  La syntaxe à utiliser pour instancier un générique est la suivante :
  <Nom de l'objet> est "<Nom du générique><<Type concret>>"
  Exemple d'instanciation d'un générique :
  MaListe est une Liste<CMonObjet>"
  
• Méthodes génériques :
  La syntaxe à utiliser pour appeler une méthode générique est la suivante :
  <Nom de l'objet>."<Nom de la méthode générique><<Type concret>>"(<paramètres>)
  Exemple d'appel d'une méthode générique :
  // Prototype de la méthode générique CloneListe de la classe CClone
  // CloneListe(List<T>)
  // ...
  MaListe est une Liste<entier>"
  // ...
  clClone est CClone
  MaListeCopie est une Liste<entier>" <- clClone."CloneListe<entier>"(MaListe)
  
• Méthodes d'extension :
  Les méthodes d'extension peuvent être appelées de la même manière que les méthodes de l'objet.

Limites

• Une classe WLangage ne peut pas dériver d'une classe .NET.
• Les types suivants sont gérés :
  • Date / Heure
  • Monétaires WINDEV. En sortie, les monétaires WINDEV sont convertis en décimaux.
  • Décimaux
    Un paramètre de type décimal passé depuis un assemblage .NET à une fonction WLangage est converti en monétaire si possible. Si cette conversion est impossible, le paramètre est converti en double.
  • Structures
• Les objets dérivés en .NET à partir d'une classe WLangage exportée ne sont pas gérés. Si un objet de ce type est passé en paramètre à une fonction WLangage, il est "casté" dans le type WLangage de base.
• Le passage de paramètres de type pointeur entre le WLangage et .NET n'est pas géré.
• Les membres de type "structure" des classes et/ou des collections ne sont pas visibles en .NET car les structures WLangage ne sont pas visibles en .NET. Pour contourner ce problème, il suffit de créer une classe contenant le code de la structure.
• Les membres de type "classe" des classes et/ou des collections sont visibles en .NET uniquement si la classe est elle aussi exportée.
• Attention : Les composants créés avec une version 11 ou inférieure utilisant .NET ne fonctionneront plus avec la version SaaS. Il est nécessaire de re-générer les composants avec la version SaaS.

Utiliser des assemblages standards du framework .NET 4 (et inférieur)

1. Sélectionnez le dossier "Assemblages .NET" dans le volet "Explorateur de projet".
2. Affichez le menu contextuel et sélectionnez l'option "Utiliser un assemblage .NET".
3. Dans la fenêtre qui s'affiche, cliquez sur "Remplir automatiquement une liste avec les assemblages .NET de votre disque. Attention Ce traitement peut prendre du temps.".
4. Sélectionnez les assemblages standards à utiliser (mscorlib.dll ou un autre assemblage).
5. Validez.

• Sous le volet "Projet", dans le groupe "Projet", dérouler "Liste des éléments" et sélectionner "Liste des assemblages .NET utilisés".
• Dans le volet "Explorateur de projet", dans le menu contextuel de l'élément "Assemblages .NET", sélectionner l'option "Liste des assemblages .NET utilisés dans le projet".