Auteur:
Christian Maréchal
Categories:
Codes C#
Création:
25/11/2022
Modifié:
25/11/2022
Version:
1.0.0
- Plan du code
- Créer une classe
Personavec des propriétés privées et des méthodes publiques pour accéder à ces propriétés. - Créer une application console qui utilise cette classe pour illustrer l’encapsulation.
Pseudocode détaillé
- 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)
- Propriétés privées:
- 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.
- Créer une instance de
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
SetFirstNameetSetLastNamevérifient que les valeurs fournies ne sont pas nulles ou vides. Si une valeur invalide est fournie, elles lancent une exceptionArgumentException. - La méthode
SetAgevérifie que l’âge est un nombre positif. Si une valeur invalide est fournie, elle lance une exceptionArgumentException.
Méthodes Get
- Les méthodes
GetFirstName,GetLastNameetGetAgeretournent 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
Setne 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
Getaprè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.
