Komposition C#

Der folgende Artikel bietet eine Übersicht über Composition C#. In C# gibt es zwei Arten von Beziehungen zwischen Klassen. Der erste Beziehungstyp heißt „ist eine Beziehung“ und verwendet einen Vererbungsmechanismus. Die zweite Art von Beziehung ist die Beziehung zwischen zwei Klassen und hat zwei Untertypen. Der erste Typ heißt „hat eine Beziehung“.

Bei dieser Art von Beziehung wird ein oder mehr als ein Objekt einer anderen Klasse in der zugehörigen Klasse deklariert. Hier kommen zwei weitere Unterteilungen, nämlich Aggregation und Komposition. Bei der Aggregation können die verschachtelten Objekte unabhängig voneinander in der Klasse existieren, ohne ein integraler Bestandteil der Klasse zu sein. Andererseits ergänzen in der Komposition die verschachtelten Objekte oder ein einzelnes verschachteltes Objekt die Klasse, was die Klasse ohne ihre oder ihre Existenz undenkbar macht.

Syntax der Komposition in C#

Nachstehend finden Sie die erwähnte Syntax:

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

Arbeiten der Komposition in C#

• Komposition in C# ist eine Möglichkeit, eine Beziehung zwischen zwei Klassen zu erstellen, sodass ein oder mehr verschachtelte Objekte Teil der zugehörigen Klasse sind und die logische Existenz der Klasse ohne die verschachtelten Objekte unmöglich wird.
• Wenn wir beispielsweise eine Klasse namens „Car“ betrachten, dann sollte sie eine Instanz der Klasse „Engine“ haben. Darüber hinaus sollte es auch vier weitere Instanzen der Klasse „Wheel“ geben.
• Wenn wir nun einen dieser Fälle beseitigen, wird das Auto nicht funktionieren.

Beispiele für Komposition C#

Im Folgenden finden Sie Beispiele für Komposition C#:

Beispiel #1

Wenn die Schulungsklasse berücksichtigt wird, die zwei Kurse beschreibt. Nun werden die Kurse zur Beschreibung der Kursklasse verwendet. Daher kann die Trainingsklasse nicht ohne die Zwei-Kurs-Instanzen existieren, da diese beiden Instanzen Teil der Kursklasse sind. Darüber hinaus sind diese beiden Instanzen der Kursklasse auch Teil der Schulungsklasse.

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();
}
}
}

Ausgabe:

Beispiel #2

In diesem Beispiel sind beide erstellten Klassen reguläre Klassen; Die Kursklasse verwendet jedoch eine Instanz der darin enthaltenen Projektklasse. Dies ist die gleiche Art und Weise, wie eine Funktion innerhalb einer anderen aufgerufen wird. Mithilfe der Vererbung können wir auf alles und jeden aus der Project-Klasse zugreifen. Mittels Composition kann jedoch nur auf den von uns angegebenen Code zugegriffen werden. Hier können wir indirekt auf die Project-Klasse zugreifen.

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......");
}
}
}

Ausgabe:

Beispiel #3

In diesem Beispiel wird der Aufbau des Verbunddesigns erläutert. Es hilft beim Verständnis der für die Komposition verwendeten Klassen und der Rollen dieser Klassen. Darüber hinaus wird auch erklärt, wie die Elemente des Musters miteinander in Beziehung stehen.

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);
}
}
}

Ausgabe:

Fazit

Auf der Grundlage des obigen Artikels haben wir das Konzept der Komposition in C# verstanden. Wir haben mehrere Beispiele durchgesehen, um die Anwendung der Komposition in der C#-Codierung zu verstehen.

Das obige ist der detaillierte Inhalt vonKomposition C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!