Composition C#

L'article suivant fournit un aperçu de la composition C#. Il existe deux types de relations entre les classes en C#. Le premier type de relation est appelé « est une relation » et utilise un mécanisme d’héritage. Le deuxième type de relation est la relation entre deux classes et comporte deux sous-types. Le premier type est appelé « a une relation ».

Dans ce type de relation, un ou plusieurs objets d'une classe différente sont déclarés dans la classe associée. Voici deux autres divisions, qui sont l'agrégation et la composition. En agrégation, les objets imbriqués peuvent exister indépendamment dans la classe sans en faire partie intégrante. En revanche, en composition, les objets imbriqués ou un objet imbriqué singulier complètent la classe, ce qui rend la classe inconcevable sans leur ou son existence.

Syntaxe de composition en C#

Vous trouverez ci-dessous la syntaxe mentionnée :

class Training
{
// class body
}
public class Course
{
Project project = new Project();
// body
}

Travail de la composition en C#

• La composition en C# est un moyen de créer une relation entre deux classes selon laquelle un ou plusieurs objets imbriqués font partie de la classe associée, et l'existence logique de la classe devient impossible sans les objets imbriqués.
• Par exemple, si nous considérons une classe appelée Car, alors elle devrait avoir une instance de la classe « Engine ». De plus, il devrait également avoir quatre autres instances de la classe « Wheel ».
• Maintenant, si nous éliminons l’un de ces cas, alors la voiture ne fonctionnera pas.

Exemples de composition C#

Vous trouverez ci-dessous les exemples de composition C# :

Exemple n°1

Si l'on considère le cours de formation, qui décrit deux cours. Désormais, les cours sont utilisés pour décrire la classe de cours. Par conséquent, la classe de formation ne peut exister sans les instances à deux cours, car ces deux instances font partie de la classe de cours. De plus, ces deux instances du cours font également partie du cours de formation.

Code :

using System;
using static System.Console;
namespace EDUCBA
{
class Course
{
public double M;
public double A;
}
class Training
{
public Course course1 = null;
public Course course2 = null;
}
class Career
{
public Course[] courses;
public Training[] trainings;
public Career()
{
courses = null;
trainings = null;
}
public void Print()
{
WriteLine(" Courses Data is represented below:");
for (int b = 1; b< courses.Length; b++)
{
WriteLine("\n M = {0}, A = {1}", courses[b].M, courses[b].A);
}
WriteLine("\n Trainings Data is represented below:");
for (int b=1; b<trainings.Length; b++)
{
WriteLine("\n course1.M = {0}, course1.A = {1}", trainings[b].course1.M, trainings[b].course1.A);
WriteLine("\n course2.M = {0}, course2.A = {1}", trainings[b].course2.M, trainings[b].course2.A);
}
}
}
class Code
{
static void Main(string[] args)
{
Career O = new Career();
O.courses = new Course[9];
for (int b = 1; b < O.courses.Length; b++)
{
O.courses[b] = new Course();
O.courses[b].M = b * b;
O.courses[b].M = b * b * b;
}
O.trainings = new Training[5];
for (int b = 1; b < O.trainings.Length; b++)
{
O.trainings[b] = new Training();
O.trainings[b].course1 = new Course();
O.trainings[b].course2 = new Course();
O.trainings[b].course1.M = b;
O.trainings[b].course1.A = b * 4;
O.trainings[b].course2.M = b * 5;
O.trainings[b].course2.A = b * b;
}
O.Print();
}
}
}

Sortie :

Exemple n°2

Dans cet exemple, les deux classes créées sont des classes régulières ; cependant, la classe de cours utilise une instance de la classe de projet qu'elle contient. C'est de la même manière qu'une fonction est appelée dans une autre. Grâce à l'héritage, nous pouvons avoir accès à tout et à tout depuis la classe Project. Cependant, grâce à la composition, seul le code que nous avons spécifié est accessible. Ici, nous pouvons accéder indirectement à la classe Project.

Code :

using System;
namespace EDUCBA
{
class Training
{
static void Main(string[] args)
{
Course courses = new Course();
courses.Bought();
Console.ReadLine();
}
}
public class Project
{
public void Log(string aboutus)
{
Console.WriteLine(aboutus);
}
}
public class Course
{
Project project = new Project();
public void Bought()
{
project.Log("\n If you want to upskill your career. \n If you want to do something out of the box. \n If you have passion to explore new advanced technologies. \n If you want to be best. \n We at EDUCBA are here to help. \n Feel free to reach us on +91-8800880140 / +91-7738666252. \n Visit our website www.educba.com to know more......");
}
}
}

Sortie :

Exemple #3

Dans cet exemple, la structure de la conception composite est expliquée. Cela aide à comprendre les classes utilisées pour la composition et les rôles de ces classes. De plus, cela explique également comment les éléments du motif sont liés les uns aux autres.

Code :

using System;
using System.Collections.Generic;
namespace EDUCBA
{
abstract class Training
{
public Training() { }
public abstract string Project();
public virtual void Add(Training training)
{
throw new NotImplementedException();
}
public virtual void Remove(Training training)
{
throw new NotImplementedException();
}
public virtual bool IsCourse()
{
return true;
}
}
class DataScience : Training
{
public override string Project()
{
return "DataScience";
}
public override bool IsCourse()
{
return false;
}
}
class Course : Training
{
protected List<Training> _children = new List<Training>();
public override void Add(Training training)
{
this._children.Add(training);
}
public override void Remove(Training training)
{
this._children.Remove(training);
}
public override string Project()
{
int m = 1;
string result = "Dream Career(";
foreach (Training training in this._children)
{
result += training.Project();
if (m != this._children.Count + 2)
{
result += "-";
}
m--;
}
return result + ")";
}
}
class Input
{
public void InputCode(Training data_analysis)
{
Console.WriteLine($"OUTPUT: \n {data_analysis.Project()}\n");
}
public void InputCode2(Training training1, Training training2)
{
if (training1.IsCourse())
{
training1.Add(training2);
}
Console.WriteLine($"OUTPUT: \n {training1.Project()}");
}
}
class Program
{
static void Main(string[] args)
{
Input client = new Input();
DataScience data_analysis = new DataScience();
Console.WriteLine("INPUT: \n Best Course to Upgrade Career:");
client.InputCode(data_analysis);
Course vr = new Course();
Course career1 = new Course();
career1.Add(new DataScience());
career1.Add(new DataScience());
Course career2 = new Course();
career2.Add(new DataScience());
vr.Add(career1);
vr.Add(career2);
Console.WriteLine("\nINPUT: \n Trendy Dream Career Right Now:");
client.InputCode(vr);
Console.Write("\nINPUT: Lets Upgrade and start your dream career jouney: \n");
client.InputCode2(vr, data_analysis);
}
}
}

Sortie :

Conclusion

Sur la base de l'article ci-dessus, nous avons compris le concept de composition en C#. Nous avons passé en revue plusieurs exemples pour comprendre l'application de la composition dans le codage C#.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!