profile 6

Auteur:

Christian Maréchal

Categories:

Codes C#

Création:

25/11/2022

Modifié:

25/11/2022

Version:

1.0.0

  • Plan du code
  1. Créer une classe Person avec des propriétés privées et des méthodes publiques pour accéder à ces propriétés.
  2. Créer une application console qui utilise cette classe pour illustrer l’encapsulation.

Pseudocode détaillé

  1. Déclarer la classe Person.
    • Propriétés privées: firstName, lastName, age.
    • Méthodes publiques:
      • GetFirstName(), SetFirstName(value)
      • GetLastName(), SetLastName(value)
      • GetAge(), SetAge(value)
  2. Dans le Main:
    • Créer une instance de Person.
    • Définir les valeurs des propriétés en utilisant les méthodes Set.
    • Afficher les valeurs des propriétés en utilisant les méthodes Get.

Class ‘Person’

using System;

namespace EncapsulationExample
{
    /// <summary>
    /// Représente une personne avec un prénom, un nom de famille et un âge.
    /// Utilise l'encapsulation pour protéger les données privées.
    /// </summary>
    class Person
    {
        // Propriétés privées
        private string firstName;
        private string lastName;
        private int age;

        /// <summary>
        /// Obtient le prénom de la personne.
        /// </summary>
        /// <returns>Le prénom de la personne.</returns>
        public string GetFirstName()
        {
            return firstName;
        }

        /// <summary>
        /// Définit le prénom de la personne.
        /// </summary>
        /// <param name="value">Le prénom à définir.</param>
        public void SetFirstName(string value)
        {
            if (string.IsNullOrEmpty(value))
            {
                throw new ArgumentException("Le prénom ne peut pas être vide ou nul.");
            }
            firstName = value;
        }

        /// <summary>
        /// Obtient le nom de famille de la personne.
        /// </summary>
        /// <returns>Le nom de famille de la personne.</returns>
        public string GetLastName()
        {
            return lastName;
        }

        /// <summary>
        /// Définit le nom de famille de la personne.
        /// </summary>
        /// <param name="value">Le nom de famille à définir.</param>
        public void SetLastName(string value)
        {
            if (string.IsNullOrEmpty(value))
            {
                throw new ArgumentException("Le nom de famille ne peut pas être vide ou nul.");
            }
            lastName = value;
        }

        /// <summary>
        /// Obtient l'âge de la personne.
        /// </summary>
        /// <returns>L'âge de la personne.</returns>
        public int GetAge()
        {
            return age;
        }

        /// <summary>
        /// Définit l'âge de la personne.
        /// </summary>
        /// <param name="value">L'âge à définir. Doit être un nombre positif.</param>
        public void SetAge(int value)
        {
            if (value <= 0)
            {
                throw new ArgumentException("L'âge doit être un nombre positif.");
            }
            age = value;
        }
    }
}

Class ‘Program’

using System;

namespace EncapsulationExample
{
    /// <summary>
    /// Programme principal pour démontrer l'encapsulation.
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            // Création d'un nouvel objet Person
            Person person = new Person();

            // Définir les propriétés en utilisant les méthodes encapsulées
            person.SetFirstName("John");
            person.SetLastName("Doe");
            person.SetAge(30);

            // Obtenir et afficher les propriétés en utilisant les méthodes encapsulées
            Console.WriteLine("Prénom : " + person.GetFirstName());
            Console.WriteLine("Nom de famille : " + person.GetLastName());
            Console.WriteLine("Âge : " + person.GetAge());
        }
    }
}

Projet de Tests: EncapsulationExample.Tests

Fichier: PersonTests.cs

using Xunit;
using EncapsulationExample;

namespace EncapsulationExample.Tests
{
    public class PersonTests
    {
        [Fact]
        public void SetFirstName_ValidValue_ShouldSetFirstName()
        {
            // Arrange
            var person = new Person();
            var expectedFirstName = "John";

            // Act
            person.SetFirstName(expectedFirstName);
            var actualFirstName = person.GetFirstName();

            // Assert
            Assert.Equal(expectedFirstName, actualFirstName);
        }

        [Fact]
        public void SetFirstName_EmptyValue_ShouldNotSetFirstName()
        {
            // Arrange
            var person = new Person();
            var invalidFirstName = "";

            // Act
            person.SetFirstName(invalidFirstName);
            var actualFirstName = person.GetFirstName();

            // Assert
            Assert.NotEqual(invalidFirstName, actualFirstName);
        }

        [Fact]
        public void SetFirstName_NullValue_ShouldNotSetFirstName()
        {
            // Arrange
            var person = new Person();
            string invalidFirstName = null;

            // Act
            person.SetFirstName(invalidFirstName);
            var actualFirstName = person.GetFirstName();

            // Assert
            Assert.Null(actualFirstName);
        }

        [Fact]
        public void SetFirstName_SpecialCharacters_ShouldSetFirstName()
        {
            // Arrange
            var person = new Person();
            var expectedFirstName = "J@hn!";

            // Act
            person.SetFirstName(expectedFirstName);
            var actualFirstName = person.GetFirstName();

            // Assert
            Assert.Equal(expectedFirstName, actualFirstName);
        }

        [Fact]
        public void SetFirstName_LongString_ShouldSetFirstName()
        {
            // Arrange
            var person = new Person();
            var expectedFirstName = new string('A', 1000);

            // Act
            person.SetFirstName(expectedFirstName);
            var actualFirstName = person.GetFirstName();

            // Assert
            Assert.Equal(expectedFirstName, actualFirstName);
        }

        [Fact]
        public void SetLastName_ValidValue_ShouldSetLastName()
        {
            // Arrange
            var person = new Person();
            var expectedLastName = "Doe";

            // Act
            person.SetLastName(expectedLastName);
            var actualLastName = person.GetLastName();

            // Assert
            Assert.Equal(expectedLastName, actualLastName);
        }

        [Fact]
        public void SetLastName_EmptyValue_ShouldNotSetLastName()
        {
            // Arrange
            var person = new Person();
            var invalidLastName = "";

            // Act
            person.SetLastName(invalidLastName);
            var actualLastName = person.GetLastName();

            // Assert
            Assert.NotEqual(invalidLastName, actualLastName);
        }

        [Fact]
        public void SetLastName_NullValue_ShouldNotSetLastName()
        {
            // Arrange
            var person = new Person();
            string invalidLastName = null;

            // Act
            person.SetLastName(invalidLastName);
            var actualLastName = person.GetLastName();

            // Assert
            Assert.Null(actualLastName);
        }

        [Fact]
        public void SetLastName_Spaces_ShouldSetLastName()
        {
            // Arrange
            var person = new Person();
            var expectedLastName = "Doe Jr";

            // Act
            person.SetLastName(expectedLastName);
            var actualLastName = person.GetLastName();

            // Assert
            Assert.Equal(expectedLastName, actualLastName);
        }

        [Fact]
        public void SetLastName_LongString_ShouldSetLastName()
        {
            // Arrange
            var person = new Person();
            var expectedLastName = new string('B', 1000);

            // Act
            person.SetLastName(expectedLastName);
            var actualLastName = person.GetLastName();

            // Assert
            Assert.Equal(expectedLastName, actualLastName);
        }

        [Fact]
        public void SetAge_ValidValue_ShouldSetAge()
        {
            // Arrange
            var person = new Person();
            var expectedAge = 30;

            // Act
            person.SetAge(expectedAge);
            var actualAge = person.GetAge();

            // Assert
            Assert.Equal(expectedAge, actualAge);
        }

        [Fact]
        public void SetAge_InvalidValue_ShouldNotSetAge()
        {
            // Arrange
            var person = new Person();
            var invalidAge = -5;

            // Act
            person.SetAge(invalidAge);
            var actualAge = person.GetAge();

            // Assert
            Assert.NotEqual(invalidAge, actualAge);
        }

        [Fact]
        public void SetAge_ExtremelyHighValue_ShouldSetAge()
        {
            // Arrange
            var person = new Person();
            var expectedAge = 150;

            // Act
            person.SetAge(expectedAge);
            var actualAge = person.GetAge();

            // Assert
            Assert.Equal(expectedAge, actualAge);
        }

        [Fact]
        public void SetAge_ExtremelyLowValue_ShouldNotSetAge()
        {
            // Arrange
            var person = new Person();
            var invalidAge = 0;

            // Act
            person.SetAge(invalidAge);
            var actualAge = person.GetAge();

            // Assert
            Assert.NotEqual(invalidAge, actualAge);
        }

        [Fact]
        public void InitialValues_ShouldBeNullOrDefault()
        {
            // Arrange
            var person = new Person();

            // Act
            var initialFirstName = person.GetFirstName();
            var initialLastName = person.GetLastName();
            var initialAge = person.GetAge();

            // Assert
            Assert.Null(initialFirstName);
            Assert.Null(initialLastName);
            Assert.Equal(0, initialAge); // Assuming default value for age is 0
        }

        [Fact]
        public void GetFirstName_AfterSettingValidValue_ShouldReturnFirstName()
        {
            // Arrange
            var person = new Person();
            var expectedFirstName = "John";

            // Act
            person.SetFirstName(expectedFirstName);
            var actualFirstName = person.GetFirstName();

            // Assert
            Assert.Equal(expectedFirstName, actualFirstName);
        }

        [Fact]
        public void GetLastName_AfterSettingValidValue_ShouldReturnLastName()
        {
            // Arrange
            var person = new Person();
            var expectedLastName = "Doe";

            // Act
            person.SetLastName(expectedLastName);
            var actualLastName = person.GetLastName();

            // Assert
            Assert.Equal(expectedLastName, actualLastName);
        }

        [Fact]
        public void GetAge_AfterSettingValidValue_ShouldReturnAge()
        {
            // Arrange
            var person = new Person();
            var expectedAge = 30;

            // Act
            person.SetAge(expectedAge);
            var actualAge = person.GetAge();

            // Assert
            Assert.Equal(expectedAge, actualAge);
        }

        [Fact]
        public void GetAge_AfterSettingInvalidValue_ShouldNotReturnInvalidAge()
        {
            // Arrange
            var person = new Person();
            var initialAge = person.GetAge();
            var invalidAge = -5;

            // Act
            person.SetAge(invalidAge);
            var actualAge = person.GetAge();

            // Assert
            Assert.Equal(initialAge, actualAge);
        }

        [Fact]
        public void SetFirstName_InvalidValue_ShouldThrowArgumentException()
        {
            // Arrange
            var person = new Person();
            var invalidFirstName = "";

            // Act & Assert
            Assert.Throws<ArgumentException>(() => person.SetFirstName(invalidFirstName));
        }

        [Fact]
        public void SetLastName_InvalidValue_ShouldThrowArgumentException()
        {
            // Arrange
            var person = new Person();
            var invalidLastName = "";

            // Act & Assert
            Assert.Throws<ArgumentException>(() => person.SetLastName(invalidLastName));
        }

        [Fact]
        public void SetAge_InvalidValue_ShouldThrowArgumentException()
        {
            // Arrange
            var person = new Person();
            var invalidAge = -5;

            // Act & Assert
            Assert.Throws<ArgumentException>(() => person.SetAge(invalidAge));
        }
    }
}

Explications

Encapsulation

L’encapsulation est un principe clé de la programmation orientée objet. Elle consiste à protéger les données d’une classe en les rendant privées et en fournissant des méthodes publiques pour accéder et modifier ces données de manière contrôlée. Cela permet de s’assurer que les données sont toujours valides et cohérentes.

Classe Person

La classe Person dans cet exemple encapsule les propriétés firstName, lastName et age en les rendant privées. Elle fournit des méthodes publiques Get et Set pour accéder et modifier ces propriétés.

Méthodes Set
  • Les méthodes SetFirstName et SetLastName vérifient que les valeurs fournies ne sont pas nulles ou vides. Si une valeur invalide est fournie, elles lancent une exception ArgumentException.
  • La méthode SetAge vérifie que l’âge est un nombre positif. Si une valeur invalide est fournie, elle lance une exception ArgumentException.
Méthodes Get
  • Les méthodes GetFirstName, GetLastName et GetAge retournent les valeurs des propriétés correspondantes.

Programme Principal

Le programme principal démontre l’utilisation de la classe Person en créant une instance, en définissant ses propriétés via les méthodes Set, puis en affichant les valeurs via les méthodes Get.

Tests Unitaires

Les tests unitaires vérifient le comportement de la classe Person dans divers scénarios:

  • Tests avec des valeurs valides pour s’assurer que les propriétés sont correctement définies.
  • Tests avec des valeurs invalides (nulles, vides, extrêmes) pour s’assurer que les méthodes Set ne définissent pas les propriétés ou lancent des exceptions appropriées.
  • Tests pour vérifier les valeurs initiales des propriétés.
  • Tests pour vérifier le comportement des méthodes Get après avoir défini les propriétés.

Exécuter les Tests

Pour exécuter les tests,

  • Exécuter dans Visual Studio (F5)
  • Utilisez la commande suivante dans le répertoire du projet de tests:
dotnet test

Ces extensions couvrent divers cas limites et vérifient les exceptions lancées lorsque des valeurs invalides sont fournies, assurant ainsi que la classe Person est robuste et fiable.

Aller au contenu principal