<repo_name>Rayyz47/Prog_2019<file_sep>/Exemple DLL/DemoDll/DemoDll/Form1.cs
﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using DLL_VB;
using Dll_cSharpe;


namespace DemoDll
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            DLL dllCSharpe = new DLL();
            Class1 dllVB = new Class1();
            decimal nb1 = dllCSharpe.validationNumber(txtNb1.Text);
            decimal nb2 = dllCSharpe.validationNumber(txtNb2.Text);
            decimal nb3 = dllCSharpe.validationNumber(txtNb3.Text);
            decimal nb4 = dllCSharpe.validationNumber(txtNb4.Text);
            nb1 = dllVB.add(nb1, nb2);
            nb3 = dllVB.add(nb3, nb4);
            txtResult.Text = dllVB.add(nb1, nb3).ToString();
            clean();
        }
        private void clean()
        {
            txtNb1.Text = "";
            txtNb2.Text = "";
            txtNb3.Text = "";
            txtNb4.Text = "";
        }
    }
}
<file_sep>/programme_Vierge/cCat.cs
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace programme_Vierge
{
    class cCat : cAnimal
    {
        // recoir en parametre commbien de legs le chats a dans ce cas ci c est 4
        public cCat() : base(4)
        {

        }
        //Cette void override la void Talk pour donner une specificiter a comment un chat parle 
        public override void Talk()
        {
            frmPoly2.affichageTotal += ("Miow \r\n");
        }
        //Cette void override la void virtuel Eat pour donner une specificiter a comment un chat mange 
        public override void Eat()
        {
            frmPoly2.affichageTotal += ($"{Name} eats a fancy meal. \r\n");
        }


    }
}
<file_sep>/programme_Vierge/cGermanShepard.cs
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace programme_Vierge
{
    class cGermanShepard : cDog
    {
    }
}
<file_sep>/programme_Vierge/frmAccueilPoly.cs
﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace programme_Vierge
{
    public partial class frmAccueilPoly : Form
    {
        string name = "";
        string content = "";
        string dateToDisplay = "";
        public frmAccueilPoly()
        {
            InitializeComponent();
        }

        private void btnInfoPoly_Click(object sender, EventArgs e)
        {
            cPolymorphismInfos poly = new cPolymorphismInfos();
            poly.isAuthor();
            name = poly.nameChild;
            this.txtAuthor.Text = name;

            poly.isContent();
            content = poly.contentChild;
            txtContent.Text = content;

            poly.isDate();
            dateToDisplay = poly.dateEntryChild.ToString();
            txtDate.Text = dateToDisplay;

            string txtboxTitle = txtTitle.Text;

            if (poly.IsTitle(txtboxTitle))
            {
                MessageBox.Show(txtboxTitle);
                this.BackColor = Color.Gray;
            }
            else
            {
                MessageBox.Show("Veuillez entrer des lettres uniquement!");
                this.BackColor = Color.GreenYellow;
            }
        }

        private void btnInterface_Click(object sender, EventArgs e)
        {
            cInterface interFace = new cInterface();
            interFace.isAuthor();
            name = interFace.nameChild;
            txtAuthor.Text = name;

            interFace.isContent();
            content = interFace.contentChild;
            txtContent.Text = content;

            interFace.isDate();
            dateToDisplay = interFace.dateEntryChild.ToString();
            txtDate.Text = dateToDisplay;
        }

        private void btnInfoDll_Click(object sender, EventArgs e)
        {
            cDllInfos dllinfos = new cDllInfos();
            dllinfos.isAuthor();
            name = dllinfos.nameChild;
            txtAuthor.Text = name;

            dllinfos.isContent();
            content = dllinfos.contentChild;
            txtContent.Text = content;

            dllinfos.isDate();
            dateToDisplay = dllinfos.dateEntryChild.ToString();
            txtDate.Text = dateToDisplay;
        }

        private void btnInfoGitGithub_Click(object sender, EventArgs e)
        {
            cGit git = new cGit();
            git.isAuthor();
            name = git.nameChild;
            txtAuthor.Text = name;

            git.isContent();
            content = git.contentChild;
            txtContent.Text = content;

            git.isDate();
            dateToDisplay = git.dateEntryChild.ToString();
            txtDate.Text = dateToDisplay;

            string txtboxTitle = txtTitle.Text;

            if (git.IsTitle(txtboxTitle))
            {
                MessageBox.Show(txtboxTitle);
                this.BackColor = Color.Blue;
            }
            else
            {
                MessageBox.Show("Veuillez entrer des lettres uniquement!");
                this.BackColor = Color.Fuchsia;
            }
        }
    }
}
<file_sep>/programme_Vierge/cTemplateInfos.cs
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace programme_Vierge
{
    public abstract class cTemplateInfos
    {
        /// <summary>
        /// -- Ces 4 éléments seront envoyés aux héritiers
        /// </summary>
        /// <returns></returns>
        public abstract string isAuthor();
        public abstract string isContent();
        public abstract int isDate();

        /// <summary>
        /// Must start with an alphabetic character. Can contain the following characters: a-z A-Z 0-9 - and _
        /// </summary>
        /// <param name="titleEntry">Entrée de titre à valider</param>
        /// <returns>bool</returns>
        public virtual bool IsTitle(string titleEntry)
        {
            Regex validEntry = new Regex(@"^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[a-zA-Z]).{8,}$");
            Match match = validEntry.Match(titleEntry);
            if (match.Success)
            {
                return true;
            }
            return false;
        }
    }
}
<file_sep>/programme_Vierge/cAnimal.cs
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace programme_Vierge
{
    public abstract class cAnimal
    {
        //ici est envoiyer le nom qu on a mis dans le formulaire qui est lue
        public string Name;

        public int NumberOfLegs { get; }
        public cAnimal(int numberOfLegs)
        {
            NumberOfLegs = numberOfLegs;
        }

        //Void abstract pour dire que l animal parle 
        public abstract void Talk();
        //Une void virtuel pour dire que l animal mange donc le nom de l animal avec la caracterisque de manger 
        public virtual void Eat()
        {
            frmPoly2.affichageTotal+=($"{Name} eats! \r\n");
        }

    }

   
}

<file_sep>/programme_Vierge/cGit.cs
﻿namespace programme_Vierge
{
    class cGit : cTemplateInfos
    {
        /// <summary>
        /// -- Variables publiques contenues dans la classe enfant uniquement. Leurs valeurs seront attribuées par les éléments 
        ///    hérités du parent
        /// </summary>
        public string nameChild = "";
        public string contentChild = "";
        public int dateEntryChild = 0;

        /// <summary>
        /// --Hérite de la classe template qui est son parent. L'enfant pourra la modifier à sa guise mais doit l'avoir
        /// </summary>
        /// <returns> string de nom</returns>
        public override string isAuthor()
        {
            nameChild = "<NAME>";
            return nameChild;
        }

        public override string isContent()
        {
            contentChild = "gitgitgitgit";
            return contentChild;
        }

        /// <summary>
        /// --Hérite de la classe template qui est son parent. L'enfant pourra la modifier à sa guise mais doit l'avoir
        /// </summary>
        /// <returns> Int représentant la date</returns>
        public override int isDate()
        {
            dateEntryChild = 20190409;
            return dateEntryChild;
        }
    }
}
<file_sep>/programme_Vierge/frmAccueil.cs
﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace programme_Vierge
{
    public partial class frmAccueil : Form
    {
        public frmAccueil()
        {
            InitializeComponent();
        }

        private void btnToPoly_Click(object sender, EventArgs e)
        {
            frmAccueilPoly poly = new frmAccueilPoly();
            poly.Show();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            frmInterface frm = new frmInterface();
            frm.Show();
            Hide();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            frmPoly2 frm = new frmPoly2();
            frm.ShowDialog();
        }
    }
}
<file_sep>/programme_Vierge/cSnake.cs
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace programme_Vierge
{
    class cSnake : cAnimal
    {
        // recoit en parametre commbien de legs le serpant a dans ce cas ci c est 0
        public cSnake() : base(0)
        {

        }
        //Cette void override la void Talk pour donner une specificiter a comment un serpant parle 
        public override void Talk()
        {
            frmPoly2.affichageTotal += ("Hissssss \r\n");
        }

    }
}
<file_sep>/Exemple DLL/DLL_cSharpe/Dll_cSharpe/DLL.cs
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Dll_cSharpe
{
    public class DLL
    {
        /// <summary>
        /// Envoye un texte en paramettre et verifie si le texte contien ou est un nombre si oui retounre le nombre en question
        /// </summary>
        /// <param name="textToVal">String</param>
        /// <returns>Decimal</returns>
        public decimal validationNumber(string textToVal)
        {
            //Declare le nombre qui va etre retourner
            decimal number;
            //Verifie si le texte envoyer est bien un nombre 
            bool success = decimal.TryParse(textToVal, out number);
            //Si oui on retourne le nombre en question
            if (success) { return number; }
            //Si non on retourne 0 pour eviter que le code plante
            else { return 0;}          
        }


        /// <summary>
        /// Recois 2 nombre et retourne le resultat de ces deux nombres additionnés
        /// </summary>
        /// <param name="nb1">Decimal</param>
        /// <param name="nb2">Decimal</param>
        /// <returns>Decimal</returns>
        //Fonction de retour d'addition possibliter de surcharge jusqu'a un maximum de 4 nombres  
        public decimal add(decimal nb1, decimal nb2)
        {
            //Declare le nombre qui va etre retourner et effectue l'addition
            decimal number = nb1 + nb2;
            //Retourne le resulat
            return number;
        }

        /// <summary>
        /// Recois 3 nombre et retourne le resultat de ces deux nombres additionnés
        /// </summary>
        /// <param name="nb1">Decimal</param>
        /// <param name="nb2">Decimal</param>
        /// <param name="nb3">Decimal</param>
        /// <returns>Decimal</returns>
        public decimal add(decimal nb1, decimal nb2, decimal nb3)
        {
            //Declare le nombre qui va etre retourner et effectue l'addition
            decimal number = nb1 + nb2 + nb3;
            //Retourne le resulat
            return number;
        }

        /// <summary>
        /// Recois 4 nombre et retourne le resultat de ces deux nombres additionnés
        /// </summary>
        /// <param name="nb1">Decimal</param>
        /// <param name="nb2">Decimal</param>
        /// <param name="nb3">Decimal</param>
        /// <param name="nb4">Decimal</param>
        /// <returns>Decimal</returns>
        public decimal add(decimal nb1, decimal nb2, decimal nb3, decimal nb4)
        {
            //Declare le nombre qui va etre retourner et effectue l'addition
            decimal number = nb1 + nb2 + nb3 + nb4;
            //Retourne le resulat
            return number;
        }

        /// <summary>
        /// Recois 2 nombre et retourne le resultat de ces deux nombres sustrais
        /// </summary>
        /// <param name="nb1">Decimal</param>
        /// <param name="nb2">Decimal</param>
        /// <returns>Decimal</returns>
        public decimal sustraction(decimal nb1, decimal nb2)
        {
            //Declare le nombre qui va etre retourner et effectue la sustraction
            decimal number = nb1 - nb2;
            //Retourne le resulat
            return number;
        }

        /// <summary>
        /// Recois 2 nombre et retourne le resultat de ces deux nombres sustrais
        /// </summary>
        /// <param name="nb1">Decimal</param>
        /// <param name="nb2">Decimal</param>
        /// <param name="nb3">Decimal</param>
        /// <returns>Decimal</returns>
        public decimal sustraction(decimal nb1, decimal nb2, decimal nb3)
        {
            //Declare le nombre qui va etre retourner et effectue la sustraction
            decimal number = nb1 - nb2 - nb3;
            //Retourne le resulat
            return number;
        }

        /// <summary>
        /// Recois 2 nombre et retourne le resultat de ces deux nombres sustrais
        /// </summary>
        /// <param name="nb1">Decimal</param>
        /// <param name="nb2">Decimal</param>
        /// <param name="nb3">Decimal</param>
        /// <param name="nb4">Decimal</param>
        /// <returns>Decimal</returns>
        public decimal sustraction(decimal nb1, decimal nb2, decimal nb3, decimal nb4)
        {
            //Declare le nombre qui va etre retourner et effectue la sustraction
            decimal number = nb1 - nb2 - nb3 - nb4;
            //Retourne le resulat
            return number;
        }

        /// <summary>
        /// Recois 2 nombre et retourne le resultat de ces deux nombres multiplier
        /// </summary>
        /// <param name="nb1">Decimal</param>
        /// <param name="nb2">Decimal</param>
        /// <returns>Decimal</returns>
        public decimal multi(decimal nb1, decimal nb2)
        {
            //Declare le nombre qui va etre retourner et effectue la multiplication
            decimal number = nb1 * nb2;
            //Retourne le resulat
            return number;
        }

        /// <summary>
        /// Recois 3 nombre et retourne le resultat de ces deux nombres multiplier
        /// </summary>
        /// <param name="nb1">Decimal</param>
        /// <param name="nb2">Decimal</param>
        /// <param name="nb3">Decimal</param>
        /// <returns>Decimal</returns>
        public decimal multi(decimal nb1, decimal nb2, decimal nb3)
        {
            //Declare le nombre qui va etre retourner et effectue la multiplication
            decimal number = nb1 * nb2 * nb3;
            //Retourne le resulat
            return number;
        }

        /// <summary>
        /// Recois 4 nombre et retourne le resultat de ces deux nombres multiplier
        /// </summary>
        /// <param name="nb1">Decimal</param>
        /// <param name="nb2">Decimal</param>
        /// <param name="nb3">Decimal</param>
        /// <param name="nb4">Decimal</param>
        /// <returns>Decimal</returns>
        public decimal multi(decimal nb1, decimal nb2, decimal nb3, decimal nb4)
        {
            //Declare le nombre qui va etre retourner et effectue la multiplication
            decimal number = nb1 * nb2 * nb3 * nb4;
            //Retourne le resulat
            return number;
        }

        //Créer un random pour le carathère bidon
        public static Random rnd = new Random();

        /// <summary>
        /// Recois du texte et retourne le texte crypter
        /// </summary>
        /// <param name="textToCrypt">String</param>
        /// <returns>String</returns>
        public string cryptSimple(string textToCrypt)
        {     
            //Decalare la variable qui va contenir le texte crypter c'est cette variable qui est returnée
            string textCrypt = "";
            //Pour chaque caratère change le caratère pour un autre aléatoire
            foreach (char item in textToCrypt)
            {
                //Change le caratère pour le meme caratère avec un code ascii augmenter de 6
                textCrypt += Convert.ToChar(item + 6);
                //Crée un code bidon
                textCrypt += Convert.ToChar(rnd.Next(43, 90));
            }
            return textCrypt;
        }

        /// <summary>
        /// Recois du texte crypter et retoure le texte decryptés
        /// </summary>
        /// <param name="textToUnCrypt"></param>
        /// <returns></returns>
        public string unCryptSimple(string textToUnCrypt)
        {
            //L'index pour recuperer les bon caratère
            int index = 2;
            //Contien le texte décripter cette variable est retourner
            string textUnCrypt = "";
            foreach (char item in textToUnCrypt)
            {
                //Quand l'index est paire (donc pas le caratere bidon) on l'ajoute au texte en diminuant de 6 son code ascii
                if (index % 2 == 0) { textUnCrypt += Convert.ToChar(item - 6);}
                //Augmente l'index a la main
                index++;
            }
            //retourne le texte décrypter
            return textUnCrypt;
        }
    }
}
<file_sep>/programme_Vierge/frmInterface.cs
﻿using System;
using System.Windows.Forms;

namespace programme_Vierge
{
    public partial class frmInterface : Form
    {
        public frmInterface()
        {
            InitializeComponent();
        }
        //Retourne au menu de choix
        private void button1_Click(object sender, EventArgs e)
        {
            frmAccueil frm = new frmAccueil();
            frm.Show();
            Close();
        }
        //bouton qui Instensie l'interface et affiche le resultat
        private void btnBTN_Click(object sender, EventArgs e)
        {
            //Instensiation de l'interface
            Mot inter = new Mot();
            //Affiche le retour de l'interface mot
            MessageBox.Show(inter.motInterface());
        }

        private void btnBTN3_Click(object sender, EventArgs e)
        {
            //Instensiation de l'interface
            interFinal inter = new interFinal();
            //Affiche le retour de l'interface mot
            MessageBox.Show(inter.motInterface());
            //Affiche le retour de l'interface int
            MessageBox.Show(inter.intInterface().ToString());
            //Affiche le retour de l'interface de validation
            MessageBox.Show(inter.valide().ToString());
        }

        private void btnBTN2_Click(object sender, EventArgs e)
        {
            //Instensiation de l'interface
            nombre inter = new nombre();
            //Affiche le retour de l'interface int
            MessageBox.Show(inter.intInterface().ToString());
        }
    }
}
<file_sep>/programme_Vierge/cDog.cs
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace programme_Vierge
{
    class cDog: cAnimal
    {
        public cDog() : base(4)
        {

        }
        //Cette void override la void Talk pour donner une specificiter a comment un chat parle 
        public override void Talk()
        {
            frmPoly2.affichageTotal += ("Woof! \r\n");
        }

        public void Guard()
        {
            MessageBox.Show("The dog guards the house!");
        }

    }
}
<file_sep>/programme_Vierge/frmPoly2.cs
﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace programme_Vierge
{
    public partial class frmPoly2 : Form
    {
        public static string affichageTotal = "";
        public frmPoly2()
        {
            InitializeComponent();
        }

        private void btnExect_Click(object sender, EventArgs e)
        {
            //Creation d'une liste d'animals
            List<cAnimal> animals = new List<cAnimal>();

            cCat monChat = new cCat();
            //LE chat a un nom qui es envoiyer dans la classe animal dans name 
            monChat.Name = "Roger";
            //Ajouter dans la liste de forme
            animals.Add(monChat);

            cSnake monSerpent = new cSnake();
            //LE Serpant a un nom qui es envoiyer dans la classe animal dans name 
            monSerpent.Name = "<NAME>";
            //Ajouter dans la liste de forme
            animals.Add(monSerpent);

            cDog monChien = new cDog();
            //LE chien a un nom qui es envoiyer dans la classe animal dans name 
            monChien.Name = "Rex";
            //Console.WriteLine(monChien.CapitalizedName);


            cGermanShepard monChienPolicier = new cGermanShepard();
            //LE GermanSherperd a un nom qui es envoiyer dans la classe animal dans name 
            monChienPolicier.Name = "<NAME>";
            //Ajouter dans la liste de forme
            animals.Add(monChienPolicier);
            //Ajouter dans la liste de forme
            animals.Add(monChien);

            //For each pour resortire le resultat de tout les animaux dans la liste avec l action que nous desirons decouvrire 
            // dans ce cas ci c est juste eat et talk.
            foreach (var animal in animals)
            {
                animal.Eat();
                animal.Talk();
            }
            MessageBox.Show(affichageTotal);
           



        }
       

        private void button1_Click(object sender, EventArgs e)
        {
            cCat monChat = new cCat();
            cSnake monSerpent = new cSnake();
            cDog monChien = new cDog();
            monChat.Name = "Roger";
            monSerpent.Name = "<NAME>";
            monChien.Name = "Rex";

            //Ici on appelle la void MakeAnimalEat pis on lui envoiye l animal en parametre pour resortire le resultat
            MakeAnimalEat(monChien);
            MessageBox.Show(affichageTotal);
            affichageTotal = "";
            MakeAnimalEat(monChat);
            MessageBox.Show(affichageTotal);
            affichageTotal = "";
            MakeAnimalEat(monSerpent);
            MessageBox.Show(affichageTotal);
            affichageTotal = "";

        }

        public void MakeAnimalEat(cAnimal animal)
        {
            //D'ici on ressort que ce qu on veux de animal dans ce cas ci c est eat 
            animal.Eat();
        }
    }
   
}
<file_sep>/programme_Vierge/cPolymorphismInfos.cs
﻿namespace programme_Vierge
{
    class cPolymorphismInfos : cTemplateInfos
    {
        /// <summary>
        /// -- Variables publiques contenues dans la classe enfant uniquement. Leurs valeurs seront attribuées par les éléments 
        ///    hérités du parent
        /// </summary>
        public string nameChild = "";
        public string contentChild = "";
        public int dateEntryChild = 0;

        /// <summary>
        /// --Hérite de la classe template qui est son parent. L'enfant pourra la modifier à sa guise mais doit l'avoir
        /// </summary>
        /// <returns> string de nom</returns>
        public override string isAuthor()
        {
            nameChild = "Marie-Pier et Denis";
            return nameChild;
        }

        /// <summary>
        /// --Hérite de la classe template qui est son parent. L'enfant pourra la modifier à sa guise mais doit l'avoir
        /// </summary>
        /// <returns> Contenu de l'article</returns>
        public override string isContent()
        {
            contentChild = "Polymorphisme";
            return contentChild;
        }

        /// <summary>
        /// --Hérite de la classe template qui est son parent. L'enfant pourra la modifier à sa guise mais doit l'avoir
        /// </summary>
        /// <returns>int représentant la date</returns>
        public override int isDate()
        {
            dateEntryChild = 20190408;
            return dateEntryChild;
        }

        /// <summary>
        /// -- Hérite de la classe template qui est son parent. L'enfant pourra la modifier à sa guise mais peut choisit 
        /// de l'utiliser ou pas car il est virtual
        /// </summary>
        /// <returns> string de titre</returns>
        public override bool IsTitle(string titleEntry)
        {
            return base.IsTitle(titleEntry);
        }
    }
}<file_sep>/programme_Vierge/cInterfaceAlex.cs
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace programme_Vierge
{
    //L'interface StringRand contiens une string
    interface StringRand
    {
        string motInterface();
    }

    //L'interface IntRand contiens un int
    interface IntRand
    {
        int intInterface();
    }

    //L'interface contiens plusieurs Variable
    interface MultipleVariable
    {
        string motInterface();
        bool valide();
        int intInterface();
    }


    //La classe genere un string contenant les numeros 0 a 10 et les retourne dans la variable de l'interface
    class Mot : StringRand
    {
        public string motInterface()
        {
            string str = "";
            for (int i = 0; i < 11; i++)
            {
                str += i.ToString() + Environment.NewLine;
            }
            return str;
        }
    }

    //La classe genere un int de 100 a 7000000 et le retourne dans le int de l'interface
    class nombre : IntRand
    {
        public int intInterface()
        {
            Random rnd = new Random();
            int rtn = rnd.Next(100, 7000000);
            return rtn;
        }
    }


    //Une classe peux avoir plusieur interface tent que chaqu'une de variable se trouvant dans les interface recupère une valeur
    class interFinal : MultipleVariable, IntRand, StringRand
    {
        //cette string est dans l'interface MultipleVaraible et StringRand
        public string motInterface()
        {
            string str = "";
            for (int i = 0; i < 11; i++)
            {
                str += i.ToString() + Environment.NewLine;
            }
            return str;
        }
        //Ce int est dans l'interface MultipleVaraible et intInterface
        public int intInterface()
        {
            Random rnd = new Random();
            int rtn = rnd.Next(100, 7000000);
            return rtn;
        }
        //Ce bool est dans l'interface MultipleVaraible seulemeent
        public bool valide()
        {
            bool tst = true;
            tst = false;
            return tst;
        }
    }
}
<file_sep>/programme_Vierge/cInterface.cs
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace programme_Vierge
{
    class cInterface : cTemplateInfos
    {
        /// <summary>
        /// -- Variables publiques contenues dans la classe enfant uniquement. Leurs valeurs seront attribuées par les éléments 
        ///    hérités du parent
        /// </summary>
        public string nameChild = "";
        public string contentChild = "";
        public int dateEntryChild = 0;

        /// <summary>
        /// --Hérite de la classe template qui est son parent. L'enfant pourra la modifier à sa guise mais doit l'avoir
        /// </summary>
        /// <returns> string de nom</returns>
        public override string isAuthor()
        {
            nameChild = "Alexandre";
            return nameChild;
        }

        /// <summary>
        /// --Hérite de la classe template qui est son parent. L'enfant pourra la modifier à sa guise mais doit l'avoir
        /// </summary>
        /// <returns> string de contenu</returns>
        public override string isContent()
        {
            contentChild = "Interface";
            return contentChild;
        }

        /// <summary>
        /// --Hérite de la classe template qui est son parent. L'enfant pourra la modifier à sa guise mais doit l'avoir
        /// </summary>
        /// <returns> Int représentant la date</returns>
        public override int isDate()
        {
            dateEntryChild = 20190409;
            return dateEntryChild;
        }
        interface StringRand
        {
            string motInterface();
        }

        //L'interface IntRand contiens un int
        interface IntRand
        {
            int intInterface();
        }

        //L'interface contiens plusieurs Variable
        interface MultipleVariable
        {
            string motInterface();
            bool valide();
            int intInterface();
        }
    }
}

