Transkripte
1. C# Erweiterte Einführung: Hallo zusammen und willkommen zu meinem Kurs und fortgeschrittenen
C-Sharp-Themen. In dieser Videoserie werden
wir uns mit den
Details des
vorherigen Kurses oder der Klasse befassen und unsere Reise fortsetzen um einen Blick auf fortgeschrittene
Konzepte in C-Sharp zu werfen. Dieser Kurs wird einem Git-Repository
begleitet, mit dem Sie Ihr Wissen erweitern und die Beispiele
reproduzieren können . Wenn Sie also
etwas
Komplexeres und C-Sharp lernen
möchten , ist dieser Kurs genau das Richtige für Sie. Wir sehen uns in der nächsten.
2. C# hat die Einrichtung erweitert: Hallo zusammen und willkommen zurück. In diesem kurzen Video werden
wir uns
die Umgebung ansehen , in Sie den Beispielen
folgen können. Im Grunde
haben Sie also zwei Möglichkeiten. Eine davon ist, dass Sie
mit Visual Studio verwenden können, Sie können die 29. Version
oder die 2022-Version verwenden. Sie können es von der
offiziellen Microsoft-Seite herunterladen. Und im Grunde müssen
Sie den Visual
Studio-Installer öffnen. Und Sie können
auf Ändern klicken. Hier. Sie müssen die Dotnet-Entwicklung
überprüfen und installieren lassen. Sobald Sie dies installiert haben, können
Sie mitverfolgen. Das ist eine Option. Die andere Option, die Sie
verwenden können , ist Visual Studio Code. Und Visual Studio Code, Sie können die Erweiterungen überprüfen
und nach Cis suchen. Das ist ein bisschen langsam. Aber im Grunde sollte es dir auch gut gehen, wenn
du diese Erweiterung
installierst . Also das war alles was ich benutze, im Grunde eine Windows-Maschine. Und das war's. Wir sehen uns im nächsten.
3. C# Advanced Logische und Bitwise: Hallo zusammen und willkommen zurück. In diesem Video werden
wir durchhalten. Wir werden über
logische und bitweise Operatoren sprechen und wie Sie sie verwenden können. So logisch und weise. Okay, lass es uns erstellen. Wenn wir also über logische und bitweise
Operatoren und C-Sharp
sprechen, unterstützt
C-Sharp im Grunde über logische und bitweise
Operatoren und C-Sharp
sprechen, unterstützt
C-Sharp vier
Haupttypen von Operationen, die basierend auf der Idee,
die hinter ihrer Existenz steht,
gruppiert werden basierend auf der Idee,
die hinter ihrer Existenz steht,
gruppiert . Kategorien sind also arithmetische,
relationale, logische, bitweise Zuweisung und einige
verschiedene Operationen. Arithmetische Operatoren führen
normalerweise Operationen mit zwei Zahlen aus. Sie möchten also zwei Zahlen
summieren, multiplizieren, dividieren und so weiter. Die relationalen Operatoren werden
verwendet, um die
Qualität des
Eingabeobjekts oder der Eingabeobjekte zu vergleichen oder zu überprüfen. Und die logischen Operatoren
ermöglichen es uns, ein bisschen
eines bestimmten Objekts zu vergleichen und geben immer einen Boolean als Resort
zurück. Unabhängig davon, ob es wahr oder falsch ist, führen
bitweise Operatoren Operationen an einzelnen Bits aus und die
Ergebnisse sind immer Bits. Und Zuweisungsoperatoren
ermöglichen es uns,
ein Objekt mit einem Wert zu initialisieren , um eine bestimmte Operation
auszuführen. Und es gibt noch ein anderes
wichtiges Konzept , nämlich die Rangfolge der
Operatoren, welche Operatoren
stärker sind als die anderen. Und dies zeigt die Logik, wie komplexe Ausdrücke bewertet
werden. Wenn wir uns also logische Operatoren
ansehen wollen, könnten
wir Folgendes tun. Fügen wir am Ende den richtigen
Schlüssel hinzu. Und wir könnten sagen, dass
wir ein boolesches a haben, das wahr ist, und das
boolesche b, das falsch ist. Wir könnten die
rechte Linie der Konsole verwenden, um zu überprüfen ob der
Wert von A und B ist. Oder wir könnten
den Wert von Ohm oder
rechte Linie A oder B überprüfen und so weiter. Wenn wir dies starten oder
entweder ausführen, können
wir sehen, dass a und B
falsch sind und a oder B wahr ist. Wenn wir also
über den Ende-Operator sprechen, müssen
wir wissen, dass
die Bedingung
wahr ist , wenn beide Eingaben wahr
sind, andernfalls ist sie falsch. Die Bedingung bei
OR-Operatoren ist
die Bedingung wahr, wenn einer von ihnen wahr
ist, andernfalls ist sie falsch. Das sind vielleicht
die logischen Operatoren
und wir haben Negation. Und wenn Sie vor der Variablen ein
Ausrufezeichen verwenden, erhält
sie ihren Wert nicht. Also haben wir ein s true definiert, und wenn wir hier
true negieren, erhalten wir false. Was wir nun auch überprüfen können,
sind die bitweisen Operatoren. Wir können also ein int-Array haben
, das sechs sein wird. Und nennen wir sie C
und D. Und das D wird 17. Wenn wir also
die bitweisen Operatoren verwenden wollen, können wir
Folgendes tun. Also könnten wir das
convert to string verwenden. Mit dieser Funktion können
Sie eine Zeichenfolge konvertieren. Und wir könnten sagen, dass a oder B Und wir könnten die beiden auch hier
verwenden. Also lass es mich einfach überprüfen. Also konvertiere in String A oder B. Und wenn wir gehen, warte mal, ist es C oder D. Okay? Wenn
wir also den ODER-Operator verwenden, verhält es sich im Grunde so
, als hätten wir einige dieser beiden Zahlen. Wir haben also den Wert 23. Und wir hätten, überprüfen
wir mal, ob diese Zahlen
doppelt dargestellt
werden . Sechs ist also 0000110. Und wir haben die 17, die
Nullen sein werden, Nullen 010001. Und wir könnten hier auch
die UND-Operation verwenden. Wenn wir es ausführen, erhalten
wir diesen Wert. Und weißt du, wenn wir uns die Endoperation
ansehen, würden
wir eine bekommen. Wenn es in beiden Fällen eine Eins
gab, erhalten wir
sonst 0. Deshalb bekommen wir Nullen. Ergebnis, weil keine
dieser Spalten ausgerichtet wird
, um den Wert eins zu erhalten. Und wir können den
bitweisen UND-Operator verwenden. Das sieht also so aus. Und das ist minus sieben. Und wir könnten den
bitweisen OR-Operator
C oder D verwenden . Und das gibt uns 23. Und technisch gesehen ist es das. Das wollte ich dir in diesem Video
zeigen. Wir sehen uns.
4. C# Advanced Const vs Nur lesen: Hallo zusammen und willkommen zurück. In diesem Video
werden wir
über den Unterschied
zwischen Kosten und schreibgeschützt sprechen . Cis. C-Sharp
ermöglicht Schlüsselwörter wie nur Konzentrat oder
statisches Nur-Lesen. Und es kann zunächst
verwirrend sein. Wir müssen die kleinen
Unterschiede zwischen diesen kennen. Das Schlüsselwort const
ist also nichts weiter als
eine Konstante. Also zum Beispiel bei cost
string, meine Zeichenfolge. Und wir könnten sagen, dass
dies eine Zeichenfolge ist. Und ändern wir das in
doppelte Anführungszeichen. In Ordnung? Jetzt beschwert es sich
, dass es zugewiesen, nie benutzt wurde, aber das ist okay. erhalten wir standardmäßig Wenn wir also dieser Konstantenzeichenfolge keinen Wert
geben, einen Fehler,
da sie initialisiert werden muss. Deshalb ist es mit Rot
unterstrichen. Aber nachdem wir ihm einen Wert gegeben haben, sollte
es in Ordnung sein. Und erstens, wenn wir
die Konstantenfunktion definieren, ist
dies im Grunde eine
Ausnahme. Also zum Beispiel, wenn Sie einen statischen String-Test
haben
und wir könnten sagen, dass wir
einen konstanten
String-Testwert und die Rückgabe haben . Also
müssen wir im Grunde meine Einschränkung
und die rechte Zeile der Konsole ausschreiben . Das wird
Telefone mit allen drei Tasten verwenden. Damit wir die
Eingabeaufforderung haben können, führen wir sie aus. Der Wert der
Konstanten kann
sich während der Ausführung nicht ändern. In letzter Zeit ist keyword
ein spezieller Modifikator , der dem Schlüsselwort constant sehr ähnlich
ist. Und es kann für Felder verwendet werden, aber nicht für lokale Variablen. Diese Felder können also entweder
initialisiert werden, wenn sie deklariert werden.
Was ist der Konstruktor
unseres Objekts? Und dieses Schlüsselwort stellt sicher, dass die Variableninstanz
oder Eigenschaft
eines Objekts
nach der Initialisierung nicht geändert werden kann. Und ein solcher Versuch wird zu
einer Ausnahmeausnahme führen. Und warum die Konstanten
darin zur Kompilierzeit initialisiert werden. Das schreibgeschützte Schlüsselwort
ermöglicht die
Initialisierung der Variablen entweder zur Kompilierzeit oder zur Laufzeit. So konnten wir die öffentliche schreibgeschützte
String-Spalte von Mike darin kompilieren lassen. Und wir könnten es einfach so
lassen wie es ist. Wir könnten zum Beispiel einen Klassenschüler
haben. Und diese Klasse könnte den
öffentlichen schreibgeschützten
String Full Name haben . Und der öffentliche
Studenten-String-Name. Vollständiger Name ist gleich Name. Und wenn du zur Hauptschule gehst, könnten
wir unseren Studenten erschaffen. Dann ER und New Student, und verwenden Sie die rechte Zeile der Konsole , um die
Danielle als Namen auszudrucken. Und jetzt können wir
die Ausgabe sehen. Ist da. Der Kernunterschied auf
höchster Ebene, wenn wir das schreibgeschützte
und das const-Schlüsselwort
unterscheiden wollen . Wir könnten also sagen, dass der
Unterschied darin liegt, wann der Wert der Variablen über den
Lebenszyklus der Anwendung
bekannt ist . Für das schreibgeschützte Schlüsselwort ist
der Wert
spätestens zur Laufzeit bekannt Für
das Schlüsselwort const muss
der Wert bis zur Kompilierzeit
bekannt sein. Diese
Schlüsselwörter sind gemeinsam, dass beide
unveränderliche Datentypen abdecken,
was bedeutet, dass sich der Wert
während der gesamten Lebensdauer
der Anwendung nicht ändern kann . Für das Schlüsselwort const wird
die
als solche markierte Variable vom Compiler in
die
Assembly-Metadaten platziert ,
die die Konstante und die Metadaten definieren und den Wert in
den
Zwischensprachencode einbetten . nach der Initialisierung. Dies bedeutet,
dass während der
Laufzeit unter der Haube keine Speicherzuweisung als vier Konstanten erfolgt, der schreibgeschützte Wert
ist keine Konstante. Es wird im Lader-Heap gespeichert
, einem
Gedenktyp, der erst
zugewiesen werden kann, wenn der
Typ geladen ist. Also eigentlich war das
alles, was ich dir sagen wollte. Wir sehen uns im nächsten.
5. C# erweiterte Reichweite und Sichtbarkeit: Hallo zusammen und willkommen zurück. In diesem Video
werden wir
über Umfang und Sichtbarkeit sprechen . Das sind also sehr wichtige
oder grundsätzlich entscheidende Konzepte, die es zu verstehen gilt. Und die meisten
Programmiersprachen da
draußen beinhalten
dieses Konzept. Das Layout, die Struktur,
in der sich Ihre Daten befinden, und sie zeigen die Richtung an, in
die die Daten fließen dürfen. Zunächst werfen wir einen
tieferen Einblick in die Sichtbarkeit, um den Umfang zu überprüfen. Wenn wir zum Beispiel über Sichtbarkeit
sprechen, müssen
wir
eine Klassenmethode und eine
variable Sichtbarkeit oder
zumindest diese Konstrukte in Betracht ziehen . Es gibt jedoch fünf
verschiedene Arten der Sichtbarkeit. Der erste ist öffentlich, der zweite ist geschützt. Die dritte ist intern. Kräfte geschützt intern,
und der fünfte ist privat. Public ist der
verzeihendste Sichtbarkeitstyp. Das auf diese Weise definierte Mitglied
kann von überall aus erreicht werden. Die
angegebenen geschützten Mitglieder können nur von derselben Klasse
oder von innerhalb der Klasse aus
erreicht werden . Die angegebenen internen Mitglieder können vom
selben Projekt aus erreicht werden. Und die geschützten
internen Mitglieder
können vom
selben Projekt oder von den Klassen,
die von der Klasse
erben,
entweder von einem anderen Projekt, erreicht Klassen,
die von der Klasse
erben,
entweder von einem anderen Projekt, werden. Die angegebenen privaten Mitglieder können von anderen
Mitgliedern derselben Klasse erreicht werden. Standardmäßig sind Klassenstrukturen auf diese Sichtbarkeitsstufe
festgelegt. Dies ist am restriktivsten. Sehen wir uns die Demonstration an. Im Namespace haben wir Sichtbarkeit
der öffentlichen Klasse. Und wir werden die
öffentliche String-Nachricht haben,
was bedeutet, dass ich
von überall aus sichtbar bin. Und wir werden die geschützte
Saitenstrahl-Nachricht nur von demselben Glas erhalten. Und interne String-Nachricht nur innerhalb
desselben Projekts. Und wir werden
die private
String-Nachricht haben , Dao-Chatbot. Wir werden also die öffentliche Leere haben. Aber eine architektonische Botschaft. Diese geschützte Nachricht
wird die Konsole verwenden. Rechte Zeile, B-Meldung und Konsolen-Punkt-Schreibzeile. Aber wenn die Botschaft, was wir
jetzt haben können, eine andere Klasse
ist. Also öffentliche Klasse B, die
von der Sichtbarkeitsklasse erben wird. Und die öffentliche Statik. Ungültig. Main wird das machen. Also Sichtbarkeit, eine neue Sichtbarkeit. Und eine Sichtbarkeit B wird eine
Sichtbarkeit sein. Halte durch. Was wir gerne
tun würden, ist die Telefone zu benutzen oder eine Nachricht
zu schreiben. Ein oder ein Punkt. Schreiben Sie line eine Nachricht in die Konsole dot write
line aid bei p0 message. Und sei Goodall, hat Message. Dann werden die Kegel gelesen. Jetzt kann das also gelöscht werden. Wir sollten die richtige Linie haben und wir werden die P-Botschaft haben. Wir haben die Sichtbarkeit der Augen, und wir haben die öffentliche
statische Leere, main. Dies wird
die neue KI-Sichtbarkeit sein. Wir haben die Sichtbarkeit
V. Und das Ich ist das eine Sichtbarkeit ist neu Ich Sichtbarkeit als neue Sichtbarkeit zu
sein. Und wenn wir das ausführen, sollten
wir die
folgende Ausgabe haben. Das zeigt also
die Sichtbarkeit. Wenn wir
über Bereiche sprechen. Dieses Konzept definiert einen Teil der Anwendung, in dem auf
die Variable zugegriffen werden kann, und es wird als Gültigkeitsbereich einer Variablen bezeichnet
. Oder Variablen können in
Klassen, Methoden und Schleifen definiert werden . Wenn wir zum Beispiel
eine
Variable auf Cast-Klassenebene definiert haben , sieht das so aus. Also öffentliche Klasse a. Und wir können das
Ereignis a haben, das sechs ist. Und wenn wir
eine Variable in der Klasse
außerhalb einer Methode deklariert haben , kann auf
sie
überall in der Klasse zugegriffen werden. In unserem Fall, genau
wie die Variable a. Wenn wir eine Variable auf
diese Weise definieren, werden sie Klassenfelder
oder Klassenmitglieder
genannt. Wir können also auch über die Sichtbarkeit
auf Methodenebene sprechen. Und wir können
zum Beispiel void definieren. Zuerst. Das wird unsere Methode sein. Und wir werden ein doppeltes C haben, was zehn
sein wird, das ist 0. Und wir könnten die
Konsole in der rechten Zeile C haben Auf
diese Weise zeigen wir, wie
Methoden unseren eigenen,
ihren eigenen Namespace und die darin definierten
Variablen kapseln . Wir können sehen, wie der Wert
der
Variablen ausgedruckt werden soll. Und wir können auch Variablen auf
Blockebene erstellen. Und diese
in einem Block definierten Variablen werden
nur leben oder zugänglich sein während wir uns in der
Blockausführung befinden. Das war also alles,
was ich Ihnen
über Umfang und Sichtbarkeit zeigen wollte . Wir sehen uns im nächsten.
6. C# Advanced Unsafe: Hallo zusammen und willkommen zurück. In diesem Video
werden wir
über unsicher in C-Sharp sprechen . Im Grunde
sprechen wir also von unsicherem Code in C Sharp. Wenn wir den Code codieren, führen
wir den Code ohne
Überwachung der CLR aus, was für die Laufzeit der
gemeinsamen Sprache kurz ist. Unsicherer Code ist also ein Code
, der Zeiger enthalten kann. Sie können also zu dem
Schluss kommen, dass die Zeiger in Csharp
unsicher sind. Es ist jedoch nicht
ganz richtig und wir sind hier, um dieses Geheimnis zu
beleuchten. Die CLR steuert also
die Ausführung von Programmen vom Laden in den Speicher bis zur Sicherheit der
Ausnahmebehandlung. Es gibt zahlreiche
Einrichtungen, die von
CLR bereitgestellt werden, und es gibt zwei
Einrichtungen, die bereitgestellt werden. Der erste ist der
Garbage-Collector
, der nach ungenutzten Objekten
aufräumen soll. Und das zweite ist das
Thread-Management. Es gibt also zwei Hauptkomponenten
des.net-Frameworks. Wir haben das Basislabor BCL, das die Basisklassenbibliothek ist, und die CLR, die die
gemeinsame Sprachlaufzeit ist. BCL ist also nichts anderes als
die standardmäßige Dotnet-Bibliothek, die
über Konsolen-Apps,
VPN-Apps, ASP.Net usw. zugegriffen werden kann . Es handelt sich um eine Reihe
vordefinierter Klassen und Funktionen
, die Sie wiederverwenden können. Also kann ich im Grunde in zwei weitere Teile
zerlegt werden, den CTS, CTS und den CLS. Die CTS ist die allgemeine
Typspezifikation und die CLS ist die gemeinsame
Sprachspezifikation. Wir müssen
zwei weitere Konzepte klären , die notwendig sind, um die
Ausführung des Antwortcodes und deren Bedeutung zu verstehen. Also zwei Arten von Code, der
verwalteter Code und nicht verwalteter Code ist . Der verwaltete Code wird
als sicherer Code betrachtet. Der nicht verwaltete Code ist unsicher. Managed Code
läuft also grundsätzlich vollständig unter der
Aufsicht von CLR. Es wird automatisch verfolgt und Müll
gesammelt. Es hat auch Zugang
zum gesamten Arsenal an
Einrichtungen, die von CLR bereitgestellt werden. Jetzt kommen die Hinweise. Daher werden Zeiger nur im Kontext
interpretiert, im
Kontext von nicht gespeichertem oder
unsicherem oder nicht verwaltetem Code. Und ein Zeiger
kann ein Zeigertyp, ein Wertetyp oder ein Referenztyp sein. Um also einen Zeiger zu definieren, benötigen
wir den folgenden Code. Wir können einen int-Stern haben
, der mein int-Zeiger
genannt wird. Und wir können einen leeren
Stern haben, meinen Leeren-Zeiger. Und der Name des
Typs, der vor
dem Asterix definiert ist, wird Referenztyp genannt
. Zeigertypen erben
nicht von der
Objektplatz-Basisklasse und es findet keine Konvertierung zwischen Zeigertypen und der
Basisobjektklasse statt. Wir können auch
mehrere Zeiger definieren. Also int, Stern für Schaden, meine Gesundheit, meine Erfahrung usw. Der Garbage Collector schützt die Referenzen des
Objekts
nicht . Das bedeutet, dass der Garbage-Collector, selbst wenn er auf
eine Referenz oder eine Struktur
zeigt ,
die Verweise enthält, diese sammeln
kann, oder wenn er sie sammelt. Wenn also verboten, ist
es verboten, dass ein
Zeiger auf eine Referenz oder eine Struktur zeigt
, die eine Referenz enthält. Und wir können Zeiger
der Basistypen in C-Sharps haben. Also lass es uns demonstrieren. Ich werde das kommentieren. Also hier haben wir ein Array, das zwei ganze Zahlen
enthalten wird, die 12 sein werden. Und wir können
den festen int Stern verwenden , p ist gleich 0. Hier möchten
wir P2 haben, was p entspricht, und
die Konsole, die Konsole, rechts,
Linie,
Stern V2 oder Asterix P2 verwenden rechts,
Linie, . Um
das Rot auf der ganzen Linie loszuwerden, können
wir sagen, dass dies unsicher ist. Und im Grunde sehen
wir uns danach den Beweis an. In Ordnung. Lass uns die Konsole benutzen. Es gibt drei Schlüssel
, um den Wert zu lesen. Wie Sie jetzt sehen können, haben
wir einen Zeiger
,
der auf das erste Element des
Arrays zeigt , das eins ist. Und das Schlüsselwort answer if
markiert den Abschnitt des Codes , der für den Compiler Zeiger enthält. Das feste Schlüsselwort bedeutet, dass wir den Asterix
feststecken, sehr fähig sein. Also dieser auf unserem
Haufen und der letzte Asterix plus gleich
eins wird Ehrerbietung genannt. Sie referenzieren sich. Also, wenn wir weitermachen
und
so etwas tun, dann ist Asterix p plus eins. Dann können wir die Konsole
dot write line asterix be verwenden. Wenn Sie es jetzt ausführen, können
Sie sehen, dass wir
unseren Zeiger mit einem Index bewegt haben. Es gibt also eine Liste
von Operatoren und Anweisungen, mit denen wir Zeiger in der
Antwort im Kontext
manipulieren können . Wir können also grundsätzlich
den Mitgliederzugriff haben. Wir können die Indizierung haben, wir können die
Adresse einer Variablen haben, wir könnten die
arithmetischen Operatoren haben, und wir können
Vergleichsoperatoren haben und so weiter. Wir können also auch einige
Anweisungen haben, die fest sind und Stapel sind log so festgefahren und gesperrt bedeutet Denkmal
auf dem Stapel zugewiesen wird. Und wenn Sie die
Antwort auf Coat-Eigenschaften überprüfen möchten, können
wir Methoden,
Typen und Codeblöcke haben , die als sicher definiert werden können,
da der Code für
native Funktionen erforderlich ist , die
auf Zeigern und Asif-Code, der Sicherheits- und
Stabilitätsrisiken von
Code einführt , der
unsere Unterblöcke enthält ,
muss mit
unsicherem kompiliert werden , was wir hier behoben haben. Und in einigen Fällen, als
ob Gott zu einer
besseren Leistung führen kann , da die
Prüfungen der Array-Grenzen entfernt werden. Das war also alles, was ich dir über unsicher zeigen wollte
. Wir sehen uns im nächsten.
7. C# Erweiterte Generische Sammlungen: Hallo zusammen und willkommen zurück. In diesem Video werden
wir über
generische Sammlungen sprechen ,
damit wir anrufen können. Das sind also
Programmiersprachen, die zum Leben erweckt wurden. Normalerweise gab es eine
gemeinsame Anforderung unter ihnen, und die Leute wollten Daten strukturiert speichern ,
um
sie später abzurufen und zu bearbeiten. Das waren generische Operationen
, die üblicherweise für diese
Datensätze
ausgeführt werden , wie ungerade ,
entfernen, suchen, sortieren,
ersetzen, kopieren ,
klonen, Anzahl der
gespeicherten Elemente usw. C-Sharp und Dotnet sind in dieser Situation keine
Ausnahme. Es gibt also grundsätzlich zwei
Arten von Sammlungen, die mit einem Rahmen
ausgestattet sind , der uns
zur Verfügung steht. erste ist Januar und der andere
ist nicht generisch, aber ich musste Version zwei dotnet, es gibt nur Sammlungen. Und wenn Sie
nicht generische Sammlungen kategorisieren möchten, können
wir über
ArrayList, Hash-Tabelle,
sortierte Liste, Stapel, Warteschlange sprechen sortierte Liste, Stapel, Warteschlange und die generischen Sammlungen zumindest Wörterbuch ist
sortiert Listenstapel und Warteschlange. Der Hauptunterschied zwischen
genetischen und nicht-genetischen
Sammlungen besteht also genetischen und nicht-genetischen
Sammlungen darin, dass der Wert der Arten, die sie in der
nicht generischen Sammlung speichern können. Jedes Element kann
den Wert eines anderen Typs repräsentieren. Während das generische bedeutet, dass Sie nur den gleichen Typ haben
können. Im Grunde brauchen wir also
das System, dass Sammlungen generisch
sind, um es zu verwenden. Und es ermöglicht uns, zum Beispiel
eine Liste von ganzen Zahlen zu
erstellen, die
als meine Liste bezeichnet wird. Und im Grunde wollen wir
eine neue Liste mit
beispielsweise zehn Werten. Das bedeutet, dass wir eine Liste
haben, die nur ganze Zahlen speichern
kann. Es heißt mylist und hat ohne
die
using-Anweisung halbe Werte ausgeführt ohne
die
using-Anweisung halbe Werte Wir könnten es auf
folgende Weise angeben. Also könnten wir im Grunde den vollständigen Pfad
angeben. Das ist nur interessant. Für dein Interesse. Was wir auch tun können, ist die nicht generische Hash-Tabelle zu überprüfen . Eine Hash-Tabelle. Wir sollten es meinen Hash nennen. Und das wird
einen neuen Hash haben, die Bar oder besser gesagt Hash gesetzt. Hash setzt und zeigt mögliche Korrekturen an. Also System, das Wahlen aufruft, dieses Generikum, dieses Hash-Set. Okay, dann
haben wir das HashSet. Und das sollte wie eine Ganzzahl oder
so sein. Und wir haben es
mit den n-Werten zu tun , nein. Januar in Kapazität. Oder es sollte HashSet D sein. Aber es sollte
C-Sharp-Hash sein , Hash-Hash-Tabelle. Also lass uns das
mit der Hash-Tabelle machen . Also lass es uns akzeptieren. Oh, das sollte
ein Systemaufruf sein , der den Bug
hasht, meinen Hash. Und jetzt können wir weitermachen. Nennen wir dieses
neue System also im Grunde Wahlen. Der Ball. Großartig. Was wir also tun können, ist
das Folgende, mein Hash. Und wir werden zuerst die Fähigkeiten haben, die wir mit dem Wert
teilen. Und mein Hash diese Ed Lu-Site. Und das
sollte als zweitens bezeichnet werden. Jetzt großartig. Was wir also hier tun können,
ist Folgendes. Also für jede 13 D in meinem Hash. Und ich denke, das wird
auch von
den Systemsammlungen dieses
Wörterbucheintrags kommen . Großartig. Was wir auch tun können, ist
es einfach hier auszulagern , indem wir das System verwenden
, das Sammlungen verwendet. Und jetzt können wir es entfernen. Großartig. Wir würden also
gerne über diese iterieren und die rechte Zeile der
Konsole verwenden. Und wir hätten den
D-Schlüssel , der diesem Wert entspricht. Und benutze die Konsole, um den Schlüssel zu lesen. Um diesen
Wert zu akzeptieren, führen wir ihn aus. Und wenn Sie es ausführen, sollten
wir die
folgende Ausgabe sehen. So
können wir also die Hash-Tabelle verwenden. Was wir auch tun können, ist
eine generische ArrayList. Lassen Sie uns also im Grunde eine Array-Liste
erstellen. Meine Liste entspricht auch der
neuen Array-Liste. Und in diesem Fall würden wir kein
Argument vorbringen. Und benutze meine Liste, um
eine Meile hinzuzufügen,
um meiner Liste drei
lineare hinzuzufügen und so weiter. Also nur zur Demonstration, und für jedes Objekt war
für Element in meiner Liste, zwei, würden wir weitermachen und Punktschreibzeilenelement trösten. Großartig. Was wir jetzt tun können, ist die Ausgabe nach der Ausführung auf dem
Bildschirm zu sehen. Und im Grunde ist es das. Es gibt also auch ein anderes Konzept , das
Boxen und Unboxing genannt wird. Und dieses Konzept ist
sehr wichtig, wenn wir in C Sharp mit
Generika arbeiten. Im Allgemeinen bietet das Konzept und seine Realisierung
einige Vorteile
der stark typisierten Sammlungen
und bieten qualitativ hochwertigeren und
leistungsgesteigerten Code. Es gibt zwei Hauptkategorien
für den Datentyp C-Sharp. Einer heißt Wertetyp und der andere
heißt Referenztyp. Das Boxen ist der
Prozess der Konvertierung eines Wertetyps in einen
Referenztyp. Und hinter den Kulissen weist
die CLR dem Heap
ein neues Objekt zu kopiert
dann den Wert des
Wertetyps value
in diese Instanz. Zum Beispiel haben wir
eine Ganzzahl, die ein
b mit dem Wert 99 ist, ein Objekt B, das gleich a
ist. Und ändern wir es auf diese Weise. Und wir haben a, C
mit der Ganzzahl b. Und jetzt können wir die rechte Zeile der Konsole
benutzen, siehe, plus b, plus a. Und los geht's. Es gibt also keinen Raum
zwischen dem Raum,
der nicht irreführend ist. Und los geht's. Technisch gesehen war das
alles, was ich zeigen wollte. Du. Wir sehen uns im nächsten.
8. C# Erweiterte Explicit vs Implizite Conversions: Hallo zusammen und willkommen zurück. In diesem Video werden wir unsere C-Sharp-Reise
fortsetzen. Und wir werden über
explizite und implizite
Typkonvertierung sprechen . Im Grunde
gibt es also zwei Hauptkategorien
von Programmiersprachen. Die erste ist statisch tabulatorisch und die zweite ist
dynamisch typisiert. Also haben
diese statisch getippt wie C-Sharp, C, C plus, plus und so weiter. Und dynamisch typisiert ist wie Python und Ruby und so weiter. Und dynamisches Tippen wird manchmal auch als Duck Typing bezeichnet
. Also, wenn es
aussieht wie eine Ente, läuft es wie eine Ente und
quakt wie eine Ente. Dann ist es wahrscheinlich eine Ente. Wir werden uns die Funktionen von
C-Sharp in Bezug
auf die statische
Typisierung in C-Sharp ansehen C-Sharp in Bezug
auf die statische
Typisierung in C-Sharp Wenn eine Variable deklariert wird, kann
sie nicht
erneut deklariert oder
einem Wert eines anderen Typs zugewiesen werden. Typ. Typ ist implizit einen
bestimmten Variablentyp
konvertierbar. Dies wird während des
Kompiliertyps entschieden und stellt eine Einschränkung dar, wie ein Entwickler
Deklarationsvariablen verwenden würde, obwohl es auch zu
einer Geschwindigkeitsbegrenzung bei der Ausführung kommt. Statisch typisierte
Sprachen sind also normalerweise schneller als dynamisch
typisierte, aber beide haben ihre Vorteile
und diese Vorteile. Wenn
wir also zum Beispiel sagen, dass wir in C-Sharp
eine Ganzzahl haben , die j
ist, können wir das Folgende nicht tun. Weisen Sie eine Zeichenfolge als Wert zu. Das wird es einfach
nicht schneiden. Aber was wir tun können
, ist einen Wert von
zehn zuzuweisen oder das Folgende als 0 zu tun. Die sollen funktionieren. Und das würde uns eine Anzeige geben oder weil die Ganzzahl und eine Zeichenfolge oder nicht
implizit konvertierbar sind, könnte
es eine
Zeit geben, in der wir hier einen Wert eines
anderen Wertes
kopieren müssen , Wert von a Variable
an eine andere Variable, wie die Übergabe einer Ganzzahl an
eine Methode, die doppelte lange Argumente benötigt oder a bleibt, um Variablen zwischen Klassen zu pushen. C-Sharp bietet also Möglichkeiten einen Typ
in einen anderen zu konvertieren. Einer ist implizit, der
andere explizit. Die dritte ist benutzerdefiniert und die vierte ist die Konvertierung
mit Wrapper-Klassen. Typkonvertierung wird also auch Casting oder Typecasting
genannt. Implizite Konvertierungen. Was sollten wir über sie wissen? Wenn wir
über implizite Konvertierung sprechen, ist
das im Grunde keine spezielle Syntax
für diese Typkonvertierung. Dies ist die sicherste
Art des Gießens. keine Daten verloren. Zum Beispiel die Konvertierung
von kleineren zu größeren Integer-Typen oder
Klassen in Basisklassen. Das ist eine implizite numerische
Umrechnungstabelle,
die sich als nützlich erweist, wenn wir
herausfinden möchten , welche ganzen Zahlen kompatibel
sind. Und Sie finden es hier
auf der Microsoft-Seite. Und zum Beispiel könnten
wir für eine
implizite Konvertierung Folgendes verwenden. Verstecken wir das. Wir haben also eine Ganzzahl, die Zahl 128
heißt, und wir hätten ein Double, das größer
ist und der Zahl entspricht. Und die Amplitude ist ein Beispiel
für die implizite Umwandlung von Klasse in
Basisklasse in etwa so. Klasse a entspricht einer neuen Klasse. Und wir hätten
die Basisklasse C, die a entspricht. Dies ist nur ein Beispiel, da diese nicht genau definiert sind, aber so
könnten und sollten Sie es tun. Und es gibt eine Reihe
von Konvertierungen, Untertypen, die alle
als implizit betrachtet werden. Also zum Beispiel
Identitätskonvertierungen, implizite numerische
Konvertierungen und so weiter. Jetzt haben wir implizite
Konvertierung aus dem Weg, wir sollten über
X plus ruhige Versionen sprechen. Diese Art des Gießens
beinhaltet also auch einen Kostenoperator. Und der Prozess ist normalerweise mit
Informationsverlust oder
fehlender Konvertierung zwischen typischerweise
nicht metrischen Konvertierungen
verbunden . Ich erwähnte, wenn wir von
einem Datentyp
mit größerer Genauigkeit in eine niedrigere Genauigkeit konvertieren und manchmal die Konvertierung
von einer Basisklasse in
eine Datenbankklasse
auch hier erwähnt wird. Ein Beispiel für eine explizite
Konvertierung wäre also mein Pi. Und wir würden sagen, dass
wir eine ganze Zahl a haben und wir möchten den Wert als Ganzzahl
meines Kuchens mit a verknüpft haben. Und wenn wir die rechte
Zeile
der Konsole mit a und meinem b verwenden würden , wir würden den folgenden
Guanzhong-Gierschlüssel bekommen. Speichern wir es und führen es aus. Wir können also sehen, dass die Dezimalzahl, die Zahlen nach dem
Grenzpunkt. In diesem Fall können wir
über ausgeführte Konvertierungen
zwischen Klassen sprechen . Wir haben zum Beispiel eine OPA-Klasse, die das Auto ist. Und das wäre eine
Instanz der Oberschicht. Und wir werden ein Auto C haben, das gleich o sein wird. Und wir hätten die
OPA o gleich c. Das ist
also ein Beispiel für eine explizite Konvertierung zwischen
Klasse und Basisklasse. Und im Grunde ist es das. Was ich dir zeigen wollte. Wir sehen uns im nächsten.
9. C# Erweiterte Expression gedämpfte Funktionen: Hallo zusammen und willkommen zurück. Was wir nun in C-Sharp
lernen möchten, ist das Thema, der Ausdruck, aber
es funktioniert Syntax. Aber Funk, Synth sparen nicht. Okay. Mit der Version von Version
sechs der Sprache C Sharp wurde
diese Funktion
der Programmiersprache hinzugefügt. Es wird
Ausdruckskörpermitglieder genannt. Die Idee hinter dieser
Funktion war,
den Code
lesbarer und übersichtlicher zu gestalten . Und wir werden in diesem Video
sehen wie diese neue Funktion in unseren Code
integriert werden kann. Wir haben also das
Members-Konzept in C-Sharp, und es bezieht sich auf
objektorientierte Programmierung. Zahlen ermöglichen es uns
, das Verhalten
unserer Klasse zu ändern und die Art und Weise zu ändern,
wie sie
mit anderen Klassen interagiert , und
sie und gekapselte
Informationen nach Bedarf zu lassen Mitglieder sind also der Klebstoff, der die Anwendung
zusammenhält. Also
welche Mitglieder sind verfügbar? Wir haben Konstruktoren,
Destruktoren, Property-Getter und -Setter,
Methoden und Indexer. Der Ausdruck aber
in Mitgliedern kann
auf jeden der
oben genannten Punkte angewendet werden , aber wir müssen
überlegen, welcher in unserer
aktuellen Version
verfügbar ist . Also unterstützte Versionen
aus der Version sechs, den Property-Getter und die Methoden. Ab Version sieben
der Konstruktor, Destruktoreigenschaftssektor und die Indexer. Nehmen wir also ein Beispiel für den Konstruktor und den Destruktor. Also werden wir im Grunde einen Klassenserver
haben. Innerhalb unserer Klasse haben wir
den öffentlichen String-Namen und den String-Namen des öffentlichen Servers gleich name, gleich name. Und wir müssen
sicherstellen, dass dies das große M und das große N
ist. Okay, jetzt könnten wir unseren Destruktor
für den Server
haben. Und wir könnten einfach in der rechten Zeile
der Konsole sagen , dass das Ende nahe ist. In Ordnung. Nun, was wir hier hätten, nennen
wir diesen öffentlichen
Klassen-Const-Kumpel. Und wir hätten unsere
öffentliche statische, leere Hauptleitung. Und wir hätten den Server
, der vom neuen Server stammt. Dann hier, oder eher
Domänencontroller. Und danach könnten
wir den Konsolenpunkt verwenden, Zeile einen Namen
schreiben und den Konsolenschlüssel verwenden. Warte auf die Aufforderung. Wenn wir es jetzt ausführen, können
wir die folgende ODE sehen. Und ja, im Grunde ist es das. So
können wir es für Mitglieder verwenden. Was wir auch tun können, ist
es für grundsätzlich Accessors zu verwenden. Also, wenn mein Server zum Beispiel eine öffentliche in V-CPU haben
soll, dann könnten wir
das get
die v Scott v CPU zurückgeben lassen , und der Sektor gibt den Unterstrich V
CPU gleich Wert zurück. Und ja, wir hätten auch die
private int underscore V CPU. So könnten wir es also im Grunde
auf die Zugriffsquelle anwenden . Wir könnten also weitermachen und
eine vCPU verwenden, die zehn entspricht. Und wir könnten
es zu unserer Ausgabe hinzufügen. Wenn wir es ausführen, können
wir sehen, dass dieser Server zehn Kerne hat. Und wir könnten auch
einen Indexer verwenden lassen. Wenn wir also
die öffentliche Zeichenfolge definieren und dieses Netzwerk
aufrufen, könnte
dies eine neue
Zeichenfolge mit fünf Werten sein. Und wir könnten
den public String benutzen. Und das int bekomme ich
Netzwerkadapter. Und Netzwerkadapter
sind gleich Wert. Und da haben wir die Netzwerkadapter
mit dieser Zeichenfolge. Und wir sollten dieses Ich und dieses mit dem Index haben. So würden wir es für Indexer
verwenden und wir könnten es auch für Methoden verwenden. Wenn wir also unsere öffentliche Lücke
definieren, könnten
wir im Grunde genommen die
rechte Zeile der Konsole hochfahren lassen. Und dann sag, dass der
Staat Started gleich ist. Und damit das funktioniert, müssen
wir den
privaten String-Zustand der Kneipe definieren. Und das ist irgendwie alles. Das ist also alles,
was ich dir
über den Ausdruck sagen wollte ,
aber er funktioniert. Das ist also eine neuere
und prägnantere
Möglichkeit , deine Klassen
mit all ihren Leckereien zu nutzen. Wir sehen uns im nächsten.
10. C# Advanced Operator Vorrang: Hallo zusammen und willkommen zurück. In diesem Video werden
wir über die Rangfolge von
Operatoren in C-Sharp sprechen . Also lasst uns dafür ein neues
Projekt erstellen. Im Grunde wird also die Reihenfolge der
Begriffe und Ausdrücke in jeder Programmiersprache Ergebnis
der Bewertung
bestimmt. Und die
Rangfolge der Operatoren in C-Sharp bestimmt, wie die
Gruppierung dieser Begriffe und
Ausdrücke erfolgt. Und wir werden
die Grundlagen durchgehen , was Sie über diese Technik
wissen müssen , und
semantisch korrekte Apps erstellen. Es gibt also drei
verschiedene Arten von Operatoren, die
unäre, binäre und ternäre Operatoren sind . Und diese definieren, wie viele
Operanden und Operatoren aufnehmen können. Die Vereinigten nehmen einen, die Binärdatei zwei und die Gerberei
drei Operanden. Wir müssen
über Assoziativität sprechen. Im Grunde gibt es also zwei
Arten von Assoziativität eine ist die von links nach rechts
und von rechts nach links. Und die Operatorpriorität ist nur dann von Bedeutung, wenn ein Ausdruck
Operatoren mit
höherer und niedrigerer Priorität enthält. In diesem Fall
ist die Priorität von links nach rechts. Zum Beispiel ist int x gleich sieben plus drei geteilt durch zwei. Die Reihenfolge, an die wir uns
erinnern müssen , ist, dass
wir, wenn
wir über Harn sprechen, diese folgende Stärke haben. Wir haben also die Größe
des Endes, des Sterns. Die Plus-,
Minus , Negations-,
Plus - und
Minus-Präfixe. Und dann haben wir Type Cast. Wenn wir über
bedingte Ausdrücke sprechen, haben
wir das
Fragezeichen und die Spalte. Und wir haben einfache
zusammengesetzte Zuweisungen, wie gleich mal gleich
geteilt durch gleich, und so weiter. Und wir können grundsätzlich die Priorität der
Operatoren durch Klammern
ändern, und das meine ich damit. Im ersten Fall teilen
wir zuerst drei durch zwei und addieren dann sieben. Im zweiten Fall würden
wir 37 addieren und
dann durch zwei dividieren. Das war also alles was ich zeigen
wollte. Du. Wir sehen uns im nächsten.
11. C# Advanced Method Ein- und Ausstiegspunkte: Willkommen. In diesem Video werden wir
über Methoden,
Ein- und Ausstiegspunkte sprechen . Jede C, C-Sharp-Anwendung
hat also einen Anthropologen
namens Hauptmethode. Diese Methode wird
zuerst aufgerufen und
die Geschäftslogik, die in Ihrem AP implementiert
ist,
wird gesteuert. Von hier aus. In diesem Handbuch werden
wir herausfinden, wie CRM CLR, damit die Common Language Runtime weiß, welche Methode wann aufgerufen werden muss. Und wir werden den Unterschied in
diesen Kontexten zwischen
den ausführbaren Anwendungen
und Bibliotheken
sehen diesen Kontexten zwischen
den . CLR ist also die gemeinsame
Sprachlaufzeit. Es dient dazu, Ihren Code so zu
übersetzen , dass die Hardware
Ihrer Maschine Ihre Absichten verstehen
kann. Wenn Sie den
Code in C-Sharp schreiben, wird er
als Quellcode bezeichnet. Der
sprachspezifische Compiler
wird diesen
Code in etwas verwandeln, das MSAL oder Microsoft
Intermediate Language
genannt wird. Und manchmal wird es auch als CIR
oder gemeinsame Zwischensprache
bezeichnet . Und im Grunde hat
der Zwischenzustand
des Codes auch sprachspezifische Metadaten
und Typimplementierung und die tatsächliche Implementierung jeder
unserer Klassen, Funktionen, Methoden, und so weiter. Jetzt greift die CRM CLR
ein und bietet einen Service und die Laufzeit für Ihren Code und den GIT, der Compiler für
die Anpassungszeit, befindet sich
ebenfalls in diesem RAM
, der den Code
in Maschinencode umwandelt was wiederum von
der CPU auf Ihrem Computer ausgeführt wird. Das einfachste Beispiel ist das, was
Sie auf dem Bildschirm sehen können. Also Ponzo, diese richtige
Linie, hallo Welt. Und wenn wir diesen Code ausführen, können
wir sehen, dass die Hello World auf der Konsole
ausgedruckt ist. Und danach wird es geschlossen. Wenn wir also eine App haben, die mit einer ausführbaren Datei
verglichen wird , haben
wir zwei unterschiedliche
Ansätze für Einstiegspunkte. Einer ist synchron und der
andere ist asynchron. Der Typ der Hauptfunktion
ist immer statisch. Und wir haben die Möglichkeit
zu wählen, ob wir den Statuscode
zurückgeben möchten , nachdem die Anwendung vorhanden ist oder nicht. Und wir müssen
Integer verwenden, sonst void. Synchrone
Methoden sind das also. Also wenn wir hier hingehen und das machen, also einfach Curly, komm schon. Wir haben ein main, das ohne Argumente
nichts zurückgibt. Eines ist mit Argumenten und das andere Main gibt eine Ganzzahl
ohne Argumente
zurück und das andere ist mit Argument. Und der andere Typ
würde so aussehen. Wir haben also etwas, das sich Aufgabe auf Domain
nennt. Und es kann auch Argument
- und Nicht-Argumentversionen haben. Warum ist es ein Duplikat? Die Ausgangspunkte dienen
als Kontrollmechanismus und übertragen die
Kontrolle zurück an den Anrufer. Entweder mit dem Rückgabewert
eines bestimmten Typs oder void. Die Hauptmethode,
die die Ausgangspunkte erreicht bedeutet, dass unsere Anwendung geschlossen ist. Wenn wir also zum Beispiel
sagen würden, dass wir 0 zurückgeben
werden, dann wird dies
sozusagen unser Ausgangspunkt in einer Funktion sein. Und mehr
wollte ich dir nicht zeigen. Wir sehen uns im nächsten.
12. C# Advanced Generische parameter: Hallo zusammen und willkommen zurück. In diesem Video
werden wir
über generische
Parameterbeschränkungen sprechen . So wurde Generic mit der Version
2 der Sprache und der CLR,
der gemeinsamen Sprachlaufzeit, Teil von
C-Sharp 2 der Sprache und der CLR,
der gemeinsamen Sprachlaufzeit, . Es wurde
ein neues Konzept von
Typparametern eingeführt , mit dem
Sie Klassen
und Methoden entwerfen können , die sich
von
der Spezifikation einer oder mehrerer Tabs unterscheiden von
der Spezifikation einer oder mehrerer Tabs bis die Klasse oder Methode
deklariert ist und
durch Client-Code instanziiert. Also, wenn wir zum Beispiel eine Klasse erstellen
würden, class generic array d, und sagen, dass wir
die public void haben. Fassen Sie die Eingabe zusammen. Und so könnte man eine generische Klasse
definieren. Und im Grunde diese Klassen und Methoden kombinierten
diese Klassen und Methoden drei
unterschiedliche Merkmale. Eine ist die Wiederverwendbarkeit, die
zweite die Typsicherheit und die dritte die Effizienz. Die Generika werden häufiger in Verbindung mit
Sammlungen und Methoden
verwendet , die auf ihnen basieren. Es wurde ein neuer Namespace eingeführt
, der als System
That Collections bezeichnet wird, dieser generische, der
mehrere neue generische basierte
Sammlungsklassen enthält . Wir haben auch die Möglichkeit, benutzerdefinierte generische Typen zu erstellen. Wir müssen also auch über
Parameter sprechen. Daher nennen wir den Parameter einen
Platzhalter für einen bestimmten Typ , den der Client
angibt, wenn er eine Instanz
eines generischen Typs
erstellt. Eine generische Klasse
kann nicht so verwendet werden, wie sie ist, da sie einfach eine Blaupause für diesen Typ ist und
wir einen
konstruierten Typ deklarieren und
dann nach einem bestimmten Volumetyp
instanziieren müssen einen
konstruierten Typ deklarieren und
dann nach einem bestimmten Volumetyp
instanziieren . Und dafür können wir ein
Beispiel haben. Wenn wir zum Beispiel dieses generische Array
haben, das eine Ganzzahl ist, würden wir es auf diese Weise instanziieren. Und sehen wir uns die
möglichen Korrekturen an. Wir haben keins. In Ordnung? In diesem
Beispiel haben wir die instanziierende
Instanziierung für den Blueprint eines generischen
Arrays mit Integer-Typen gezeigt. Und in diesem Fall wird
der Parameter t zur Laufzeit
ersetzt. Und mit dem Argument type , das es uns ermöglicht,
typsichere und effiziente Objekte
mit einer Klassendefinition zu erstellen . Es gibt einige Regeln für die Benennung, daher sollten generische
Typparameter
beschreibende Namen und den
deskriptiven Präfixtypparameter T
oder ähnliches haben beschreibende Namen und den
deskriptiven Präfixtypparameter T . Wir haben auch acht Einschränkungen , die wir berücksichtigen müssen. Also lass es mich einfach kopieren
und hier einfügen. Wenn d also ein Strikes ist, muss
das Argument ein Werttyp
sein, außer jetzt der Ball,
wenn es Klasse ist, muss
das Argument ein Referenztyp
sein und es gilt für
Klassen, wenn t nicht ist. Jetzt muss das Argument nicht, nicht liberal
sein. Wenn es nicht verwaltet wird, muss
das Argument
ein M sein und jeder Typ
ist eine Basisklasse. Das Argument muss von
einer Basisklasse aus behandelt werden. Wenn d eine neue Instanz ist, muss
das Argument einen
übergeordneten meterlosen Konstruktor haben. Wenn es sich um eine Schnittstelle
handelt,
muss das Argument bereits
in einer bestimmten Schnittstelle implementiert sein. Und wenn du es bist, muss
das Argument oder Papa mit aus dem für dich
bereitgestellten Argument sein. Warum verwenden wir also Einschränkungen? Durchsetzen von Einschränkungen oder
bestimmten Typparametern können wir die Anzahl
der zulässigen Operationen und
Methodenaufrufe auf die unterstützten erhöhen der zulässigen Operationen und . Und wir würden
gerne eine Demonstration
für die Prüfung
erstellen. Lassen Sie mich das einfach kommentieren. Nehmen wir an, wir haben eine Klasse, generische Klasse mit t, wobei t eine Klasse ist. Und wir können sagen, dass wir
ein privates schreibgeschütztes t haben, bei dem es sich um ein Feld handelt. Und wir haben eine öffentliche
generische Klasse, das Feld oder eher value. Und dieses
Unterstreichungsfeld ist gleich Wert. Wir haben auch die generische Methode public
t mit dem T-Bodenmesser. Und wir können weitermachen und die rechte Linie
der Konsole benutzen. Und sagen Sie, dass der Typ
des unteren Messgeräts sowohl T als auch Wert Wert ist. Oder eher unteres Meter oder Meter. In Ordnung? Und die generische Methode. Und Frauen müssen sicherstellen
, dass wir dieses Feld zurückgeben. Und wir können die rechte Zeile der
Konsole benutzen. Der Ausdruck, dass
der Rückgabetyp des Parameters Dipol ist. T-Wert. Dieses Score-Feld. In Ordnung, hier können wir unsere Klasse
instanziieren. Wir können also eine
generische Klassenzeichenfolge a haben, die der neuen generischen
Klassenzeichenfolge hello world entspricht. Und wir können den
generischen Methodenaufruf a dot verwenden. Und wir können die Punktschreibzeile der
Konsole verwenden, nicht die rechte Zeile, die Lesetaste,
um eine Sekunde anzuhalten. Und geben wir dem
die Argumentzeichenfolge. In Ordnung, führen wir es aus. Und wie Sie sehen können, haben
wir eine Zeichenkette mit
dem Wert string. Und los geht's. Das sind also die Botschaften
, die wir sehen können. Eigentlich war das alles, was
ich dir zeigen wollte. Wir sehen uns im nächsten.
13. C# Advanced Open und Closed generischen Typen: Willkommen. In diesem Video werden
wir über
die
generischen Typen Öffnen und Schließen sprechen . Mit der
zweiten Version von C Sharp wurde also ein neues Konzept eingeführt, das als Genetik bezeichnet
wird. Die Grundidee bestand darin, die Übergabe
bestimmter Typen wie
float, double
oder string
als Parameter an Methoden,
Klassen und sogar Interfaces zu ermöglichen bestimmter Typen wie
float, double oder string
als Parameter an Methoden, . Dies ist eine sehr wichtige
Einschränkung für Sammlungen,
bei denen es sich um eine fehlende oder sogar
fehlende Typprüfung handelt. Auf diese Weise können Sie
jedoch die Objekte
beliebiger Art der Zusammenschaltung hinzufügen ,
da sie alle von der
Objektbasisklasse abstammen. Dies widerspricht der
grundlegenden Definition von C, C-Sharp als typsicher
und umfasst eine Typsicherheit . In diesem Leitfaden werden wir uns eingehender damit befassen, was Generika sind und was sie offene und geschlossene Immobilien bedeuten. Die Typen in C Sharp haben
zwei Hauptkategorien. Einer heißt Wert und der andere heißt Referenztypen. Beide können generische Typen
sein , die
Eins-zu-Eins-Typparameter annehmen. Also der geschlossene Januar. Also eine der mächtigsten
Funktionen und C-Sharp, denen Entwickler
Typen von Datenstrukturen
wie Sammlungen definiert haben . Und das bedeutet, dass dies nicht nur zu einer
besseren Codequalität führt, sondern auch hinter den Kulissen eine ordentliche
Leistungssteigerung hinzufügt. Schauen wir uns an,
wie das aussieht. Wir werden ein Gerät der
öffentlichen Klasse haben. Und dieses Gerät wird
einen öffentlichen d0-Namen haben , Get and Set. Und die öffentliche T-Kategorie. Mit dem Gatt und dem Set. Wir werden die Öffentlichkeit im Griff haben. Das gehört hier. Das werden also die Generika der
öffentlichen Klasse sein. Und was wir
gerne tun würden, ist
die öffentliche statische, leere Hauptleitung zu haben . Und innerhalb der Hauptversion hätten
wir das Gerät
mit der Zeichenfolge
a als neuen Geräte-Domänencontroller. Und überspringen wir einfach den Namen. Okay, ja,
sollen wir das machen? Und wir haben das Gerät float
b mit dem neuen Gerät float. Und lass es uns einfach schließen. Und wir können das a,
diesen Namen als
Domänencontroller modifizieren . Und das ist eine Kategorie
, um dieses Ding zu sein. Und das gilt auch für das B.. Der DNS-Server wird
in diese Kategorie fallen. Und nennen wir es Produktion. Und was wir tun können, ist
zum Beispiel durchzuhalten. Dies sollte 1 f und
2 f sein. Also Konsole, rechts, Zeile, A, Name und eine Kategorie. Und das Gleiche gilt für B,
O, K und benutze den Doppelpunkt. Lesen Sie also den Schlüssel, um die Konsole zu behalten. Warum schauen wir uns das an? Da haben wir's. Wir haben eine generische Klasse erstellt , die ein Gerät darstellt. Und basierend auf dem
Typ des Generikums können
wir die Werte initialisieren. Und was wir auch tun können
, ist einen offenen Januar zu schaffen. Wir möchten also, dass dieser
Code dies demonstriert. Wir werden also eine öffentliche Klasse haben, o g mit dem T. Und wir müssen die
systemeigene Gedankenreflexion verwenden. Und hier haben wir
die Öffentlichkeit in M, g. Und wir werden ein
Woo Hoo gleich 0 haben. Um es nutzen zu können, müssen
wir eine
Instanz erstellen. Wir werden also eine
öffentliche statische Leere haben. Halte durch. Dies ist in der
Pflanzengenetik öffentlich. Statisches Objekt. Wird es laufen? Und das wird
den Typ von g enum geben dafür ein. Hol das kühlere rote Feld. Woo hoo. Und wir würden
gerne den Wert erhalten. Und jetzt können wir weitermachen und
ein neues
Instanzobjekt erstellen , das ausgeführt wird. Und wir werden die
Konsole in der richtigen Linie haben. Erzählen Sie uns Folgendes. Ist das generisch? Und wir verwenden das foo
, das
Typinfo eingibt und eine generische
Typdefinition ist. So können Sie die offenen Generika
definieren. Und indem Sie Reflexion verwenden , um ein konstantes
Feld zu erhalten, der Woo-hoo. Die CLR konvertiert
die Ganzzahl automatisch in eine
Instanz des offenen Typs. Also im Grunde war es das. Was ich
dir in diesem Video zeigen wollte. Wir sehen uns im Axon.
14. C# Erweiterte Out-Parameter und Abwerfen: Hallo zusammen und willkommen zurück. In diesem Video werden wir
uns zwei Funktionen ansehen, zwei Funktionen ansehen in der Version C sharp
seven
enthalten sind. Und diese Funktionen haben die Arbeitsweise der
Entwickler und die Entwicklung der
Anwendungen
wesentlich verändert . Der app-Parameter ist
praktisch, wenn Methoden mehr
als einen Wert zurückgeben
müssen. Und dieser Parameter wird
als Referenz übergeben und
transformiert im Grunde den formalen Parameter, ein Alias für
das Argument, das sehr fähig sein muss, dem
reference-Schlüsselwort
sehr ähnlich. Der Hauptunterschied besteht jedoch
darin, dass letzteres zuvor initialisiert werden
muss. Die verwirft grundsätzlich eine
temporäre Variable, also Dummy-Variablen, die im Anwendungscode
verwendet werden. Der
Hauptzweck dieser Katze besteht darin,
wiederverwendbare Variablen bereitzustellen ,
die die Speicherzuweisung verringern und die Lesbarkeit
und Wartbarkeit verbessern. Zunächst werfen wir
einen Blick auf den OUT-Parameter. Es gibt also im Grunde drei Regeln. Parameter können
ohne Deklaration
und Initialisierung übergeben werden . Es kann den var-Typ in der
Methodenparameterliste verwenden. Wir müssen nicht
den gleichen Namen für unseren Parameter in der
Funktion und im Kern haben. Also lass uns dafür eine Demo machen. Wir haben eine öffentliche
statische Zeichenfolge, SLA. Mit dem double a und double B. Innerhalb dieser Funktion
möchten wir ein Ergebnis haben,
das etwa ein mal b aus der
Mathematik stammt. Oder besser gesagt, wie
sollen wir das machen? B geteilt durch a. Und wir
möchten es mit 100 multiplizieren
und wir benötigen zwei Ziffern. Das
hätten wir also gerne. Und wir werden die
Zeichenfolge SLA haben, die der Gesamtzahl der verfügbaren Stunden
entspricht . Stunden. Und die SLA ist das Ergebnis. Was wir nun
gerne tun würden, ist SLA zurückzugeben. Und was wir danach
tun möchten, ist unsere
Funktionssignatur
grundsätzlich zu modifizieren. Und wir würden sagen, dass unser out double result und out string SLA andere Parameter sein werden. Und wir müssen die
Initialisierung daraus entfernen. Wir können diese Funktion
ab sofort aufrufen. Also Konsole rechte Linie. Und wir würden gerne verwenden,
was wir verwenden würden SLA. Und im Grunde möchten wir dann insgesamt Stunden
zur Verfügung
haben mit acht Stunden. Und wir würden
gerne das neuartige
Ergebnis haben. String SLA und verwenden Sie die Telefone sind der Schlüssel. Um es zu retten. Okay, fangen wir damit an. Und wie Sie sehen können, ist
dies das Ergebnis. Was wir auch tun können,
ist diese Karte zu benutzen. Diese Kartenvariablen haben
das Unterstreichungssymbol. Wenn wir zum Beispiel
eine Variable
namens Coupa mit 12345 erstellen , dann
machen Sie den Unterstrich. Unterstrich, Unterstrich entspricht Coupon. Dann können wir die rechte Zeile der Konsole
verwenden, die
erste und die zweite ausschreiben. Also lass es mich dir zeigen. Das ist also im Grunde das Einfache, dies ist ein einfaches Beispiel für das Verwerfen und wie man es benutzt. Und unsere Aufgabe bestand darin, zwei Variablen zu
erstellen ,
aus denen
benannte Variablen aus dem Coupon stammen, und
den Rest der Werte zu verwerfen. Und wenn wir
so
etwas sagen können, dann ist die wahre Stärke
dieser Karte, wenn wir
sie mit der äußeren Variablen kombinieren. Wenn wir zum Beispiel
public void, sorry, static,
void B, S mit der
Zeichenfolge d t haben .
Wenn dann die Zeit, die trocken
ist, den SDR und den Out-Unterstrich unterstrichen, dann könnten wir sagen, dass die Kegel auf dieser rechten Seite
Zeilendatum ist gültig. Andernfalls, Das Datum der
rechten Zeile der Konsole befindet sich in Guanzhong. Links. In Ordnung.
Vergessen wir diesen hier nicht. Und wenn wir weitermachen und
die P S mit der O2 anrufen können , 292022. Wir sollten
Folgendes auf unserem Bildschirm sehen. Und los geht's. Technisch gesehen ist
das alles, was ich dir in diesem Video
zeigen wollte. Wir sehen uns in der nächsten.
15. C# Advanced Preprocessor: Hallo zusammen und willkommen zurück. In diesem Video
werden wir
über
Präprozessor-Direktiven in C-Sharp sprechen . Im Grunde gehört
dieses Konzept also zum
Bereich der kompilierten Sprachen. Sind kompilierte Sprachen
oder Sprachen,
die übergeordneten Code
wie C-Sharp oder C benötigen. Und mit Hilfe des Compilers wird es
in Maschinencode übersetzt. Der Compiler ist eine
Abstraktionsschicht zwischen verschiedenen Architekturen
von Herstellern. Es weiß, wie man
Codeblöcke in
verschiedene Architekturen übersetzt . Also, ja, Intel
- oder AMD-Prozessoren. Und der Prozessor
selbst
garantiert nicht den endgültigen
Maschinencode. Wie der Name schon sagt
, werden nur
die Anweisungen vorverarbeitet. Wir haben eine höhere Sprache. Dann haben wir einen Präprozessor als eine reine Hochsprache, als einen Compiler und Assembler, Loader und Linker. Präprozessor-Direktiven können also die if-Anweisung als
Blatt sein und wenn und so weiter. Und wir
schauen uns ein einfaches Beispiel an. Wenn wir zum Beispiel diese Direktive verwenden wollen
, könnten
wir sagen,
dass wir beim Debuggen die Systemkonsole im
rechten Debug-Modus
sagen möchten . Wir würden gerne sagen,
Systemkonsole Punkt, schreibe Zeile und kenne den Fehler. Und dann bring es her. Und wir können das
mit der Endif-Anweisung schließen. Und hier haben wir
eine
Präprozessor-Direktive definiert , die besagt , dass dies nur im Debug-Modus
berücksichtigt werden sollte. Andernfalls drucken wir kein Debug
aus. Und wir können diese Lösung entweder im
Release- oder Debug-Modus
ausführen. Und standardmäßig ist der
Debug-Modus R1, und das ist die Ausgabe
, die wir sehen sollten. Also lasst uns weitermachen und die
Systemaufrufe oder die Lesetaste verwenden. Wenn wir die Lösung ausführen, können
Sie sehen, dass wir im Debug-Modus
laufen. Und ja, das war die Demo. Also haben wir ein undefiniertes definiert. Und diese Direktiven
können verwendet werden, um Direktiven
für den Präprozessor zu definieren oder undefiniert zu definieren. Und der häufigste Anwendungsfall dafür ist, wenn
wir zusätzliche Bedingungen für
die Kompilierung selbst
definieren möchten . Also wird das normalerweise
zusammen mit der def-Direktive gemacht. Und im Grunde könnten wir
weitermachen und den Entwickler definieren. Und wenn Betrug, möchten wir sagen, dass wir Debug
und undefiniert definiert definiert haben, brace und end if. Und wir sollten
es in den ersten aufnehmen. Das funktioniert.
Was wir also auch tun können, ist die Warnung oder
die Anzeige zu verwenden oder und im Grunde könnten
wir sagen, dass wenn wir nicht korrodieren, nicht testen und nicht Deb, eine Fehlermeldung ausgeben können die
besagt, dass dies nicht möglich ist kombinieren. Wir lassen eine
Warnmeldung aus
, die besagt , dass mit hartcodiertem ausgeführt wird. Und wir können
diese if-Anweisung beenden. Und wenn wir diese Lösung ausführen, sehen
wir nichts. Aber sobald ich diesen
entferne, sehen
wir, dass der Build
Erwachsene enthält und wir können die
Fehlermeldung sehen, dass wir nicht kompilieren können. Das ist also ein Verhalten
, das wir implementieren können. Was wir tun können, ist auch die align-Direktive zu
verwenden. aktive Zeile ermöglicht es uns , die
Nummerierung der Compiler-Folien und sogar den Dateinamen
für die Erwachsenen und Warnungen zu ändern Nummerierung der Compiler-Folien und sogar den Dateinamen . Nehmen wir an, wir
möchten
den Dateinamen ändern , der gemeldet wird, wenn
eine Warnung generiert wird. Also lassen Sie es uns hier platzieren
und diese Zeile sagen, eine, die Zeile C S
will Wenn wir das entfernen, sollten
wir in der Lage sein, unsere Lösung
auszuführen. Wir haben diese Ausgabe. In Ordnung? Jetzt möchten wir etwas über
Region und n Region lernen. Diese Direktiven sind also nützlich
, wenn wir mit dem
Visual Studio Code-Editor
oder mit dem Studio selbst arbeiten . Und es gibt keine spezielle
Ausgabe von dieser aktiven Diät, aber es ermöglicht Ihnen,
bestimmte Regionen zu markieren , die
erweiterbar sind und kollabieren, CBO durch den
Redakteur Ihrer Wahl
zusammenbrechen. So
könnten wir zum Beispiel sagen, dass eine Region verwendet und wir könnten sagen, dass
dies die Endregion ist. Und jetzt können wir
es zusammenbrechen. Und wir haben auch das Pragma, die Pragma-Warnung
und die Pragma-Prüfsumme. In einfachen Worten kann die
Pragma-Direktive verwendet werden, um zu beeinflussen, wie die
Berichte oder Warnungen zur Kompilierzeit behandelt werden und den Compilern spezielle Anweisungen
zu geben. Es gibt also zwei grundlegende Varianten. Einer will, der
andere ist Prüfsumme. Wenn wir want verwenden, haben
wir die Möglichkeit,
entweder disabled oder restore anzugeben, gefolgt von einer Liste von Warnungen auf die reagiert werden muss oder
nichts davon ausgeht,
dass jede Art von Wunsch die
Prüfsumme angeboren, es generiert eine Prüfsumme
der Quelldatei, die das Debugging haben
wird. Wenn wir zum Beispiel
das folgende Pragma
definiert haben das folgende Pragma und es ausführen, werden
Sie feststellen, dass keine
Probleme gefunden wurden. Im Grunde war das
alles, was ich
Ihnen über
Präprozessor-Direktiven zeigen wollte . Wir sehen uns im nächsten.
16. C# Erweiterte Overload: Willkommen. In diesem Video
werden wir über
Überlast-Indexer in C-Sharp sprechen . In C-Sharp stehen uns also viele verschiedene
Datenstrukturen zur Verfügung. Und diese ermöglichen es uns, bestimmte Daten zu unserem
Zeitpunkt der Notwendigkeit zu speichern und abzurufen. In diesem Video erfahren
wir mehr über
Indexer und
insbesondere darüber , wie Sie sie auf die richtige Weise
überladen können . Wenn wir davon sprechen, dass der Indexer die Idee
dahinter
überlastet, zwingt
die Klasse, sich wie
eine Datenstruktur zu verhalten und ihre Instanzen im Auge zu
behalten , die es uns ermöglichen,
diese Instanzen abzurufen würde mit einem Array, einem
Array von Listen zu tun haben. Zuerst löschen wir das Thema in
den Indexern und wenden uns dann an,
um eine Überlastung hinzuzufügen. Erstellen wir also ein neues
Projekt in der Ladung. Das ist also eine allgemeine, im Grunde genommen
Template-Syntax dafür. Und wir werden
uns das an
einem praktischen Beispiel ansehen. Nehmen wir zum Beispiel an,
wir haben eine Klasse Schüler. Und hier haben wir ein
privates String-Array. Und wir werden diese Indexer nennen, was eine neue Zeichenfolge
mit Dan-Werten ist. Und wir haben einen öffentlichen String. Und es zeigt auf den Index. Und was wir
gerne tun würden, ist das Folgende. Wir werden das Gatt haben, das den
Indexer-Index zurückgibt, und
die Menge, die den
Index auf einen bestimmten Wert setzt. Hier im Wesentlichen möchten
wir
eine neue Instanz der Schüler erstellen , und nennen wir diese
Grundschule. Und hier hätten wir gerne das
erste Element der Grundschule mit meinem Namen und das zweite Element der
Grundschule mit dem Namen meines Bruders. Und das
zweite Element der Grundschule erhält den Namen
meiner Schwester. Und was wir
gerne tun würden, ist eine
for-Schleife zu nehmen und von
0 auf I weniger
als zu iterieren 0 auf I weniger
als zu und die rechte Zeile der
Konsole auszugeben. Und die Grundschule. Ich bin das Element. Verwenden Sie dann die
Lesetaste der Konsole, um die Aufforderung beizubehalten. Wie Sie
auf der Konsole sehen können, haben
wir jetzt die drei Namen. Und natürlich
blinkt hier weil der Rest
der Liste leer ist. Also, was passiert hier? Wir haben einen Kurs, Schüler wie ein
seltsames Array verhalten und es ermöglichen bis zu zehn Schülernamen in einer Domäne
zu speichern. Die Klasse wird instanziiert und drei Schüler werden eingefügt. Und wenn wir die folgenden Elemente festlegen würden , also Grundschule, TAM, eine Mutter, dann sollten wir eine Ausnahme
bekommen. Weil es
kein zehntes Element gibt. Die Größe erlaubt
uns einfach nicht , dass das hier wichtige
Punkte sind. Es gibt also zwei grundlegende
Arten von Indizes. Ein- und zweidimensional. Indexsuche kann überlastet werden
und entspricht nicht den
Eigenschaften. Sie ermöglicht die Indizierung eines Objekts und das Festlegen eines Accessor. Wir werden zuweisen. Dennoch werden wir einen Wert abrufen. Der Wert wird verwendet, wenn
Sie den Wert festlegen. Und Indexer werden als
intelligente Arrays oder
parametrisierte Eigenschaften bezeichnet , was ein
bisschen irreführend sein kann. Und Indexer können keine
statischen Member sein ,
wie sie Mitglieder der Klasse sind. Wie überlasten wir also
die Indexer? Erstellen wir eine neue Klasse. Nennen wir diese Guides. Und wir haben einen privaten String-, Array- und Guide-Namen, was eine neue Zeichenfolge ist. Dan-Werte. Wir werden die öffentliche Zeichenfolge haben, dieser int-Index
wird den Indexwert des
Leitnamens zurückgeben. Und das Set wird den Indexwert der Leitnamen auf den angegebenen Wert
setzen. Und wir könnten
währenddessen die Öffentlichkeit
mit dem Float-Index haben. Und wir sollten dieselben
Get- und Set-Funktionen haben. Und wir werden die öffentliche
Zeichenfolge haben, diese doppelte ID. Ändern
wir diese. Und wir hätten es auf eins eingestellt. Und hier hätten wir keine
festgelegte Definition. Beide geben etwas zurück,
das heißt, das ist schreibgeschützt. Und jetzt, in unserer Hauptsache, wenn wir das auskommentieren, können
wir die Guides instanziieren. Und wir werden einen doppelten Wert haben, das k, und es ist **** 0. Und hier würde das erste
Element des Guides geschrieben werden. Und das
indexbasierte Element der Guides Float würde sich auf Hilfslinien befinden. Und was wir tun können, ist die rechte Linie der Konsole zu
benutzen. Und wir möchten das Guides k-Element
ausdrucken. Und wir möchten das erste Element
ausdrucken. Und wir möchten das erste
plus das float-basierte
erste Element
ausdrucken . In Ordnung? Was wir
hier sehen können, ist, dass wir grundsätzlich
verschiedene Versionen
davon
zugegriffen haben, basierend auf dem Typ des
Indexers, den wir verwendet haben. Und hier haben wir einen Index
, der eine Ganzzahl ist. Und hier haben wir einen
, der ein Float-Wert ist. Und wir können auf diese verweisen und basierend
auf diesem Rückgabewert manipulieren. Und wir haben ein letztes Beispiel , das wir uns ansehen
möchten, und es würde als
mehrdimensionaler Tee bezeichnet werden , den ich jetzt erwähnt habe. Und hier haben wir
den privaten String. Und wir haben dieses Komma. Und wir haben die Leitnamen, die zehnmal
einer neuen Zeichenfolge entsprechen. Dann hätten wir
die öffentliche Zeichenkette, diese int x und int y. Und wir hätten das get, das die
Leitnamen x und y zurückgibt. Und wir werden
die Menge haben die die führe die Namen x
und y auf den Wert. Und wenn wir weitermachen
und es instanziieren, benutze sie alle. Die Diamanten sind jetzt gleichwertig
mit neuen multidimensionalen. Und dann benutze zuerst das a. Es wird den Danio geben und einen für einen anderen. Dann können wir verschachtelte
Schleifen verwenden, um über
j gleich 0 zu iterieren , j kleiner
als Term j plus plus. Und benutze die rechte Linie der Konsole. Und wir würden gerne a und y oder j
verwenden. Und wir würden
gerne den Scheck hinzufügen. Also, wenn ein x und y
gleich null sind, dann verwenden wir die ganze
helle Linie des Telefons mit der F-Saite. X und y sind leer. Also machen wir dieses x und machen wir dieses y. Und ansonsten, tut mir leid, ich und j. Und j. Andernfalls würden wir diesen Ausdruck
gerne verwenden. In Ordnung. Nun zur Ausgabe können wir
das sehen. Warum genau das so ist. So können Sie
die Indexer in C-Sharp überlasten. Wir sehen uns im nächsten.
17. C# Erweiterte Common vordefinierte Attribute: Hallo zusammen und willkommen zurück. In diesem Video werfen
wir einen Blick auf den Zweck gängiger vordefinierter
Attribute in C-Sharp. Attribute ermöglichen es
Entwicklern also,
Metadaten oder deklarative
Informationen
in ihrem Projekt und ihrem Code zuzuordnen Metadaten oder deklarative
Informationen . Eine der Möglichkeiten, die ich
bevorzuge, ist, dass Klassen oder
Funktionen
von morgen veraltet sind während die App-Entwicklung
fortgesetzt wird? Und zuerst schauen wir uns an, was Attribute sind und sehen uns einige
Beispiele dafür an. Attribute sind also Stellen in Ihrem Code, an denen wir sie definieren
können. Und sie sind wie Assemblys, Methoden, Typen, und
die Liste geht weiter. Sobald Sie
das Attribut mit unserem
ausgewählten Teil des Codes verknüpft haben , haben
wir die
Möglichkeit, es mit
einer Technik namens Reflection abzufragen . Im .net-Framework haben alle
Typen und Komponenten wie Assemblys und Klassen standardmäßig
ihre eigenen Metadaten
definiert, die durch
benutzerdefinierte
Metadateninformationen erweitert werden können , wie
wir aufs Tor. Und wenn wir
Metadateninformationen anwenden, haben
wir die Möglichkeit
, den Umfang zu wählen. Wir können es auf
ganze Assemblys
oder nur auf bestimmte
Teile unseres Codes anwenden . Attribute haben die besondere
Fähigkeit,
weiter, mit Parametern weiter konfiguriert zu werden. Und schließlich ist das
Besondere an
Metadaten, dass unsere
Anwendung
ihre eigenen Metadaten und auch andere
Fortschrittsmetadaten
überprüfen kann ihre eigenen Metadaten und . Auf diese Weise können wir die Kompatibilitätsprüfung
und andere nette Funktionen einbauen. Es gibt also diesen
Skeleton-Code, den wir verwenden können. Und das
wird uns sagen, dass dies
ein Positionsparameter ist, er einen Wert hat und so weiter. Nehmen wir an, wir haben den
folgenden Code, der die Pullover-Maschine
darstellt
und zwei Funktionen hat. Eine ist das Starten
der Maschine und die andere installiert Updates. Wir haben also den Server der
öffentlichen Klasse und er hat den
privaten String-Namen. Und es hat den öffentlichen
String-Namen, den Eigenschaftsnamen. Und setze Name gleich Wert. Entschuldigung, unterstrich den Namen. Und wir haben den öffentlichen
String-Namen, den Konstruktornamen. Es geht darum, einen Namen zu spezifizieren. Und wir haben den öffentlichen
Void-Update-Server
, der
direkt zur Konsole durchläuft. Dieser Aktualisierungsserver. Und wir haben den Anfang. Und es wird heißen, dass
wir den Dienst neu starten. Großartig. Was wir jetzt tun
möchten, ist unseren Unterricht zu
beenden. Ja. Und während sich das
Projekt weiterentwickelt, möchten
wir die
nächste Funktion hinzufügen, die Update-Server veraltet und sowohl das Update als auch die Installation
und den Rest
der Startaufgabe
mit einem zusätzlichen Schritt
erledigt . Wie lassen wir die Entwickler wissen, dass die neue Funktion eingeführt
wird, die diese abdeckt. Alles was es ist. Was wir tun können, ist
die neue Zeilen- oder besser
Funktionsdefinition hinzuzufügen . Und dann sag dem
Update-Server, dass dies veraltet ist. Und wir
möchten der
Düne sagen, dass sie diese Methode verwenden soll, stattdessen den Start
verwenden. Und wir können auch
diese falschen Fälle hier haben. Jetzt haben wir das hier, auf diese Weise. In Ordnung? Der entscheidende
Punkt hier ist also diese Zeile, und sie muss
mit den Funktionsnamen korrekt sein. Andernfalls gibt der Compiler einen Fehler aus
, der besagt, dass die Methode, auf die wir uns
beziehen, nicht gefunden werden kann. Was wir also gerne
tun würden, ist dieses zu kopieren und sicher, dass das auch richtig ist. Und es muss
für die Funktionsnamen korrekt sein. Andernfalls wirft der Compiler eine Anzeige oder gibt an
, dass die Methode, auf die wir uns
beziehen, nicht gefunden werden kann. Das zweite Argument ist
entweder wahr oder falsch. Wenn wir es auf false setzen, der Compiler eine
Warnung aus, aber die Kompilierung werden
wir durchlaufen. Wenn sie auf „true“ gesetzt ist, wird
eine Exception ausgelöst und
die Kompilierung wird beendet. Und das ist auch ein Konzept, das als
Attribut-Targeting bezeichnet wird. Und es zeigt auf die Entität , auf die das Attribut ausgerichtet
ist. In diesem Fall ist die
a-Funktion das Ziel. Jetzt können wir über
vordefinierte Attribute sprechen. Diese Attribute
bezogen sich auf eine Reihe von Attributen, die von Microsoft in die
Dokumentbibliothek
integriert wurden. Und wir müssen uns
bewusst sein, dass dies eine Basisklasse für Attribute ist, die als system
that attribute bezeichnet wird. Und jedes vom Kunden
vordefinierte Attribut erbt von dieser Basisklasse. Die gebräuchlichsten vordefinierten
Attribute sind
Serialisierung, Serialisierung, veraltet, DLL,
important und wet method. Was wir tun können, ist
unsere Kundenattribute zu definieren. Jeder,
der das.net-Framework verwendet und seine absoluten
Kosten definiert, kann
es für den privaten
oder privaten Gebrauch sein, in eine öffentliche
Bibliothek oder Anwendung gepackt. Was wir gerne tun würden ,
ist
die folgende Demonstration zu erstellen. Also müssen wir das System
dieser Reflexion
importieren. Und was wir tun wollen,
ist eine Klasse zu definieren. Und die Attributverwendung
dieser Klasse ist das
Attribut, das auf diese Klasse abzielt. Und die Klasse wird Firmenattribut
genannt,
das von
der Attribut-Basisklasse erbt. Und wir werden
den privaten String-Namen haben ,
private String-Position. Und der öffentliche
String-Name mit der Lücke. Das gibt den Namen zurück. Und das Set,
das
den Namen gleich value setzen wird . Und wir werden den
öffentlichen String-Standort haben. Und wir hätten einen Konstruktor. Also das öffentliche Unternehmensattribut und die Zeichenfolgenfirma und
die String-Position. Und wir
möchten, dass der Name
dem Unternehmen und der
Standort dem Standort entspricht. In Ordnung? Jetzt,
wo wir
das aus dem Weg geräumt haben, können
wir eine neue
Attribut-Basisklasse haben können
wir eine neue
Attribut-Basisklasse haben, in der das Unternehmen imaginär sein
wird. Und es wird etwas
in Atlanta geben. Das, das wird Klassenserver genannt. Und es wird einen
privaten String-Namen haben. Und die private Zeichenfolge. Dieser öffentliche String-Name. Mit der GET. Komm schon. Das gibt den Namen und die Menge zurück, die
Name gleich Wert zurückgibt. In Ordnung, wir haben
diese öffentliche Klasse. Nennen wir diesen
Firmenserver, tut uns leid. Und wir werden diese
Funktionen wiederverwenden lassen. Wir haben also diese veraltete
Funktion und wir müssen den Rest starten und ihn
in Dressurfunktionen hinzufügen. Und hier im Wesentlichen können
wir einen Server a
aus dem neuen
Unternehmensserver-Domänencontroller erstellen . Und warum weint es? Es hat
natürlich keinen Konstruktor, da er definiert werden muss. Also public, Unternehmensserver, Zeichenfolge, Name und der Name
sind gleich dem Namen. Okay, jetzt haben wir
den Konstruktor und wir werden
die Mitgliederinformationen haben. Info entspricht dem Typ oder
einem Nuss-Typ von Ruhm, sondern eher dem Unternehmensserver. Und das Objekt-Array
mit dem Attribut wird die Info sein, benutzerdefinierte Attribute
abrufen. Sterben sowohl Firmenattribut als auch falsch. In Ordnung? Danach können wir
die foreach-Schleife verwenden, um über
jedes Objektattribut
in Attributen zu iterieren . Dann verwenden Sie einfach
das Unternehmensattribut C ist gleich
Unternehmensattribut, Attribut. Du. Und Kegel in der richtigen Linie. Dollarzeichen, Zitat, a, Name und Ort oder nicht. B. C, diese Orte, tut mir leid. Und wir können die auf den drei Tasten verwenden , um
die Eingabeaufforderung
beizubehalten. Okay, jetzt wie Sie sehen können, konnten
wir
das Attribut von einer
bestimmten Instanz abrufen . Und so können Sie
häufig vordefinierte
Attribute in C-Sharp verwenden . Wir sehen uns beim nächsten Mal.
18. C# Advanced Nur Autoproperties lesen: Willkommen. In diesem Video werden wir
über drei,
die einzigen automatischen
Eigenschaften in C-Sharp sprechen . Lesen Sie also nur automatische
Eigenschaften. Was sind sie? Wir gehen auseinander und sechs haben
C-Sharp 2015 veröffentlicht. So wie sieben Jahre
vergingen nicht neben dem Visum
Studio Ultimate. Das war eine sehr einzigartige
Funktion, die implementiert wurde. Dies wird als schreibgeschützte
automatische Eigenschaft bezeichnet und manchmal als
Nur-Getter-Auto-Eigenschaft bezeichnet. In diesem Video
werden wir das Konzept von
Feldern und Eigenschaften betrachten und sehen, das Konzept von
Feldern und Eigenschaften betrachten und wie beide schreibgeschützt sein
können
und wie sie
implementiert werden , indem wir uns auf
den Aspekt der automatischen Eigenschaft konzentrieren. Also Ängste versus Eigenschaften. Diese beiden Konzepte
drehen sich um die Idee der Abstraktion.
Mit der Klasse. Sie können Felder
und Eigenschaften haben. Felder sind normale
Variablenmitglieder oder einer Klasse. Warum habe ich Auto geschrieben? Eine Autoklasse? Und Eigenschaften sind eine
Abstraktion, mit der
Sie ihre Werte abrufen oder sogar
festlegen können . Also könnten wir zum Beispiel
die Klasse public field erstellen die Klasse public field und es
tut uns leid, Klasse, okay. Private String-Name und private String-Funktion. Und was wir tun können, ist
diese sogenannten Felder in einem
Konstruktor zu definieren . Damit der öffentliche Server geheilt ist, hätten
wir den
String-Namen, die String-Funktion. Hier. Wir würden
gerne sagen, dass dieser Name gleichbedeutend mit dem Namen ist. Und diese Funktion ist
gleichbedeutend mit Funktion. Wenn wir Felder definieren, sollten
wir sicherstellen, dass
wir sie als privat definieren. Dadurch wird sichergestellt, dass wir nicht gegen das Konzept
der Kapselung verstoßen. Kurz gesagt bedeutet Verkapselung dass wir die Felder
erstellen, aber wir bündeln die
Felder oder Daten mit Methoden und Funktionen,
die sie manipulieren können. Und wir legen diese
Daten nicht zur direkten Manipulation offen. Und dieser aktuelle Code reicht nicht wirklich aus
, da wir diese
nicht abrufen können. Was wir also tun müssen
, ist
den folgenden öffentlichen
String-Namen zu definieren , name. Und wir würden verwenden, um den Namen und die Menge,
die Menge, den Namen auf den Wert
zurückzugeben . Wir hätten die
öffentliche String-Funktion, und wir würden
die Funktion abrufen und die Funktion auf value
setzen. Und jetzt haben
wir die Möglichkeit, die Eigenschaften zu lesen
und zu ändern. Also lass uns unsere Erkältung sehen. Serverfeld a entspricht also einem
neuen Sandwichfeld. Und der Name ist DC. Die Funktion am
Silberfaden ist eher eine. Und die Funktion ist
Domänencontroller. In Ordnung? Was wir jetzt tun können, ist die rechte Zeile der Konsole,
den Ausdruck, einen Namen
und eine Funktion zu
verwenden . Und vergiss die
Konsole nicht mit diesen drei Tasten. Wenn wir dieses Beispiel ausführen, ist
dies die Ausgabe. Wir haben diese also erfolgreich
gesetzt und darauf zugegriffen, und wir haben unsere Klasse
mit einem Konstruktor
initialisiert .
Später wurden die Felder mit Hilfe
von Eigenschaftszugriffen
geändert. Und wir haben auch das
Verkapselungsprinzip befolgt. Nachdem wir das Konzept geklärt haben, können
wir es mit
dem schreibgeschützten Aspekt würzen. Wenn wir
ein schreibgeschütztes Feld erstellen möchten, müssen
wir nur
das Schlüsselwort Read Only verwenden. Wenn wir
dies also so ändern, dass es
schreibgeschützt ist, können wir sehen, dass der Unterstrich des Namens rot sein
wird. Und in diesem Fall
einer Angstzahl bedeutet
dies, dass wir nur eine
Chance haben, das Feld mit einem Wert zu initialisieren. Es passiert, wenn wir
den Konstruktorkonstruktor aufrufen und darauf hinweisen, dass wir eine
Anzeige oder einen solchen Versuch erhalten. Das kann also sicher entfernt werden. Wenn wir das noch einmal ausführen
würden, können
Sie sehen, dass
es gut funktioniert. Aber wenn ich versuche zu sagen, dass
der Name gleich new name
ist, sollte
ich sehen, dass dies
eine schreibgeschützte Eigenschaft ist und nicht geändert werden kann. In Ordnung? Also im Falle einer
Feldnummer, okay? Und wir haben die Ausgabe gesehen. Auf diese Weise können Sie
schreibgeschützte
Alto-Eigenschaften in C-Sharp verwenden . Wir sehen uns in.
19. C# Erweiterte Syntax für Literale: Willkommen. In diesem Video werden
wir darüber sprechen, wie Sie die
Syntax für Alphabetisierung erkennen können, einschließlich
Unicode-Deck-Skip-Sequenzen und
Unterstrichen in C-Sharp. Also lasst uns gleich loslegen. Später wir in C-Sharp und nichts
weiter als feste Werte. Diese Werte werden von
Variablen oder Konstanten verwendet. Es gibt viele Arten von
Literalen, wie Ganzzahl, Fließkomma, Zeichen,
Zeichenfolge, Boolescher Wert. Und wenn wir uns Integer-Literale
ansehen, wäre
dies ein Beispiel. Und es ist eine Art von Literatur
, die ganze Zahlen betrifft. Und es gibt grundsätzlich
drei Subtypen,
Dezimal, Oktal und Hexadezimal. Das ist die Dezimalzahl. Was wir tun könnten, ist
das Okto zu erschaffen, das ist das, oh, komm schon. Und acht. Und jetzt 028. Und wir können den Hexadezimalwert haben
, der 0 x eins ist, zum Beispiel C. Und im Grunde könnten wir weitermachen und die
Kegel oder die Linie von links nach rechts verwenden. Und sagen Sie, dass der Variablenname von a einen Wert hat. Und tu das für
alle drei. Also das ist für das O und das H. Und vergiss den
Doppelpunkt nicht, also lies die Taste. Wenn wir es also ausführen, haben wir
das auf dem Bildschirm. Beachten Sie also, dass der Name von es uns ermöglicht, in unserer
String-Interpolation auf den Namen
einer Variablen zu
verweisen . Die andere Sache, die wir
möglicherweise nicht bemerken, ist, wie die Werte bei
Hexa- und Oktalzahl zeigen. Und sie mögen grundsätzlich
die Vorwort-Präfixe. Wir sehen weder das
Hex-Präfix noch das Präfix. Was wir tun können, ist Gleitkommaliterale zu erstellen
. Erstellen wir also den
Float f k gleich 283848. Und wir könnten den schwebenden,
schwebenden Okto F B haben , der
28 oder 27 minus fünf wäre. Und wir könnten The, sorry, d und Roman. Ja, jetzt scheint es besser zu sein. Wir könnten also das 28. F. haben. Und jetzt können wir die Werte ausdrucken. Also das a, das B und das C.
Und wenn wir es ausführen,
beachten Sie, dass dies auch
die unterschiedliche Notation hat , wenn es auf dem Bildschirm ausgedruckt wird. Dies ist die wissenschaftliche
Notation für die Floats. Und wir können auch
Zeichenliterale haben. Also ist car c gleich a, oder wir können die
Unicode-Version definieren. Du schuldest also drei O, sechs. Und drucken wir das aus. Ca, ca. Siehst du das. Wir sehen uns. Da haben wir's. Das ist also zum Beispiel das Unicode-Zeichen für das
Fragezeichen. Und wir können auch
String-Literale haben. Und wir können auch
die booleschen Literale haben. Drucken wir sie aus. Das ist also das S. Und das wird die Biene sein. Ich werde die Biene sein. Da haben wir's. Und was wir haben können, sind auch
Unicode-Escape-Sequenzen. sind zum Beispiel Das
sind zum Beispiel die Escape-Sequenzen
, die wir verwenden können. Der Unicode hat
sie in umgekehrte Schrägstriche gesetzt. So können wir den
Bogencharakter, die Rücktaste, den
Formularvorschub, den Wagenrücklauf, neue Zeile, das horizontale,
vertikale Tippen, einfache Anführungszeichen, das doppelte Anführungszeichen und den umgekehrten Schrägstrich haben. Und wir müssen auch über Unterstriche
sprechen. Meiner Erfahrung ist
dieses Thema eines der am stärksten
umstrittenen unter Entwicklern. Ein Grund dafür
ist, dass es
Menschen gibt, die C-Sharp
als Muttersprache lernen und
versuchen, den Best Practices
und Codierungsstilanleitungen zu folgen . Und es gibt auch solche , die
unterschiedliche Hintergründe haben, wie C, C plus Python
oder was auch immer. Und sie tendieren dazu,
Variablen unterschiedlich zu benennen. Und so kann natürlich jedes
Unternehmen seine eigene
Codierungs
- oder Stilrichtlinie haben . Und was Sie tun können, ist den Style-Cop zu
überprüfen. Und auch das britische Herz. Mit diesen Tools können Sie eine auf Stil oder
verifizierte Styleguide basierende
Version Ihrer Anwendung erstellen eine auf Stil oder . Das war also alles, was ich dir in diesem Video zeigen wollte
. Wir sehen uns im nächsten.
20. C# Advanced Zurückführen von read aus Funktionen: Willkommen. In diesem Video werden
wir über drei schreibgeschützte
Referenzen von Funktionen sprechen . In diesem Thema dreht
sich alles um den Typ und den
speichersicheren Code. Wir gehen also auseinander und einer der von C-Sharp veröffentlichten
Entwickler könnte Argumente als Referenz an
Methoden
übergeben. Als die Zeit verging und sich die
Programmierung änderte, tauchten neue Herausforderungen auf, die das Hinzufügen der neuen Funktionen
zu C-Sharp
zwangen. Mit der Version
sieben von C-Sharp wurden
zwei sehr wichtige
Funktionen hinzugefügt. Eine war die Möglichkeit
, Verweise auf
lokale Variablen zu deklarieren , und
die andere bestand darin, als Referenz
von Methoden
zurückzugeben. Wir werden die Grundlage schaffen, um die beiden
Arten von Argumenten zu verstehen. Vorbeigehen. Was ist also der Unterschied
zwischen Wert und Finanzierung? Dies sind zwei
Haupttypen in C-Sharp, und wir haben auch die Möglichkeit, benutzerdefinierte Typen
zu definieren, aber das gehört nicht zum
Umfang dieses Videos. Via-Referenztypen zeigen also unterschiedliche
Leistungsmerkmale, wenn wir unter die Haube schauen, weil die Natur
dieser Implementierung, in der Sie Registerkarten haben,
keine Overhead-Erinnerung haben. die Daten, die Sie in
einem bestimmten Typ wie
Integer-String-Double speichern können einem bestimmten Typ wie
Integer-String-Double ,
einen
bestimmten Typ , eine bestimmte Größe haben
und Referenztypen zusätzliche Felder hinzufügen
müssen. Einer ist der Objekt-Header und der andere ist
die Methodentabelle. Objekt-Header wird von
der Common Language
Runtime zum Speichern
zusätzlicher Informationen verwendet der Common Language
Runtime zum Speichern und
ist im Grunde eine große Maske. Schauen wir uns also struct an. Also öffentliche
Nur-Lese-Struktur, eine Dynamik. Und diese Struktur
hätte die öffentliche Zeichenfolge, Bob Lake-Zeichenfolge mit
Namen, mit dem GET. Und öffentliches Doppel. Eigentlich, Verhältnis mit der GET
und der Öffentlichkeit int, Anfangsfälle und öffentliche doppelte Sterblichkeitsrate. Jetzt können wir eine Instanz oder einen Konstruktor
für die Pandemie haben. Und es hätte
den String-Namen, doppelte Verhältnis und die int-
und die doppelte Rate. Und jetzt hier in der Pandemie hätten
wir den
Virusnamen gleich dem Namen, das Verhältnis
entspricht tatsächlich dem Verhältnis. Und der Fall ist, tut mir leid. Tatsächlich sollte das Verhältnis gleich dem Verhältnis
sein. Und im Anfangsfall sollte
dies
gleich k ist, ist, und die Sterblichkeitsrate
sollte gleich der Rate sein. Und wir können sehen, dass die
Accessors gelesen
werden, nur mit get definiert sind
und das Set fehlt. Und wir lesen nicht
nur ein Schlüsselwort , das der CRL mitteilt, dass unsere Struktur unveränderlich sein wird
. Das bedeutet, dass die
Felder im Laufe der Zeit nicht geändert werden können. Jetzt möchten wir diesen Mann
kombinieren,
Der oben erwähnte Aspekt, der Struktur und
das
Übergeben von Werten als Referenz ist um eine Demonstration
für dieses Thema zu erstellen. Was wir also gerne tun würden ist dies zu schaffen. In Ordnung, die
Ausrichtung ist also gut. Öffentliche Klasse, einfach,
ref, schreibgeschützt. Und wir werden das statische int-Array
mit dem neuen int three haben. Und es wird 123 sein. Und der statische int
get index, int index. Und wir geben der RAF einen Index zurück. Und wir hätten die
öffentliche statische Leere für unser was. Dies sollte geschlossen sein. Und hier
möchten wir die Kegel
all diese helle
Linie verwenden , um den Index zu erhalten. Halte durch. Hier sollten
wir es hinstellen. Holen Sie sich zuerst den Index und verwenden Sie
die Kegel- oder Leset Und wir können den
Wert sehen, der eins ist. In diesem Code
sehen wir also ein statisches Array von ganzen Zahlen mit
einer Größe von drei. Und unsere Methode GET
index nimmt einen Index als
Argument und gibt
ein int in einem Jar aus unserem
Array zurück , das Radon ist. Wenn wir den Index übergeben
, der größer als
die Länge des Arrays
oder kleiner als 0 ist , dann erhalten wir eine Ausnahme
der Index-Ausnahme außerhalb des
Bereichs. Wenn wir also
ein komplexeres Beispiel erstellen möchten, können
wir es auf
folgende Weise tun. Nehmen wir an, wir haben eine Struktur, die
Klassenzimmer darstellt. Das hat also den Konstruktor
, der einen
Namen und die Größe annimmt. Und es hat auch ein privates Array mit aktueller
Nutzung. Und es hat einen Namen und die
Größeneigenschaften und so weiter. Was wir jetzt tun können, ist das Folgende zu erstellen. Wir haben also eine Bar
, die Räume genannt wird, und es ist ein neues Klassenzimmer. Und hier hätten wir gerne
die neuen Klassenzimmer. Mathe mit zehn Leuten. Und neue Klassenzimmer führen mit 20
zu reicheren. Und
vergessen wir nicht, es zu schließen. Wir können die Var-Schule haben
und sie hat neue Klassenzimmer. Und die Schule. Dieser Lagerraum
wird die Räume einnehmen
, die initialisiert werden. Und dann können wir die
Telefone in der richtigen Zeile verwenden, um die Schule zu drucken, die
genutzt wird. 10. Wenn Sie es ausführen, können Sie die unterschiedliche Auslastung des
Klassenzimmers
sehen. Und auf diese
Weise können Sie im Grunde Ihre eigenen
schreibgeschützten Referenzen
erstellen , die von
Funktionen in C Sharp zurückgegeben werden. Und eigentlich war das
alles, was ich dir zeigen wollte. Wir sehen uns im nächsten.
21. C# Advanced Methode ohne einen Namen: Willkommen. In diesem Video
werden wir
über Methoden ohne Namen sprechen . Dies ist also eine Reihe von Funktionen in C-Sharp, die sehr
wichtig zu verstehen sind. Diese Funktion
dreht sich um Lambda, Lambda-Ausdrücke, Delegaten
und anonyme Methoden. Wir werden sehen,
wie Sie sie nutzen können. Zunächst werden wir über Delegierte
sprechen. Also funktioniert normalerweise oder pausiert einen oder mehrere Parameter
oder gar nichts. Normalerweise geben sie
etwas zurück oder führen eine bestimmte Operation mit
Daten oder den Texten aus, die sie haben. Wir sprechen von Delegierten
, wenn wir die Funktion selbst
als Parameter
übergeben möchten . Mal sehen, was
C-Sharp zu bieten hat. Zunächst möchten
wir einen Delegierten erstellen. So hätten wir zum Beispiel den öffentlichen statischen
String-Linux-Server, String-Namen, den String-Status, hat. Wir würden prüfen, ob der Staat gleich
up ist, dann kehren wir zurück. Der Server ist. Was wir sonst gerne machen
würden. Wenn der Staat ausgefallen ist. Dann können wir zurückgeben,
dass der Server ausgefallen ist. Und schließlich, gib unbekannten Zustand
zurück. In Ordnung. Also funktioniert es Problem mit sollte es
in doppelten Anführungszeichen stehen. Großartig. Fein. Jetzt
müssen wir
eine Delegate-String-State-Reaktion
mit dem String-Server
und dem String-Status erstellen eine Delegate-String-State-Reaktion
mit dem String-Server . Und wir müssen
die
öffentliche statische Zeichenfolge
Windows Server mit dem
String-Namen und dem String-Status definieren die öffentliche statische Zeichenfolge . Und was wir tun möchten, um den Server
zurückzugeben, ist im Zustand. Staat mit dem
Dollarzeichen natürlich. Und wir sollten
es hier innerhalb des Programms verschieben . Und hier möchten
wir eine staatliche Reaktion auslösen. Linux entspricht einer Reaktion auf einen neuen Staat. Und wir würden
den Linux-Server benutzen. Und die staatliche Reaktion Windows, neue Zustandsreaktion
Windows Server. Und wir würden gerne
die folgende Konsole machen, rechte Zeile,
Linux, Bind und Up. Und wir hätten
ein anderes Linux, das LDAP
ist, und das Folgende haben. Jetzt möchten wir
diese staatliche Reaktion haben oder sie einfach in Live-Action
sehen. Also was ist das Problem? Wie Sie sehen können, kein Problem. Der Server ist aktiv, also
funktioniert er im Grunde wie beabsichtigt. Und ja, wir könnten die
Funktionalität dieses Materials
durch die Remote-Prüfung oder das Öffnen von
Tickets weiter erweitern , wenn Sie sich
in einer großen
Unternehmensinfrastruktur befinden , aber lassen Sie es uns technisch gesehen tun. Jetzt werden wir
über anonyme Methoden sprechen. Daher wurde im vorherigen Abschnitt erörtert
, wie Delegate
Referenztypen sind und verwendet werden, um
auf jede Methode zu verweisen, die dieselbe Signatur
hat. Im Gegensatz zu ihnen sich bei
den anonymen Funktionen alles um das Parsen Codeblock oder Code
als Delegatparameter. Erstellen wir das
folgende Beispiel. Öffentlicher Delegierter. Ungültiger Zustand, der String-Zustand. Und in der statischen Leere möchten
wir den äußeren
Bereich
erstellen, der 99 ist. Und der Staat S
wird Delegierter sein. Und es wird ein
String-State-Delegierter sein. Und im Grunde
würden wir
gerne eine rechte Linie der Konsole verwenden. Und der Staat wurde betreten. Machen wir daraus eine F-Zeichenfolge
und schließen die Konsole. Richtige Linie. Dollar-Zeichen. Der Wert aus dem äußeren Bereich liegt außerhalb des Gültigkeitsbereichs. Und wir
schicken D her. Und wenn wir es ausführen, sollten
wir auch
dieses schließen. Wir sollten das Folgende sehen. Der Zustand aufwärts und drittens, und der Wert aus dem
äußeren Bereich ist 99. So können Sie also anonyme Methoden
definieren. Der letzte sollte Lambda-Parameter
sein denen wir überprüfen, welche
Lambda-Ausdrücke. Es ist eine anonyme
Funktion, die Ausdrücke
und Anweisungen
enthalten kann . Also lasst uns das Folgende erstellen. Wir werden die
Funktion string string haben. Und es wird ein willkommener Name
sein. Und wir definieren den
Rückkehr-Willkommensnamen. Gewicht natürlich,
das Dollarzeichen. Und vergiss nicht, es zu schließen. Jetzt können wir die rechte Zeile der
Konsole verwenden, um den Vermögensdaumen
auszudrucken. Danielle. Wenn wir es ausführen, können
Sie sehen, dass wir den Lambda-Ausdruck
verwenden. Wir könnten ein anderes Beispiel erstellen. Also int, int n 34 ist gleich x und gibt das x mal drei zurück. Und dann können wir den Eintrag 0.5
ausdrucken. Es sollten 15 sein. Das war alles, was ich
Ihnen in diesem Video über
Lambda-Ausdrücke,
Delegierte und
anonyme Methoden zeigen wollte Ihnen in diesem Video über
Lambda-Ausdrücke, . Wir sehen uns im nächsten.
22. C# Advanced LINQ: Willkommen. In diesem Video werfen
wir einen
Blick auf die sprachintegrierte
Abfragesyntax, die die lange
Version von Linked Cue ist. Und es wurde 2007 in
einem anderen Dotnet-Framework mit
der Version 3.5 eingeführt einem anderen Dotnet-Framework mit . Das Kernkonzept
bestand darin, das Framework und damit
die C-Sharp-Sprache mit Funktionen für
Abfrageausdrücke zu erweitern. Wenn wir
beispielsweise ein Beispiel erstellen, können
wir eine ArrayList-Zeichenfolge erstellen. Und dass es
Serverliste mit der
neuen Listenzeichenfolge enthält . Und wir hätten gerne den Bottle Bell
Loom-Domänencontroller. Und prothetisch,
das ist das DNS. Und zum Schlüssel, der das
ist, die ACP. Und im Grunde ist das
die Struktur , die man
in der Hauptfunktion definieren könnte. So könnten wir es
demonstrieren. Also ist d c gleich Liste,
Serverliste, wobei S,
S den Domänencontroller enthält. Und lassen Sie es uns
hier in die Hauptleitung verschieben. Jetzt können wir die rechte Zeile der
Konsole verwenden, den Ausdruck, die DCs. Und wie Sie sehen können, ist
dies die Liste der EECS. Und es hat im Grunde
eine verzögerte Ausführung. Um also tiefer in die verknüpfte Warteschlange
einzudringen und welche anderen Vorteile es zu essen
gibt, müssen
wir verstehen, was
verzögerte Ausführung ist. In den meisten Fällen
werden
die Linkausdrücke
während der Kompilierung für
einen bestimmten Datensatz ausgewertet und die Variablen
mit den gefilterten Werten initialisiert. Durch die Implementierung einer
verzögerten Ausführung können
wir wertvolle CPU
- und RAM-Ressourcen sparen. Weil das Konzept
es uns ermöglicht, einen bestimmten
Ausdruck nicht zu bewerten oder
die Auswertung zu verzögern , bis der realisierte Wert
tatsächlich benötigt wird. Es gibt zwei Fälle
, in denen es sehr nützlich ist. Die erste ist, wenn Ihre
Anwendung an
mehreren Gigabyte an Daten
oder sogar Terabyte an Daten arbeitet . Und die zweite ist, wenn Sie
mehrere Abfragen miteinander
verkettet haben mehrere Abfragen miteinander
verkettet , die zu unterschiedlichen
Manipulationen der Datensätze führen. Wir haben also ein Keyword, über das
wir sprechen müssen. Und das ist Ertrag. Um
unser Verständnis
der verschiedenen Ausführungen zu vertiefen , müssen
wir ein
Schlüsselwort namens yield einführen. Und das wurde mit
der Version 2 von C-Sharp eingeführt. Es ist mit der Vita für faule Auswertung und Verbesserung der Leistung von LINQ-Abfragen. Und das Schlüsselwort yield
ist der Kontext, den Sie sind, was bedeutet, dass
es
problemlos
als Variablenname verwendet werden kann . Erstellen wir also eine
kleine Anwendung. Hier. Wir hätten gerne
einen Server der öffentlichen Klasse. Und es hat einen String-Namen
und eine String-Funktion. Und wir haben den öffentlichen
String-Namen mit dem Get. Das soll den Namen
zurückgeben. Und die Menge, die den Namen
setzen soll,
ist gleich Wert. Und wir haben das gleiche
für die Funktion bisher, düstere String-Funktion. Und wir benutzen die Funktion,
vergiss die Antwort. In Ordnung. Wir werden auch einen
Konstruktor haben, also einen öffentlichen Server. Und dieser Konstruktor
wird den Namen und
die Funktion annehmen . Und set-Funktion
ist gleich Funktion. Name ist gleich Name. In Ordnung? Und im Grunde
das mit der Serverklasse. Und wir werden
eine weitere öffentliche Klasse haben, nämlich das Zwischenprogramm. Und hier möchten wir
unzählige öffentliche statische I für den
Server
erstellen , die Server-DB. Und hier müssen wir Folgendes
definieren. Wir werden ein
Serverarray mit den Servern haben. Das ist nur eine neue
Instanz des Servers. Und diese Instanz
wird vom
neuen Server oder Bad Loan
und Domänencontroller bevölkert . Und wir werden was auch immer
haben und wo auch immer. Und eine davon werden HCP und DNS sein. In Ordnung. Dies ist jetzt geschlossen. Und was wir
gerne tun würden, ist,
das für jeden Server S in
Servern zu haben das für jeden Server S in und die Rendite
S zurückzugeben . Jetzt haben wir die
Unterstriche weg. Und was wir
in der Domäne tun können, ist
die Verwendung von forEach in der Server-DB. Verwenden Sie einfach die rechte Zeile der
Konsole, Dollarzeichen, und verwenden Sie den S-Punktnamen und
die S-Punkt-Funktion. Nun, wenn wir es ausführen, können
Sie sehen, dass wir
die verzögerte Ausführung
demonstriert haben die verzögerte Ausführung
demonstriert und wir in der Lage sind,
über die INR I unzählig zu iterieren. Und der Schlüssel hier ist die Rendite. Also hier das Rückgabe-S, das es uns ermöglicht, über
jedes Element unserer Serverliste zu iterieren . Und es wird nicht
die gesamte Liste auf
einmal zurückgegeben , um bekannte MOD zu speichern
und die Leistung zu verbessern. Dies ist auch ein Beispiel
für verzögerte Ausführung. Da die für jede Schleife die
Begriffe nacheinander
herauszog . Und wir sollten den
Unterschied zwischen Lizzie
und eifriger Hinrichtung in Betracht ziehen . Also oder Bewertung entweder. Die Verwendung von Lazy Evaluation bedeutet, dass
während des Aufrufs
des Iterators nur ein
einzelnes Element der Quellsammlung verarbeitet wird . Also so etwas. Und ein Iterator
kann
je nach Kontext eine gewohnte Klasse oder eine foreach- oder abide-Schleife sein. Und das war alles, was ich Ihnen in diesem Beispiel
zeigen wollte .
Wir sehen uns in der nächsten.
23. C# Advanced String Interpolation: Willkommen. In diesem Video werden wir über die
String-Interpolation sprechen. String-Interpolation
hat etwas mit dem Drucken
auf der Konsole zu tun. Und es ist im Grunde
eine übliche Aufgabe. Wir können eine einfache
Statusmeldung drucken, die das Ergebnis einer
bestimmten Aktion darstellt. Es ist nicht wirklich wichtig. Entscheidend ist, wie flexibel
unsere Druckauszüge sind. Und es ist auch wichtig, wie es in den Programmablauf
passt. Wir sollten zum Beispiel Folgendes
in Betracht ziehen. String-Interpolation kann also drei Arten von Variablen
verwenden:
Substitution, Array-Zugriff, Ausdrücke und Methodenaufrufe. Der wichtigste Aspekt der String-Interpolation ist
das Dollarzeichen. Also zum Beispiel string wo, wo sollte es
score haben und string was? Tomate. Und Sie könnten die
Punktschreibzeile der Konsole zum Ausdrucken verwenden. Ich habe die Konsole gekauft und benutzt die Punktschreibzeile der Konsole, nicht die rechte Zeile, die Konsole, lese T. Und wenn wir es ausführen, können
Sie sehen, dass diese Variablenwerte gut interpolatorisch
waren. Und im Grunde können
wir auch
Arrays interpellieren. Erstellen wir also ein
Integer-Array, das die geraden Zahlen 2468
enthält. Und jetzt können wir die Konsole
Dot Write-Zeile dieser Politik verwenden . Die erste, zweite,
dritte, vierte
sind also dritte, vierte gerade Zahlen. Und los geht's. Dies
sollte die erste sein, und das sollten gerade Zahlen sein. In Ordnung, jetzt
scheint die Ausgabe in Ordnung zu sein. Was wir tun können, ist
auch
Ausdrücke interpellieren oder
mit Ausdrücken interkalieren. Wir haben also zwei Werte, x, x ist gleich acht und y ist gleich zehn. Wir könnten
Folgendes verwenden, um eine schön formatierte Ausgabe
auszudrucken . Also X plus Y gleich X plus Y. Und wir könnten mal teilen und vielleicht das Minus. Und wenn es in diesem Beispiel akut ist, sollten
wir in der Ausgabe
Folgendes sehen. Sie haben also die
Möglichkeit,
Ausdrücke bei der Interpolation auszuwerten. Sie könnten auch eine
Funktion erstellen, die die statische int int vierte Potenz int x hat. Und sie sollte x
mal x mal x x zurückgeben. Und hier auf der Konsole. Und wir könnten x in die
vierte ist vierte Potenz x schreiben . Auf
diese Weise interpolieren wir
den Funktionsaufruf selbst, und wir können auch
mit Alignments interpellieren. Lassen Sie uns also eine
worker-Variable erstellen, die ein neues Wörterbuch
aus String und String ist. Hier könnten wir jedoch sagen, dass wir
den John haben , der DevOps
entspricht. John ist jedoch gleichbedeutend
mit Levelaufstieg, um hinzuzufügen. Hier können wir die rechte Zeile der Konsole
verwenden. Der Ausdruck, den wir haben. Dies sollte das Minus 15 sein. Und wir sollten
der Position mit den 20 helfen . Und benutze die for each Schleife. Bei Arbeitern. Drucken Sie hier den Titelschlüssel aus. Und der Titelwert
sollte ein großes K sein, K. Und wenn wir das ausführen, können
Sie sehen, dass wir hier das Tempo
haben. In diesem. Halte durch. Es sollte so sein. Sieht besser aus. Das war also alles, was ich Ihnen
über String-Interpolation zeigen wollte. Wir sehen uns im nächsten.
24. C# Erweiterte Wert- und Referenztyp Zuweisung: Willkommen. In diesem Video werden
wir über
ein interessantes Thema in C-Sharp sprechen , und es heißt Wert und
Referenztypzuweisung, also gut und graph. Also lass uns das Projekt erstellen. Basierend auf dem Typsystem
einer Programmiersprache
gibt es also zwei Hauptkategorien. Es gibt stark und schwach typisierte
Programmiersprachen. Und diese Kategorien definierten,
wie Tippregeln
während der Kompilierung und
Laufzeit des Quellcodes angewendet wurden. 1974 definierten Barbara
Liskov und Stefan Zeros eine stark typisierte
Programmiersprache wie folgt. Immer wenn
das Objekt von
der aufrufenden Funktion
an die Aufruffunktion übergeben der aufrufenden Funktion
an die Aufruffunktion wird, muss sein Typ mit dem in der Codefunktion
deklarierten Typ
kompatibel sein . Wir werden also einen Kontext
geben und uns ansehen wie und was der
Unterschied zwischen ihnen ist. Im
Dotnet-Framework und beim Berühren der
Programmiersprache c-Sharp gibt es zwei Haupttypen. Einer heißt Wert und der
andere ist ein Referenztyp. Das ist ein anderer Begriff, der Kontexte
genannt wird Und in C-Sharp gibt es zwei
Zusammenhänge. Einer wird als sicher und der
andere als unsicher bezeichnet. Wir werden das später erklären, aber es sollte erwähnt werden,
dass
wir in unsicheren Kontexten einen dritten Typ haben, der als Zeiger
bezeichnet wird. Moment reicht es aus, dass
wir den Kontext sicher kennen,
wenn der Kontext sicher ist, wenn der Code unter
der Aufsicht der CLR ausgeführt wird . Es gibt vier Typen, die
unter die Kategorie der
Referenztypen fallen . Strings, Arrays,
Klassen und Delegaten. Und der Rest der Typen für fällt unter die Typenkategorie. Also bool mit dem Auto, Dezimal und so weiter. Werfen wir einen Blick auf den Wertetyp. Nehmen wir an, wir haben eine Funktion, public static, void quadriert. Und es erhält ein
Doppel als Argument. Und was wir tun werden
, ist die rechte Zeile
der Konsole zu verwenden und im Grunde x mal x. Jetzt können wir eine Variable a deklarieren, die Stan ist, und die Konsole
benutzen. Oder nennen Sie
das Doppelquadrat einfach ein und geben wir ihm eine Punktlesetaste für die
Konsole. Wenn wir es jetzt ausführen, sollten
wir die Ausgabe als 100 sehen. Was passiert also
hinter den Kulissen? Der Wert dieses Inhalts wird auf dem Stapel
zugewiesen und ein einzelner Speicherplatz im Speicher, der
auf dem Typ basiert , ist
im Brustbereich reserviert Diese Variable
enthält den Wert direkt. Wenn wir also diesen Wert in
eine andere Variable und Zuweisung
kopieren würden , wird
der Wert kopiert. Sie haben also den Wert
dieser Ergebnisse zweimal, zweimal auf dem Stapel
für jede Variable. Jeder vordefinierte Datentyp
in Waffen und sogar Strukturen. Oder auf diese Weise. Die Wertetypen werden zur Kompilierzeit
erstellt. Aus diesem Grund sind sie vor dem
Garbage-Collector
geschützt. Sie kann nicht auf sie zugreifen. Schauen wir uns nun den Referenztyp
an. Nehmen wir an, wir haben einen Server der
öffentlichen Klasse. Und dieser Server wird
einen String-Namen haben, public und CPU und
public im RAM, oder einfach verdoppeln. Was wir jetzt tun könnten, ist die public zu erstellen
und void zu initialisieren. Und wir werden
eine Kategorie und den
Server S als Argumente haben . Falls die
Kategorie also klein ist, möchten wir den Typ small erstellen oder eher zuweisen. Und was wir gerne hätten, tut mir leid. Öffentlicher String-Typ. Da der Typ klein sein sollte, da die CPU eins und S sein sollte, sollte
der RAM zwei sein. Als ob die Kategorie mittel wäre. Dann werden wir
etwas mehr
Ressourcen zuweisen und es als Medium bezeichnen. Sehen wir uns zwei Kerne an, vier Gigs RAM. Wenn die Kategorie groß ist, möchten wir
die vier großen CPUs und
acht Gigs RAM zuweisen . Andernfalls würden wir
gerne eine neue Ausnahme werfen. Neues System, diese
Argumentausnahme und Kategorie müssen
klein, mittel oder groß sein. In Ordnung? Was wir jetzt
tun können, ist einen Server zu erstellen. Server wird ein neuer Server
sein. Wir können die Initialisierung aufrufen. Halte durch. Es sollte
so sein . Quadrieren Sie es. Warum funktioniert es nicht? Wir haben das. Wir haben
den initialisierten Server. Und es sollte in der Nähe sein. Initialisieren Sie also Server und ein
Logo und es ist bereits definiert. Also lass es uns
sein und quadrieren a. Es gibt
also kein Argument
für den ursprünglichen Server. Also lass es uns klein machen. Und Lee. Wir haben also den String
und den Server S. Warum ist es kein öffentlicher Klassenreferenztyp. Und wir haben den Server hier und den String - und Programmserver. Wir haben also das kleine
Medium und wir haben den Server S,
public static void. Großartig. Was wir jetzt tun sollten, ist
die rechte Zeile der
Kegelkonsole mit
dem Dollarzeichen zu verwenden rechte Zeile der
Kegelkonsole mit und nur die Attribute
anzuzeigen. Also sei CPU, Typ
und B dieser Graham. Und teilen wir sie auf. In Ordnung? Also im Grunde ist es das. Wir haben eine Klasse, die vom Referenztyp ist
. Und das ist wichtig zu beachten, da die
Funktion initialize server, die initialisiert wird, zwei Argumente
benötigt. Der erste ist
ein Wertetyp und der zweite ist
ein Referenztyp. Der Typ, bei
dem die Klasse vorbei ist, die Funktion ändert die öffentlichen Eigenschaften
der Klasse als Referenz basierend auf der
Kategorie. Wir bestehen. Wenn wir eine Kategorie bestehen
, die nicht
umgesetzt wird , als eine
neue Anzeige oder sein Thron. Das war alles, was ich dir
in diesem Video über
Wert und Typ zeigen
wollte . Wir sehen uns im nächsten.
25. C# Advanced Null propagation: Hallo zusammen und willkommen zurück. In diesem Video werden
wir über
den
Ausbreitungsoperator in C-Sharp sprechen . Im Jahr 2016 sind also viele
Dinge passiert. Am 12. November gab es eine Veranstaltung
namens Visual Studio connect head von Microsoft
auf dem Zylinder veröffentlicht Vorschau-Version von Visual Studio 2015 und
die C sharp Version sechs. Diese neue Version enthält
viele Änderungen, die Entwickler und die Technologie
dieser Zeit benötigten. Um nur einige
dieser Funktionen zu nennen, war
die schreibgeschützte
automatische Eigenschaft der
Auto-Eigenschaftsinitialisierer-Ausdruck , ABER IT-Funktionsmitglieder, die
statische und die neueren
bedingten Operatoren verwenden . In diesem Handbuch werden
wir uns also die
bedingten Operatoren ansehen, oder sie werden häufiger als Ausbreitungsoperator bezeichnet
. Es gibt auch Leute da
draußen, die
diese Funktion als sicheren
Navigationsoperator bezeichnen . Um das zu verstehen, müssen
wir
zwei neue Operatoren einführen. Das Hauptziel
dieser Operatoren besteht darin, die Codeausführung
flüssiger zu gestalten und die
Nullreferenzausnahme
durch sinnvolles Hinzufügen oder Behandeln zu ersetzen . Sehen wir uns also ein Beispiel für
den Operator für den Mitgliederzugriff an. Vor dem Cis. C-Sharp, der folgende Code
hätte zu keiner Referenzausnahme geführt . Also haben wir diesen Praktikanten oder krass. Wir haben die statische Leere. Also im Grunde ist das der Code. Und ja, wir haben einen
Server und das war's. Was wir jetzt tun möchten
, ist
dieses Problem zu lösen , und wir können
es auf folgende Weise tun. Wir werden also einen Server der
öffentlichen Klasse mit
dem öffentlichen String-Namen haben , der einen Getter und einen Setter hat. Jetzt möchten
wir es initialisieren. Und wir werden ein Server-Array haben, das Server genannt
wird. Und wir werden ein
Serverarray mit fünf Servern haben. Nun, was wir gerne
tun würden, ist einen Server zu haben, S1 wird der neue Server. Und der S1, dieser Name. Das wird der Erste sein. Wir werden einen Server
haben, S2. Und S2, der Name
wird an zweiter Stelle stehen. Was wir nun tun
möchten, ist die Zuordnung zu den Servern und Servern. Zweiter. Und dann mach weiter. Für jeden Server S, N Server. Und benutze einfach die Konsole
dot write line S, diesen Namen. In Ordnung. Was ist der eigentliche Schlüssel hier ist
, dass wir jetzt, wenn wir ihn ausführen, die
folgende Ausgabe sehen sollten. Im Grunde brauchen wir also ein Array von fünf oder in diesem
Fall zwei Elementen. Und die Umfrage wird mit Servern
gefüllt sein, deren Namenseigenschaft
ebenfalls initialisiert
wird. Dann iterieren wir über den
Server und überprüfen beim Mitgliedszugriffsoperator, ob der Dienstname oder initialisiert ist. Okay, jetzt
fragst du dich vielleicht, wo die Demonstration von Element
x ist, dieser Operator. Und wir können
die Schleife einfach wie folgt konvertieren. Wenn wir das also kommentieren, könnten
wir die rechte
Zeile der Konsole verwenden und einfach sagen, dass Server Fragen stellen oder wir es einfach nicht
so machen. Aber durchweg. Auf diese Weise. Für int ist ich gleich 0, ich weniger als zwei I plus plus. Und hier möchten wir das Fragezeichen,
das Fragezeichen,
den Namen, das
doppelte Fragezeichen des Servers haben und sagen, dass kein
Name angegeben wurde. Lassen wir es jetzt fünf laufen. Oh, was ist der Fehler? Oh, ich muss es schließen. In Ordnung. Das ist also nicht auf ein Objekt festgelegt. In Ordnung, konvertieren wir es. Das ist also im Grunde
die Demonstration für den Operator der neuronalen
Ausbreitung. Das ist die Syntax dafür, und so können Sie sie verwenden. Und das war alles, was ich dir in diesem Video zeigen wollte
. Wir sehen uns im nächsten.
26. C# Advanced Clojures und Lambda-Ausdrücke: Hallo zusammen und willkommen zurück. In diesem Video
werden wir
über Schließungen mit
Lambda-Ausdrücken sprechen . C-Sharp, die Fähigkeit,
die es einer Methode oder
Funktion ermöglicht , auf
die nicht-lokale Variable zu verweisen, welche Werte als Closure bezeichnet werden. Diese Funktion wird
häufig
in Verbindung mit der
Lambda-Funktion verwendet , die nichts anderes als
anonyme Funktionen sind , die Entwickler über Hauptfunktionen
verwenden , um eine Möglichkeit zu bieten Flexibilität. Lassen Sie uns zunächst über nicht-lokale
Variablen sprechen. In C-Sharp ist also der
Zugriff auf eine Variable außerhalb des
Funktionsumfangs möglich. Und betrachte normale Variablen x, da auf diese Weise
nicht-lokale Variablen genannt werden. Wenn Sie, können Sie auch
Entwickler hören , die sich auf
diese Art von Fourier beziehen, aber als sehr fähig erfasst werden. Und im Grunde könnten wir
hier Folgendes demonstrieren. Wir haben eine statische Zeichenkette, best, eine quasi lineare, und wir
haben eine statische Leere. Foo ist der Beste. Und wir könnten sagen , dass wir wollen, dass die Konsole diese
richtige Zeile ausdruckt. Das Beste ist das Beste. In Ordnung? Und wir sollten
dieses Loch hierher verschieben. Was wir tun könnten, ist die
Punktlesetaste der Konsole zu
verwenden und die Funktion „
Wer ist die beste“ aufzurufen. So sehen
erfasste Variablen im Grunde aus. Und was sind die
Lambda-Funktionen. Wir hatten bereits ein
Video über Lambdas, aber versuchen wir es noch einmal zu wiederholen. Es gibt also viele
Artikel über Lambda und sie sind Schließungen. Und manche Menschen stimmen dem
irgendwie zu, aber sie sind nur
ein Teil der Wahrheit. Und ich glaube, Indien, wie die Oppositionspartei, Lambda-Funktionen können als Schließungen
implementiert werden, aber sie sind selbst keine
Schließungen. Das
hängt wirklich vom Kontext ab
, in dem Sie Ihre Anwendung
oder die Umgebung verwenden. Wenn Sie
eine Lambda-Funktion erstellen , die keine lokalen Variablen
verwendet, muss
sie
als Closure implementiert werden. Lambda-Ausdrücke können
also zwei grundlegende Formen annehmen, Ausdrücke Lambda und
Anweisungen Lambda. Für einen
Ausnahmeausdruck Lambda könnten
wir dieses Beispiel geben. Es nimmt also zwei boolesche Werte und prüft, ob
sie gleich sind. Und wir können auch
Statement-Lambdas haben. Und sie sehen
ungefähr so aus. Jetzt haben wir also eine Zeichenfolge und dann
würde es diese
Zeichenfolge mit der Nachricht begrüßen. Wir sollten also beachten, dass das Schließen der geschweiften Klammer auch in einem Semikolon
endet. Wenn wir mit
Statement-Lambdas arbeiten, erstellen
wir normalerweise
mehrere Ausdrücke kapseln sie
in unserer Funktion ein. Wir würden
gerne
eine steile Kurve nehmen und
Lambdas und Schließungen kombinieren. Wir haben also eine öffentliche statische partielle
Klassenschließung, Demo. Hier. Was wir
gerne tun würden, ist
die öffentliche statische Leere zu schaffen . Draußen. Das wird
unsere Funktion sein. Und innerhalb der Funktion haben
wir eine
lokale Nordvariable. Und es heißt, dass
Schließung Lambda basiert. Jetzt haben wir den
Funk und reihen sie alle auf. Und wir würden es gerne als Lambda
verwenden. Und wir werden
die Zeichenfolge local haben. Das ist Lambda und die
Rückkehr lokal Plus. In Ordnung. haben
wir eine
String-Nachricht, die eine Demo ist. Und wir würden gerne die rechte Zeile
der Konsole verwenden , um die Nachricht zu drucken. Und was
wir in der Domäne tun könnten
, ist die
Abschlussdemo draußen zu verwenden. Und das war's. Also lass es uns ausführen. Und hier können wir sehen, wie
das demonstriert wurde. In
diesem Beispiel sehen wir also , dass sich nicht-lokale
Variablen nicht geändert haben. Die Situation ist jedoch
möglicherweise nicht immer richtig. Wenn sich die Variable ändert, die referenzierende Funktion
betroffen. Manchmal ist das genau
der Fall, den wir erreichen wollen. Zum Beispiel könnten wir
eine Funktion haben, die
Terminaländerungen in
einem Funktionsstatus
mit einer Lambda-Funktion protokolliert Terminaländerungen in
einem Funktionsstatus
mit einer . Auf diese Weise würde jede Änderung
des Staates zu
einem anderen Logo führen. Jetzt können wir
es mit Schließungen demonstrieren, und so würden wir es machen. Wir werden also eine
foo-Variable haben, die stem ist, und die Funktion,
die bar genannt wird. Und es kehrt einfach für die rechte Zeile der Konsole zurück. Und wir würden die volle Bar nutzen. Und wir können den
Wert von foo auf 20 ändern. Und danach werden wir einen Kämpfer
haben, der Bar
entspricht. Und wir könnten die rechte Zeile der
Konsole benutzen, um den Kämpfer mit dem Kämpfer
auszudrucken . Und so könnten wir Schließungen
umsetzen. Und technisch gesehen war das alles,
was ich dir
in diesem Video zeigen wollte. So können Sie Closures
mit Lambda-Ausdrücken verwenden. Wir sehen uns im nächsten.
27. C# Advanced Foreach und Enumeratoren: Hallo zusammen und willkommen. In diesem Video werden
wir über das
Verständnis von Generatoren
und Enumeratoren sprechen . Und ich zähle in C-Sharp auf. Eines der Konzepte
heißt Generatoren, das andere sind Iteratoren. Wir werden untersuchen, wie diese Ideen in C-Sharp
einfließen und prüfen, wie Sie sie zu
unserem eigenen Vorteil nutzen
können . Ein Generator ist normalerweise eine
Funktion oder eine spezielle Routine die in der
Sprache
implementiert das Verhalten einer Schleife
steuert. Der Generator hat
eine unheimliche Ähnlichkeit. Zwei Funktionen, die ein Array
zurückgeben. Sie haben Parameter und können
aufgerufen werden , um eine
Folge von Phi-Zeiten zu erzeugen. Nehmen wir an, wir haben ohne Generatoren eine
Funktion, die eine Liste von ganzen Zahlen von
etwa 1 Million gleichzeitig zurückgibt. Das bedeutet, dass
die Bedürfnisse, die Liste im Speicher
aufgebaut werden müssen, Speicherplatz für
alle Werte
zuweisen
und diese Werte dann übergeben müssen, wann immer sie benötigt werden. Wenn wir die
Ressourcen haben, ist das in Ordnung. Aber die Menschen
sind immer bestrebt,
etwas für
solche Probleme herauszufinden . Und Generatoren wurden geboren. Und die Iteratoren sind wie das Gegenstück zu
den Generatoren. Und das Konzept
geht auf das Jahr 1974 zurück. Zur C-Programmiersprache. Ein
Iterator sollte es
dem Programmierer standardmäßig ermöglichen ,
bestimmte Container zu durchqueren, und er wird am häufigsten für Listen
verwendet. Sehen wir uns also ein Beispiel
in der Implementierung an, wir haben eine Liste von
Strings, die iteriert werden sollen, was eine neue Listenzeichenfolge ist. Und iteriert zu werden
hat eine Add-Funktion. Und wir können sagen , dass Programmieren Spaß macht. Jetzt können wir diese Liste
sehr einfach in einen Generator umwandeln. Wir könnten einfach
sagen, dass es sich um eine I- und numerische Zeichenfolge handelt. Und im Grunde müssen wir es auch auf diese Weise
ändern. Also zähle ich Bogen, Saite und Halt auf. Wir haben diesen. Und
das sollte wiederholt werden. Und wir müssen auch
den anderen ändern. Also verneige ich mich, iterativ zu sein. Und was wir jetzt tun können, ist, die for-each-Schleife zu nehmen und
String-Element in I
unzählig zu sagen String-Element in I und das rechte
Konsolenelement zu verwenden. Und wenn wir weitermachen und den
Schlüssel lesen, um auf die Ausgabe zu warten, werden wir das sehen. Auf diese Weise haben wir
die Liste in einen Generator geändert, sodass sie einen geringeren
Speicherbedarf hat. Und hier gibt es im
Grunde keine break-Anweisung. Und doch wird es nicht unendlich, also weiß es, wie man aufhört, wenn wir
die Liste, die wir gerne iterieren
würden, ausschöpfen . Und wir können sehen, dass der Tee auch
ein praktisches oder
praktischeres Beispiel ist. Deshalb möchten wir eine
kleine App erstellen, die
die Zahlen verarbeiten kann , wenn sie
ungerade oder sogar unterschiedlich sind. Der Augenzähler bietet
uns eine elegante Lösung, die
zwei statische Methoden beinhaltet. Die erste statische
Methode wäre also diese. Und wir müssen das System-Threading
verwenden. Und was wir
gerne tun würden , ist auch den
Auditprozess so zu haben. also sogar welchen Prozess. Also los geht's. Was passiert also hier? Wir nehmen einen
Augenzähler als Argument. Und wenn der Strom 0 ist, sagen
wir, dass die Liste beim Beenden
verarbeitet wurde , und
warten Sie fünf Sekunden. Wenn es Modulo zwei
ist, dann sagen wir, dass die Nummer sogar den Prozessor aufruft. Und los geht's. Das ist also für gerade
und ungerade Zahlen. Und jetzt können
wir in unserem Main eine Liste int
erstellen, die myList heißt. Und das ist eine neue
Liste von ganzen Zahlen mit Dan-Werten für I
geht von 0 bis I, weniger als zehn I plus. Und wir möchten
das my list dot add verwenden , um neue Elemente hinzuzufügen. Und danach
haben wir den Augenzähler. Und das wird
eine ganze Zahl benötigen. Meine Liste in m entspricht
mylist, nimm einen Zähler. Meine Liste in num, mach weiter. Verarbeite oder liste die
Nummer auf, und das war's. Also lass es uns ausprobieren. Und wie Sie sehen können, zeigt
die Ausgabe, dass die
Liste beim Beenden verarbeitet wurde. So können Sie also für jeden
Augenzähler in C-Sharp
verwenden. Wir sehen uns im nächsten.
28. C# Advanced Static vs instance: Willkommen. In diesem Video werden
wir
darüber sprechen, wie Sie statische
und Instanzmitglieder
unterscheiden können . Objektorientierte
Programmierung dreht sich also um zwei Hauptbegriffe in. Eine ist Objekt und die
andere sind Instanzen. Es gibt verschiedene
theoretische Ideen , die die spezifische
Programmiersprache umsetzt. In diesem Handbuch werfen
wir
einen Blick auf statische Elemente und Instanzmitglieder. Wir entscheiden über die Bedingungen
und worum es dabei geht, wie Sie sie
in sehr einfachen Regeln verwenden können. Wir unterscheiden also auch drei
Arten verschiedener Zahlen. Wir können statische
Felder oder Eigenschaften, statische Methoden und
statische Klassen haben. Fangen wir also mit dem Unterricht an. Was ist, was mit den
statischen und nicht statischen Klassen ist sind Klassen entweder
statisch oder nicht statisch. Und wir haben eine nicht statische Klasse. Sie kann Methoden,
Eigenschaften und sogar Ereignisse enthalten . Und du kannst das auch aufrufen ohne die Klasse zu instanziieren. Erstellen wir zum Beispiel ein Projekt dafür. Da ist diese nicht. Erstellen wir zum Beispiel
eine Klasse, die wir nicht statisch
nennen würden. Und hier haben wir eine öffentliche statische
Zeichenkette, keine Instanz. Und auf der Konsole dot
write line drucken wir. Ich muss es nicht wissen. Dan Shi wird gezeigt. Halte durch. Wir sollten zurückgebracht werden. In Ordnung. Und was wir auch tun können, ist
innerhalb unserer internen Klasse unsere öffentliche Zeichenfolge zu definieren. Eine weitere Instanz. Und hier geben wir hier
keine Instanz zurück. Entweder. Wenn Sie zur Hauptleitung gehen, nachdem Sie den richtigen Schlüssel haben. Was wir tun können, ist
die rechte Zeile der Konsole zu verwenden, den Ausdruck, das Ergebnis
der Funktion aus der nicht statischen
No-Instanzfunktion. Und auch die rechte Linie der Konsole. Und noch eine, die nicht so ist. Wenn wir also dieses Beispiel
ausführen, werden
Sie sehen, dass wir die Funktion
der Klasse ohne Instanziierung
aufrufen . Ohne den Modifikator
public zu verwenden, können
wir die wissenden
Sterne aus der
nicht-statischen, statischen Demo-Klasse aufrufen , und
davon erben wir in unserer Hauptklasse nichts. Und Sie sollten auch
das Schlüsselwort public kennen , wenn wir eine andere Instanz von
der Methode aus
unserer Hauptklasse
aufrufen der Methode aus
unserer Hauptklasse und Barrierefreiheitsebene diesmal korrekt
ist. Im Grunde. In einer anderen Formulierung, wenn wir über
die Instanzmitglieder sprechen, haben wir über die Mitglieder
der Klasse gesprochen, auf die nicht zugegriffen werden
kann, ohne die Klasse zu
instanziieren. Diejenigen, auf die zugegriffen werden kann,
werden Mitglieder genannt. Also, wenn ich zum Beispiel
diese nichtstatische öffentliche
String-Nummer gleich was auch immer gebe , dann können wir auf diese zugreifen. Was ist mit statischen Methoden? Wenn wir zum Beispiel dieses Beispiel
haben, wird
dies als
statische Member bezeichnet , eine statische Methode. Und wenn Sie
eine statische Methode definieren, erlauben
wir den Zugriff von dieser
Methode nur auf statische Mitglieder der Klasse und wir können nicht
auf Instanzmitglieder zugreifen. Und wenn ich über die statische Methode auf
diese
Membervariable zugreifen würde, würde
sie immer noch gut funktionieren. Jetzt müssen wir also über
statische Eigenschaften oder Felder sprechen. Wenn wir also ein statisches Feld haben, müssen
wir
bedenken, dass dieses Feld nur einen
Speicherort im Speicher
identifiziert. Und egal wie viele
Instanzen wir erstellen , das ist nur eine
Kopie eines statischen Feldes. In den
meisten Fällen werden
statische Eigenschaften aufgrund ihrer Natur zum Speichern von Daten
verwendet, die von
allen Instanzen der Klasse gemeinsam genutzt werden sollen. Und wenn Sie ein
Beispiel dafür wollen, können
wir eine Klasse
namens counter erstellen. Hier hätten wir das öffentliche statische int down Cs gleich 0
und public counter. Wir möchten die Instances plus
gleich eins verwenden,
um den Instanzzähler zu erhöhen
. Und wenn wir weitermachen und
eine neue Instanz vom Zähler aus erstellen , können
wir nur die rechte Zeile
der Konsole verwenden. Drucken Sie die Anzahl
der Instanzen aus. Hier
verwenden wir die Counter-Klassennummer
bzw. Instanzen, um die Anzahl der Instanzen
auszudrucken. Wenn wir diese
Lösung ausführen, werden wir derzeit eine sehen. Aber wenn Sie noch ein
paar Instanzen erstellen. Nehmen wir an, das ist Zählung 123. Und wenn wir die Anzahl
der neuen Instanzen ausdrucken wollen, werden
wir sehen, dass wir
insgesamt vier Instanzen haben. Und im Grunde ist es das. Das wollte
ich dir in diesem Video zeigen. Wir sehen uns im nächsten.
29. C# Erweiterte Type: Hallo zusammen und willkommen zurück. In diesem Video werden wir über das Tippen von
Finanzierung C-Sharp
sprechen. C-Sharp ist eine stark
typisierte Sprache. Ist es für eine Deklaration
heißt explizit. Und das bedeutet, dass wir
eine neue Variable angeben müssen. Andernfalls wirft der Compiler eine Anzeige oder mit der
dritten Version von C-Sharp wurde
ein neues Schlüsselwort eingeführt, das voir heißt. Auf diese Weise können
Entwickler
jede Art von Wert
implizit speichern ,
was bedeutet, dass der
Compiler während der Kompilierzeit
für uns entscheidet , wann wir die erste
Zuweisung ausgeführt haben. was als ein
Typ dieser Variablen werden soll. Und es kann einfach
in Link Q integriert werden
, der
sprachintegrierten Abfrage. Vor der Einführung
der Typinferenz
wurde explizit definiert, was vor der
zusammengesetzten Kompilierzeit eine Zeichenfolge oder
Ganzzahl oder was auch immer sein
wird . Also definieren wir eine Zeichenkette mit
dem Standardwert und so weiter. Und jetzt müssen wir über Link q
sprechen. Q steht
also für language
integrated query. Es handelt sich um eine Reihe von Technologien, die auf der Integration von
Abfragefunktionen direkt
in die Sprache C Sharp
basieren . Es ist sehr ähnlich wie bei Abfragen. Ziel war es, Daten anhand
bestimmter Kriterien
herauszufiltern und die
meisten Datentypen Slack,
Fortsetzung, Zemo usw. zu unterstützen die
meisten Datentypen Slack, . Und wir werden
ein Beispiel erstellen , das genau das demonstrieren
soll. Erstellen wir also einen Server
der öffentlichen Klasse. Innerhalb der öffentlichen Klasse werden
wir einen
öffentlichen String-Namen haben
, der einen Getter und einen Setter hat. Und wir werden ein öffentliches
String-Betriebssystem mit dem Getter und Setter haben. Und danach, was
wir
tun möchten, um eine neue Sonne zu schaffen. Und das ist im Grunde
nicht nur ein neuer Server, sondern die Liste der Server. Und wir möchten
dies als neue Serverliste haben. Hier. Was wir gerne
tun würden, ist das Folgende. Deshalb wollen wir
diese Server instanziieren. Komm schon. Und wir haben einen neuen Server, einen Namen haben wird,
was ist mit einem Webstuhl und
einem Betriebssystem, was wird wann sein? 2019. Und wir werden noch mehr tun. So ein großer Junge. Dies wird ein
CentOS-Acht- und Ricky-Modell sein, das werden neun sein. Und jetzt können wir eine
Serverabfrage erstellen, die vom Server in Servern kommen wird. Und wir möchten,
dass das Serverbetriebssystem auf IBM
Nine
gefiltert wird und dieses schließen. Wir haben also diese Liste und müssen
den ausgewählten neuen Server,
das Name-Server-Betriebssystem, hinzufügen den ausgewählten neuen Server, das Name-Server-Betriebssystem, und es einfach schließen. Und danach können wir
den foreach var Server, die
Serverabfrage und einfach
den rechten Konsolenserver verwenden . Und lassen Sie uns es geben,
die Kegel sind ungefähr drei Schlüssel und lassen Sie es laufen. Wie Sie sehen können, haben wir
hier das Filterergebnis. Und was sehen wir hier? Wir verwenden zwei
zusätzliche Namespaces. Eine wird als generisch und
die andere als verknüpfte Warteschlange bezeichnet. Und die erste bietet uns die Implementierung
der Listendatenstruktur, in der wir unsere Server speichern. Und die zweiten Anzeigen, die Link-Fähigkeiten zu
unserer Anwendung nach der Initialisierung der
Liste mit den Servern. Und hier passiert
die Magie. Also definieren wir zuerst unsere Variable, die
die Abfrage enthält, ist arts, und dann ist die Abfrage erledigt. Was nach Servern sucht,
die billiger sind oder nicht billiger sind, sondern
das Betriebssystem ist WAN 19. dem Schlüsselwort walk
können wir
während
der Laufzeit den Typ des Körpers festlegen . Und technisch gesehen war das alles was
ich
dir in diesem Video zeigen wollte. Wir sehen uns im nächsten.
30. C# Erweiterte lokale Funktionen: Hallo zusammen und willkommen zurück. In diesem Video
werden wir
über lokale Funktionen
in C-Sharp sprechen . Also die lokalen Funktionen, diese Funktion ist
mit der Version 7
Teil von C-Sharp geworden . Und die Idee hinter dieser Funktion ist die
Definition einer Funktion. Wir haben eine andere Funktion gemacht. Und es ist ähnlich wie
Python-Dekoratoren funktionieren. Wenn Sie mit
dem Konzept vertraut sind und es umformulieren
möchten, können
wir sagen, dass die
lokale Funktion
eine private Funktion einer
Funktion und ihres Gültigkeitsbereichs ist . Und sie ist auf die Funktion beschränkt ,
in der sie definiert wurde. Wir werden dieses Thema in diesem Video
weiter analysieren. Der Typ der Suchfunktion weist also Ähnlichkeit mit dem Typ
der Container-Funktion auf. Es gibt jedoch keine
strikte Regeldurchsetzung von Seiten des Compilers. Und wenn wir
eine lokale Funktion haben, können
wir auch asynchrone und
unsichere Modifikatoren verwenden. Unsicher bezieht sich also auf
C-Sharp-Zeiger bei async bezieht sich
auf asynchron. Und gemeinsame Orte, an denen
lokale Funktionen definiert werden. Unsere Methodenkonstruktoren, Eigenschaftszugriffsquellen,
Ereigniszugriffe, Lambda-Ausdrücke,
Phi-Analysatoren oder -destruktoren und lokale Funktionen. Und ein sehr nützliches Merkmal der lokalen Funktion
ist, dass
Ausnahmen sofort
auftauchen können Ausnahmen sofort
auftauchen ,
wenn wir Iteratoren verwenden Ausnahmen werden
beispielsweise nur
angezeigt, wenn wir sie aufzählen. Erstellen wir also eine
kleine Demonstration. Hier. Wir hätten gerne
eine leere Nachricht, sagen wir, eine Zeichenfolge. Und wir benutzen die Konsole. Richtig? Linie“. Sagt. Verwenden wir die Kegel oder die
Lesetaste, um Eingaben zu erhalten. Was wir nun tun möchten, ist die Botschaft
zu sagen: Willkommen. Und wenn wir es ausführen, sollten
wir die
folgende Ausgabe sehen. Das ist im Grunde genommen die einfachste Form
von lokalen Funktionen. In unserem Fall haben wir die
Funktion message, die eine Zeichenfolge
als Argument verwendet und die
Nachricht an die
Konsole ausgibt. Und lassen Sie uns
eine weitere Demonstration
mit variablen Bereichen erstellen . So
haben wir hier zum Beispiel int k gleich 11 und das doppelte j
gleich neunundneunzig Punkt neun. Und wir hätten
den nichtigen Bereich. Und wir verwenden die rechte
Zeile der Konsole, um den Namen auszudrucken. Der Wert von name of. Dies sollte eine f-Zeichenfolge sein. Und wir würden auch zwei
Argumente vorbringen. Also in X in Y ist X
und Y. Und wir würden gerne auch K und J verwenden
. Komm schon. K und J. J und K. Und diesen Namen brauchen wir nicht. Eigentlich brauchten wir das. Was wir jetzt tun
möchten, ist den Bereich zu verwenden. Machen wir das zu einer Zeichenfolge und nicht zu 1299 und führen es einfach aus. Wie Sie hier sehen können, die lokalen Variablen
k sind
die lokalen Variablen
k und j
für die Funktion zugänglich da sie innerhalb
der Containerfunktion definiert sind. Und was wir gerne
tun würden , ist eine
generische Funktion zu erstellen. Also void generische Funktion. Und wir werden den
Wert mit dem Wert X haben. Und gehen wir zu diesem. Und wir hätten die Kegel
auf der rechten Seite gleich diesem wie der vorherige. Und wir werden diese Funktion aufrufen. Neun, 11 dass, wenn Sie es ausführen, der Wert von x 11 ist. Generische Funktionen kombiniert
Typ, Sicherheit und Effizienz. Und sie werden oft mit Sammlungen
und Methoden
verwendet , die
auf ihnen basieren. Und wir können auch
den äußeren Parameter in
lokalen Funktionen referenzieren , die im gleichen Bereich
deklariert sind. So
könnten wir zum Beispiel die Leere
meiner Zeichenfolge x out string S erstellen . Und S ist gleich dem Dollarzeichen. Das ist der eine. Und jetzt hätten wir die
String-Nachricht gleich null. Und wir hätten die Nachricht My
out 12 und out, den Funktionsaufruf,
und verwenden einfach die Konsole diese Nachricht in der
rechten Zeile. Also führen wir es jetzt aus. Sie können sehen, dass der
Wert von x 12 ist. Die Atmosphäre ist variabel, fängt die Botschaft ein und
arbeitet zusammen mit der Zeichenkette als Argument
der Funktion. Und wir könnten
auch das Schlüsselwort params void,
meine Unterarme, Schusswaffen im Array verwenden auch das Schlüsselwort params void, . Und Zapfen. Hab die helle Linie. Und hier könnten wir sagen, dass die Nummer von der Rohrleitung stammt. Und wir hätten Element. Und für jedes Element im Array. Auf diese Weise sieht unsere
for-Schleife gut aus. Und wir hätten den Test
, der ein neues Integer-Array ist
, das 123456789 hat. Und jetzt können wir gestern die
Unterteile benutzen. Und los geht's. Im Grunde könnten Sie also auf diese
Weise lokale Funktionen in C-Sharp
verwenden. Wir sehen uns im nächsten.
31. C# Erweiterte Benutzerdefinierte event: Hallo zusammen und willkommen zurück. In diesem Video werden wir
uns ansehen, wie Sie benutzerdefinierte
Event-Accessors in C-Sharp schreiben
können. Um die
Kundenereignisachse zu verstehen, müssen wir
also
klären, warum sie
benötigt werden und welche Anwendungsfälle sie haben. Hier stellen wir das Konzept der Ereignisse vor
und werfen einen Blick auf die Ereignisse und die Accessors
, die für die
Interaktion zwischen Klassen verwendet werden können. Und was sind Ereignisse. Nehmen wir also ein anschauliches Beispiel. Wir haben eine grafische
Benutzeroberfläche , die aus Schaltflächen,
Text, Boxen, Beschriftungen usw. besteht . Jede Komponente
besteht aus einer eigenen Klasse. Jede Klasse bietet
Funktionen. Sie können beispielsweise in das Textfeld
eingeben, auf eine Schaltfläche
klicken usw. Und wir kategorisieren Klassen entweder nach Verlagen
oder Abonnenten. Der Publisher ist eine Klasse, die Ereignisse
sendet oder auslöst. Und der Abonnent ist
derjenige, der das empfangen hat, empfängt das Ereignis basierend
auf seinen spezifischen Aktionen. Es gibt also einige
Regeln für die Ereignisse. Der Herausgeber bestimmt,
wann ein Ereignis ausgelöst wird, der Abonnent bestimmt,
welche Aktion ausgeführt wird, wenn ein bestimmtes Ereignis ausgelöst
wird, das er abonniert hat. Veranstaltungen mit unseren Abonnenten
werden niemals ausgelöst. Und Ereignisse werden meistens
aufgrund von Benutzerinteraktionen
entweder in einer Webanwendung oder einer
grafischen Benutzeroberfläche ausgelöst . Standardmäßig hat and event mehrere Abonnenten und bewirkt,
dass es synchron
aufgerufene Handler behandelt,
sofern nicht asynchron
asynchron definiert . Die Ereignisse basieren
auf der Event-Handler-, Delegaten- und
Ereignisprotokoll-Basisklasse. Um eine Veranstaltung zu erstellen, müssen
wir einen
Delegierten erstellen, der die Details
der
Abonnenten einer Veranstaltung enthält ,
und eine öffentliche
Veranstaltung erstellen, die für eine Klasse extern
sichtbar ist und
zum Erstellen verwendet wird Abonnements. Dann erstellen wir die Methode in einer Klasse, die das
Ereignis selbst auslöst. Gehen wir zum Beispiel
wie folgt vor. Nennen wir diese öffentliche
Klasse eine Maschine. Und diese
Maschine der öffentlichen Klasse soll etwas haben, das
private int-Nutzung genannt wird, was 0 sein wird,
private int sichere Auslastung, was die
Auslastungsebene sein wird , unter der Die Maschine kann sicher
betrieben werden. Und wir werden einen
öffentlichen Delegierten haben. Void Stress Limit x
c hat Event-Handler, der die
Objektquelle und die Ereignisargumente E haben wird. Und wir werden einen öffentlichen
Ereignisspannungsgrenzwert überschritten haben. Wir werden eine Öffentlichkeit haben, die
wir auf Stress verzichten müssen. Stufe. C hat Ereignisargumente E. Und im Grunde möchten
wir, dass
die Stressgrenze das Fragezeichen
überschritten hat. Aufrufen. Dieses E. Bringen wir es hier runter,
damit es besser sichtbar ist. Und wir werden einen öffentlichen int haben, vier Monate, der den Getter haben
wird. Und es wird die Auslastung zurückgeben. Und wir werden
die statische Leere haben. Maschine Stress
begrenzt x c did object, source event args e. Und wir
hätten gerne die Maschine, die der
Maschinenquelle entspricht. Einsen. In Ordnung, Line. Warnung vor Stresslevel. Sie möchten,
dass der Mac monatelang schlecht ist und
die Person unterschreibt. Was wir jetzt tun können, ist
den öffentlichen
Void-Stresstest zu erstellen , int Ausnutzung. Und jetzt möchten wir, ich die alte Nutzung
gleich zur Unterstreichung der Auslastung habe. Und die
Unterstreichungsauslastung
sollte mit
der neuen Nutzung erhöht werden. Und wenn die alte Auslastung nicht gleich
ist, um die Nutzung
zu sparen und die Auslastung größer ist
als die sichere Nutzung. Dann können wir die auf
Stressstufe überschrittenen neuen Hunde nennen . Okay, im Grunde wird
das der Stresstest
für unsere Klasse
sein. Und in unserer Hauptfunktion. Was wir tun können, ist eine neue Maschine zu
schaffen. Und wir können Maschine einen
neuen
Stresslimit-Event-Handler hinzufügen. Belastungsgrenze. Komm schon. hat Z getan. Und wir möchten
die Gedichte in dieser rechten Zeile verwenden
, um zu sagen,
dass die Verwendung darin besteht, dies
eine F-String-Maschine sein wird , die Ionen
mit einem Prozentzeichen schlecht bildet. Und wir können die Maschine benutzen. Dieser Stresstest. Nehmen wir an,
es werden 60 sein. Wir werden
die Auslastung aufschreiben und dann einen weiteren
Stresstest für den fünften erstellen. Und lassen Sie uns die 75 machen und
die Foren nutzen oder vereinbaren,
auf die Aufforderung zu warten. Wenn wir dieses Beispiel nun ausführen, können
Sie sehen, dass
sich die Auslastung nicht ändern wird. Ich meine, es wird sich ändern, aber sobald wir
die Auslastung überschritten
haben, erhalten wir die Warnung,
sodass ein benutzerdefiniertes Ereignis ausgelöst wird. Das war also im Grunde ein Beispiel , das Ihnen zeigt,
wie Sie
Ihre benutzerdefinierten
Event-Accessors in C-Sharp schreiben können . Wir sehen uns im nächsten.
32. C# Erweiterte Benutzerdefinierte Konvertierungen: Hallo zusammen und willkommen zurück. In diesem Video werden wir darüber sprechen
, wie Sie benutzerdefinierte benutzerdefinierte
Konvertierungen in C-Sharp
schreiben können . Diese
Umbauten in C-Sharp
oder jeden Tag von
Fußgängern haben die meisten Entwickler verloren . Und wir verwenden es, um zu überprüfen, ob die
Eingaben solide
dem Arbeitsablauf unserer Anwendung trotzten . Es handelt sich um integrierte Konvertierungen, die in Konvertierungen integriert sind, und unterstützende Funktionen in C Sharp, mit denen
Sie standardmäßig
Flexibilität und
Konsistenz in
Ihrer gesamten Anwendung aufrechterhalten Flexibilität und
Konsistenz in
Ihrer gesamten standardmäßig
Flexibilität und
Konsistenz in
Ihrer gesamten Anwendung es gibt zwei
Hauptarten von Konvertierungen. Einer heißt x plus c, der andere ist implizit. C-Sharp bietet
Ihnen auch die Möglichkeit, Ihre eigenen Konvertierungen zu definieren. Werfen wir einen Blick auf
explizite Konvertierungen. So
haben wir zum Beispiel einen Float-Pi
, der drei für F ist. Und
wir haben einen doppelten B-Pi
, der von sein wird. Und wir können die rechte Zeile der
Konsole verwenden, den Ausdruck von d pi. Werfen wir einen Blick auf die Ausgabe. Wie Sie sehen können, im ersten Fall haben
wir
im ersten Fall die drei
Punkte 14 als Wert. Und der dritte. Der zweite Fall ist
etwas länger. Im Grunde sehen
wir also, wie Float in Double umgewandelt
wird. Das ist der Unterschied
zwischen der Präzision. Deshalb sehen wir
unterschiedliche Werte. Und was wir auch
tun können, ist im Grunde genommen
weiterzumachen und
das E-Pi, d Pi zu nennen. Und hier sagen wir einfach, dass wir einen doppelten Wert haben
wollen. Und das werden die drei
sein, die 14. Und wir würden gerne
eine Float-Version davon erstellen. Und F DEP. Wir würden
gerne
den Float für d, d, p, y verwenden . Und jetzt können wir diese Werte
ausschreiben. Führen wir unser Beispiel aus. Wie Sie sehen können, haben
wir jetzt die
explizite Konvertierung verwendet um die neuen Werte zu erstellen. Jetzt können wir uns ansehen, wie Sie Ihre eigenen
benutzerdefinierten Conversions definieren
können. So haben wir zum Beispiel die öffentliche Klasse Conversions
genannt. Und wir haben den benutzerdefinierten Typ der öffentlichen
Klasse. Und dieser wird
eine öffentliche int-Nummer mit
seinem Getter und Setter haben . Das öffentliche Bool, Magie,
Getter und Setter. Und wir werden einen
statischen int-Operator haben, benutzerdefinierten int-Wert. Innerhalb dieser Funktion möchten
wir
einen neuen benutzerdefinierten Typ mit
dem Wert Zahl gleich zurückgeben . Und die Magie war falsch. Und dieser eine öffentliche boolesche Operator, sorry, n. Danach können wir
unseren statischen öffentlichen
X-Aufzählungsoperator,
int, benutzerdefinierter Typ, magic definieren unseren statischen öffentlichen
X-Aufzählungsoperator,
int, . Und wir würden gerne
von der magischen Zahl zurückkehren. Okay, jetzt
haben wir unsere eigene Klasse und können eine Ganzzahl erstellen
, die eine Zahl genannt wird. Und es wird den Wert drei
haben. Danach können wir
eine benutzerdefinierte Typmagie erstellen , die einer Zahl
entspricht. Und wir können
die rechte Zeile der Konsole verwenden , um
eine Zahl von int in magic mit value magic number auszugeben. Und wenn wir diese
Zeile schließen und ausführen, können
Sie sehen, dass wir die ganze Zahl
drei in eine benutzerdefinierte
Konvertierung
konvertiert haben , die den Wert drei hat. So können Sie technisch gesehen
Ihre eigenen benutzerdefinierten
Konvertierungen in C-Sharp erstellen . Wir sehen uns beim nächsten Mal.
33. C# Das Ende erweitert: Willkommen. Dies ist mein letztes
Video dieser Serie. Hier in der Serie haben
Sie viele nützliche
Techniken in C-Sharp gelernt, wie Sie
Ihre Anwendung verbessern erweiterte Funktionen implementieren können, mit
denen Sie
robustere erstellen können
Anwendungen. Wir haben in
vielen Beispielen gesehen wie Sie das
gesamte Arsenal, das
Ihnen
C-Sharp zur Verfügung stellt, nutzen können , um
Ihre Programme oder Anwendungen
erfolgreicher zu machen . Und all diese Beispiele
werden in ein GitHub-Repository
hochgeladen , damit Sie die Beispiele, die Sie in den Videos
sehen, klonen und
reproduzieren
können Beispiele, die Sie in den Videos
sehen, klonen und
reproduzieren . Wir sehen uns im nächsten. Und ich hoffe, das war
informativ für Sie. Und ich möchte mich bei Ihnen dafür bedanken, dass
Sie zugesehen haben. Tschüss.