Zusammenfassung konzeptioneller Systeme in C#

1. Was ist .Net
.Net ist eine von Microsoft eingeführte Anwendungsentwicklungsplattform, mit der eine neue Generation von Microsoft Windows- und Webanwendungen erstellt und ausgeführt werden kann.

2. Die Kerntechnologie von .Net
.Net Framework: Der Kern des .Net-Plattformkerns, der das grundlegende Framework für den Betrieb von Anwendungen unter der .Net-Plattform bereitstellt .
.Net Enterprise Server: Teil der technischen Dienste von Microsoft für Unternehmen, einschließlich verschiedener Entwicklungs-Toolkits.
Building-Modul-Service: COM+-Komponentenservice und XML-Webservice-Technologie von Microsoft. Mithilfe des Building-Modul-Service zur Entwicklung von Anwendungsmodulen kann schnell eine voll funktionsfähige Software zusammengestellt werden.
Visual Studio.Net: Das Hauptentwicklungstool für die .NET-Plattform

3..Net Framework besteht aus verschiedenen Komponenten, um die Erstellung und Ausführung von Anwendungen auf Basis der .NET-Plattform zu unterstützen.

4. Die unterste Ebene des Net Framework-Frameworks sind verschiedene Anwendungsdienstkomponenten, die vom Windows-Betriebssystem bereitgestellt werden. Zu diesen Komponenten gehören: Nachrichtendienst Warteschlange , COM+-Komponentendienst ( IIS), Windows Management Tools (WMI) usw.

5..Net Framework kann in sie integriert werden, um Anwendungen zu entwickeln. Die oberste Ebene von .Net Framework ist die Programmiersprache. .Net Framework unterstützt mehr als 20 Computerprogrammiersprachen. In der Visual Studio.Net-Entwicklungsumgebung können Sie direkt fünf Sprachen verwenden: VB, C#, C++, J# und Jscript, um beliebige Anwendungen zu entwickeln.

6..Net Framework besteht aus zwei Hauptkomponenten: Common Language Runtime (CLR) und .Net FrameworkKlassenbibliothek, zusätzlich zu ADO.NET, ASP.NET, XML-Web usw.

7..Net Framework unterstützt drei Arten von Benutzeroberflächen:
Befehlskonsole, zum Entwerfen von Anwendungen mit reinen Zeichenschnittstellen
Windows Forms, zum Entwerfen von Anwendungen mit Windows-Oberfläche
Webformulare , Anwendungen zum Entwerfen von Webschnittstellen

8.ADO.NET ist Microsofts neue Generation der objektorientierten Datenverarbeitungstechnologie, die vom .Net Framework bereitgestellt wird und mit der Datenbankanwendungen einfach und einfach entwickelt werden können schnell.
ASP.Net ist eine neue Webanwendungsentwicklungstechnologie, die von .Net Framework bereitgestellt wird. Die Verwendung von ASP.NET zur Entwicklung von WEB-Anwendungen ist so einfach wie die Entwicklung von Windows-Anwendungen.
Xml Web Service ist eine Komponente, die direkt in der Internetumgebung aufgerufen werden kann. Das .Net Framework stellt Tools und Klassen zum Erstellen, Testen und Bereitstellen von XML-Webdiensten bereit.

9.Net Framework bietet Anwendungsentwicklern eine plattformunabhängige
Entwicklungsumgebung. Die Verwendung von .Net Framework zur Entwicklung von Programmen bietet folgende Vorteile:
1. Webbasierte Standards
.Net Framework unterstützt vollständig bestehende Internettechnologien und andere Webstandards.
2. Verwenden Sie ein einheitliches Anwendungsmodell Jede mit .NET kompatible Sprache kann die .Net Framework-Klassenbibliothek verwenden.
3. Einfach für Entwickler zu verwenden
Wenn Entwickler eine Klasse der .Net Framework-Klassenbibliothek aufrufen müssen, müssen sie nur das Klassenattribut
Namespace hinzufügen Zitieren Sie einfach in der Lösung. 4. Erweiterbare Klassen .Net Framework bietet ein universelles Typsystem. Entwickler können über
erben
auf Klassen in der Klassenbibliothek zugreifen oder sogar eigene erstellen eigene Klassenbibliothek.
Vorteile von C#: (1) C# ist eine präzise, ​​einfache, typsichere
objektorientierte Sprache.
(2) C# verfügt über die Fähigkeit, persistente Komponenten auf Systemebene zu generieren. (3) C# nutzt das universelle Typsystem des .Net Framework, um mit anderen Programmiersprachen zusammenzuarbeiten. (4) C# unterstützt den MSMQ-Dienst (Microsoft Message Queuing), den COM+-Komponentendienst, den XML-Webdienst und .Net Framework.
(5) C# ermöglicht das Anpassen von
Datentypen
mit erweiterten Metadaten.
(6) C# steigert die Entwicklungseffizienz und behält gleichzeitig die von Entwicklern geforderte Flexibilität bei. Eigenschaften von C#-Programmen: 4. Die Struktur von Methoden in C#-Programmen Eine Methode in einem C#-Programm ist
in zwei Teile gruppiert
: Methodenkopf und Methodenkörper.
Methodenheader: Der Methodenheader ist die erste Zeile der Methode, einschließlich des Rückgabewerttyps, des Methodennamens, des formalen Parameternamens und der Beschreibung des formalen Parametertyps. Methodenkörper: Der Methodenkörper ist von einem Paar geschweifter Klammern „{}“ umgeben und enthält normalerweise Deklarationsanweisungen und Ausführungsanweisungen.

5. Anweisungen eines C#-Programms
Jede Anweisung in einem C#-Programm muss mit einem Semikolon enden. Beim Schreiben können Sie mehrere Anweisungen in einer Zeile schreiben.

6. Eingabe- und Ausgabeoperationen von C#-Programmen
Die C#-Sprache selbst hat keine Eingabe- und Ausgabeanweisungen, daher muss die C#-Konsolenanwendung die Methoden der Console-Klasse in der Klassenbibliothek verwenden ( ReadLine, WriteLine usw.), um Eingabe-, Ausgabe- und andere Vorgänge abzuschließen, während C#-Windows-Anwendungen und Webanwendungen die Control-Klasse (wie Beschriftungen, Textfelder usw.) verwenden müssen Klassenbibliothek zur Implementierung von Eingabe und Ausgabe.

7. Kommentare für C#-Programme
Sie können „//“ oder „/*...*/“ verwenden, um Kommentare hinzuzufügen. Durch das Hinzufügen geeigneter Kommentare kann die Lesbarkeit des Programms erheblich verbessert werden.
Einfacher Typ stellt einen Datentyp mit einem eindeutigen Wert dar, einschließlich der folgenden 4
-Typen: 1. Ganzzahltyp 2. Gleitkommatyp3. Boolescher Typ
Float-Typ: Der Wertebereich beträgt ±1,5e?45 bis ±3,4e38. Die Genauigkeit beträgt 7 Stellen.
Double-Typ: Der Wertebereich beträgt ±5,0e?324 bis ± 1.7 Die Genauigkeit von e308 beträgt 15 bis 16 Stellen

3. Dezimaltyp Dezimalzahl Um den Anforderungen hochpräziser Finanz- und Finanzberechnungsfelder gerecht zu werden, stellt C# den Datentyp „Dezimaltyp“
mit einem Wertebereich bereit von ±1,0?×?10e ​​?28 bis ±7,9? Konstanten
Ganzzahlkonstanten werden in vorzeichenbehaftete Ganzzahlkonstanten, vorzeichenlose Ganzzahlkonstanten und lange Ganzzahlkonstanten unterteilt
Vorzeichenbehaftete Ganzzahlkonstanten werden direkt geschrieben, z. B. 5
Vorzeichenlose Ganzzahlkonstanten fügen beim Schreiben das u- oder U-Zeichen hinzu, z 5Ulange Ganzzahl Fügen Sie beim Schreiben von Typkonstanten die Markierung l oder L hinzu, z. B. 5L 2. Gleitkommakonstanten werden in Gleitkommakonstanten mit einfacher Genauigkeit und Gleitkommakonstanten mit doppelter Genauigkeit unterteilt -Punkt-Konstanten
Konstanten vom Typ Gleitkomma mit einfacher Genauigkeit werden beim Schreiben mit f oder F gekennzeichnet, z. B. 5F
Konstanten mit doppelter Genauigkeit werden mit d oder D gekennzeichnet, z. B. 5D
Beim direkten Schreiben In Dezimalform werden sie automatisch als Gleitkommakonstanten mit doppelter Genauigkeit interpretiert, z. B. 5,0 ist eine Gleitkommakonstante mit doppelter Genauigkeit.
3. Dezimalkonstanten
Die Markierung m oder M muss nach der Dezimalkonstante hinzugefügt werden, andernfalls werden sie als Gleitkommadaten interpretiert.
4. Zeichenkonstanten (Unicode-Zeichen):
Zeichenkonstanten werden mit zwei einfachen Anführungszeichen gekennzeichnet, z. B. „5“, „A“, „中“, „@“
C#-Escape-Zeichenkonstanten beginnen mit ein Backslash“ und werden zur Darstellung von Steuer- und unsichtbaren Zeichen verwendet. „b“ bedeutet beispielsweise, dass ein Zeichen zurückgeht. Einzelheiten finden Sie in Tabelle 2-3 auf Seite 26 des Lehrbuchs
5. Es gibt nur zwei boolesche Konstanten
, true steht für logisch wahr und false steht für logisch falsch.
6.
String
Konstante
String-Konstante stellt eine Zeichenfolge dar, die aus mehreren Unicode-Zeichen besteht und mit doppelten Anführungszeichen markiert ist, z. B. „5“, „abc“, „Chinesisch“.
Strukturtypen müssen mit struct gekennzeichnet sein.
Strukturelemente dürfen Datenelemente, Methodenelemente usw. enthalten.
Datenelemente stellen Datenelemente der Struktur dar.
Methodenelemente stellen Operationen an Datenelementen dar.
1. Das Konzept der Variablen

Während der Ausführung des Programms wird der Betrag, dessen Wert geändert werden kann, als Variable bezeichnet.

Variablenname
: Jede Variable muss einen Namen haben. Die Benennung von Variablen sollte den Benennungsregeln für Bezeichner folgen. Beispielsweise muss sie mit einem Buchstaben oder Unterstrich beginnen und darf nur englische Buchstaben, Zahlen und Unterstriche enthalten und darf keine Leerzeichen usw. enthalten.
Variablenwert: Der Variablenwert wird im Speicher gespeichert; verschiedene Arten von Variablen belegen eine unterschiedliche Anzahl von Speichereinheiten (Bytes). In einem Programm wird der Wert einer Variablen durch ihren Namen referenziert.
2. Definition von Variablen Die allgemeine Form der Variablendefinition ist: Datentyp Variablenname 1, Variablenname 2,...; >

3. Initialisierung von Variablen Zum Beispiel:

float  f1＝1.25, f2＝3.6；

 
值类型之间的数据可以相互转换，转换的方法有两种，一种是隐式转换，另一种是显式转换。
1. 隐式转换
如果参与运算的数据类型不相同，则先转换成同一类型，然后进行运算；
转换时按数据长度增加的方向进行，以保证精度不降低，例如int型和long型运算时，先把int数据转成long型后再进行运算；
所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算； 
byte型和short型数据参与运算时，必须先转换成int型；
Char型可以隐式转换为ushort、int、uint、long、ulong、float、double或decimal型，但不存在其他类型到char类型的隐式转换。
2. 显式转换
强制类型转换的一般形式为：
     (类型说明符) (待转换的数据) 
例如：(int)(x+y)   //把x+y的值强制转换为int型
注意：上例不可写为(int)x+y，另外经过强制类型转换后x、y本身的变量类型并不会改变
3. C#还允许使用System.Convert类提供的类型转换方法来转换数据类型 
常用的转换方法有ToBoolean 、ToByte、ToChar、ToInt32、ToSingle、ToString等
例如
     

 byte x=40,y=5;                          //定义字节型变量x和y
       byte z=Convert.ToByte(x+y);  //将int型值转换为byte型并赋给byte型变量z
      char c=Convert.ToChar(z+20); //将int型值转换为char型并赋给char型变量z

C#算术运算符包括+、-、*、/、%、++、--共七种 
自增++/自减--运算符
当++或--运算符置于变量的左边时，称之为前置运算，表示先进行自增或自减运算再使用变量的值，而当++或--运算符置于变量的右边时，称之为后置运算，表示先使用变量的值再自增或自减运算 
例如：设变量i=1、变量j=2，则表达式++i + j-- 的值为4

2. 复合赋值运算符
+=、-=、*=、/=、%=、&=、|=、^=、c1416f47236dd7b5b9b6ea098534dc8d>=
1. 什么是数组
数组是一种由若干个变量组成的集合，数组中包含的变量称为数组的元素，它们具有相同的类型。
数组元素可以是任何类型，包括数组类型。
数组元素的个数称为数组的长度，数组长度为0时称数组为空数组。
数组元素没有名称，只能通过索引来访问，索引从零开始。
具有 n 个元素的数组的索引是从 0 到 n-1。
C#支持一维数组和多维数组。

2. 数组的声明和创建 
C#中的数组是一个对象，所以使用new运算符来创建 
声明和创建一维数组的一般形式：
数组类型[ ]  数组名 = new  数组类型[数组长度]；
如：

int[ ] numbers=new int[5]; //创建具有5个元素的一维数组numbers

声明和创建多维数组的一般形式：
数组类型[逗号列表]  数组名 = new  数组类型[数组长度列表]
如：

int[,,] numbers=new int[5,4,3];  //创建一个三维数组numbers

3. 数组的初始化
（1）在创建数组时初始化
创建一维数组时初始化的一般形式为：
数组类型[ ]  数组名 = new  数组类型[数组长度]{初始值列表}；
如：

 int[ ] numbers=new int[ ]{1,2,3,4,5} ;//当省略数组长度时，则给出的数据个数即为数组长度

上例中numbers[0]=1,……，numbers[4]=5
在创建并初始化数组时，还可采用简写形式：
数组类型[ ]  数组名 ={初始值列表}
如

int[ ] numbers={1,2,3,4,5} ;

3. 数组的初始化
（2）在声明一维数组后初始化数组
在声明后初始化一维数组的一般形式为：
数组类型[ ]  数组名；
     数组名 = new  数组类型[数组长度]{初始值列表}；
如：

int[ ] numbers；
             numbers = new int[ ]{1,2,3,4,5} ；

注意在先声明后初始化时，不能采用简写形式，例如：

int[ ] numbers；
      numbers = {1,2,3,4,5} ；

     是错误的


4. 数组的使用：
每个数组元素相当于一个普通变量，使用数组元素的一般形式为：
数组名[索引]
C#的数组类型是从抽象基类型System.Array派生的引用类型， System.Array类提供的Length属性可以用来获得数组的个数。
另外System.Array提供了Clear、CopyTo、Find、Resize、Sort等方法，用于清除数组元素的值、复制数组、搜索数组、更改数组长度和对数组元素排序等。
5.System.String与 System.Text.StringBuilder
C#的string 是.NET Framework中System.String 的别名，可创建不可变的字符串。其提供的常用属性和方法有Length、Copy、IndexOf、LastIndexOf、Insert、Remove、Replace、Split、Substring、Trim等，分别用来获得字符串长度、复制字符串、从左查找字符、从右查找字符、插入字符、删除字符、替换字符、分割字符串、取子字符串、压缩字符串的空白等。
System.Text.StringBuilder类用来构造可变字符串，包含Length、Append、Insert、Remove、Replace、ToString等成员，分别用来获得字符串长度、追加字符、插入字符、删除字符、替换字符和将StringBuilder转换为string字符串。
对象（Object），是问题域中某些事物的一个抽象，反映事物在系统中需要保存的必要信息和发挥的作用，是包含一些特殊属性（数据）和服务（行为方法）的封装实体。
具体来说，对象应有唯一的名称、有一系列状态（表示为数据）、有表示对象行为的一系列行为（方法），如右图所示。
对象=数据+动作（方法/操作）

1. 事件（Event）
又称消息（Message）表示向对象发出的服务请求。

2. 方法（Method）
表示对象能完成的服务或执行的操作功能。 
类（Class）是具有相同属性和服务的一组对象的集合
类为属于同类的所有对象提供统一的抽象描述。其中，相同的属性是指定义形式相同，不是指属性值相同。
对象是类的一个实例。
类与实例的关系是抽象与具体的关系，类是多个实例的综合抽象，实例是类的个体实物。
面向对象的最基本的特征是封装性、继承性和多态性：

1. 封装
封装就是指把对象的全部属性和全部服务结合在一起形成一个不可分割的独立单位。
封装是一种信息隐蔽技术，用户只能见到对象封装界面上的信息，对象内部对用户是隐蔽的。
封装的目的在于将对象的使用者与设计者分开，使用者不必了解对象行为的具体实现，只需要用设计者提供的消息接口来访问该对象。
例如，各种有标准视频接口的设备都可以连接电视机。 

2.继承
特殊类的对象拥有其一般类的全部属性与服务，称作特殊类对一般类的继承，即在特殊类中不必重新定义已在一般类中定义过的属性和服务，这种特性在面向对象中称作对象的继承性。
继承在C#中称为派生，其中，一般类称为基类或父类，特殊类称为派生类或子类。
例如灵长类动物称为一般类，具有属性包括手和脚（其它动物没有），具有的服务是抓取东西（其它动物没有），人类作为特殊的灵长类高级动物，除了继承灵长类动物的所有属性和服务外，还具有特殊的服务（创造工具）。
继承机制的优势在于降低了软件开发的复杂性和费用，使软件系统易于扩充 


3.  多态
多态性是指在基类中定义的属性或服务被派生类继承后，可以具有不同的数据类型或表现出不同的行为。
为了实现多态性，需要在派生类中更改从基类中自动继承来的数据类型或方法。
这种为了替换基类的部分内容而在派生类中重新进行定义的操作，在面向对象概念中称之为覆盖。
例如，假设机动车类是一个基类，它具有一个称为更换轮胎的方法，但是当从机动车派生火车类时，火车更话车轮的方法与一般的机动车不同，于是只能通过覆盖的方法在火车类中重新定义一个更换车轮的方法，以替换其基类的方法。
多态性的优势在于使软件开发更加方便，增加程序的可读性。
Das konstante Mitglied einer Klasse ist eine symbolische Konstante, und der Name und der Wert müssen angegeben werden.
Zu den Zugriffsmodifikatoren gehören: öffentlich, privat, intern, geschützt, geschützt intern.
Wenn Sie Zugriffsmodifikatoren verwenden, um Namespaces, Strukturen, Klassen und ihre Mitglieder zu definieren
, beachten Sie bitte Folgendes:
(1) Ein Mitglied oder Typ kann nur einen Zugriffsmodifikator haben, außer bei Verwendung einer geschützten internen Kombination.
(2) Zugriffsmodifikatoren sind für Namespaces nicht zulässig und es gibt keine Zugriffsbeschränkungen für Namespaces.
(3) Wenn der Zugriffsmodifikator nicht angegeben ist, wird die Standardzugänglichkeit verwendet und die Klassenmitglieder sind standardmäßig privat.
(4) Der Zugriff auf Typen der obersten Ebene (Typen, die nicht in anderen Typen verschachtelt sind) kann nur intern oder öffentlich sein, und der Standardzugriff ist intern.
Detaillierte Beschreibung der Definition von Methoden
(1) Zugriffsmodifikatoren steuern die Zugriffsebene von Methoden, die für Methoden verwendet werden können: öffentlich, geschützt, privat, intern usw.
(2) Der Rückgabewerttyp einer Methode kann jeder zulässige Datentyp sein, einschließlich Werttypen und Referenztypen. Wenn kein Rückgabewert vorhanden ist, wird der Rückgabewerttyp durch das Schlüsselwort void dargestellt.
(3) Der Methodenname muss der C#-Namenskonvention entsprechen, die mit der Benennungsregel für Variablennamen identisch ist.
(4) Die Parameterliste sind die Eingabedaten, die die Methode akzeptieren kann. Wenn eine Methode keine Parameter erfordert, kann die Parameterliste weggelassen werden, die Klammern dürfen jedoch nicht weggelassen werden. Wenn mehr als ein Parameter vorhanden ist, müssen Kommas als Trennzeichen verwendet werden und jeder Parameter muss den Datentyp deklarieren, auch wenn die Datentypen dieser Parameter gleich sind.
(5) Der Inhalt in geschweiften Klammern {} ist der Hauptteil der Methode, der aus mehreren Anweisungen besteht. Jede Anweisung muss mit einem Semikolon enden. Wenn Sie das Operationsergebnis zurückgeben müssen, wenn die Methode endet, verwenden Sie zum Zurückgeben die Anweisung return. Beachten Sie zu diesem Zeitpunkt, dass der Typ des von der return-Anweisung zurückgegebenen Werts mit dem Typ des Rückgabewerts der Methode übereinstimmen muss . Wenn die Methode als void markiert ist und keinen Rückgabewert hat, kann die Return-Anweisung weggelassen werden.

1. Werttypparameter
Beim Aufrufen einer Richtungsmethode zur Übergabe eines Werttypparameters weist der Aufrufer den Wert der tatsächlichen Parametervariablen der entsprechenden formalen Parametervariablen, also dem tatsächlichen Parameter, zu Die Variable und die formale Parametervariable sind zwei verschiedene Variablen.
Wenn der Wert der tatsächlichen Parametervariablen an die formale Parametervariable übergeben wird, handelt es sich um eine unidirektionale Wertübertragung.
Referenztypparameter
unterscheiden sich von Wertparametern. Wenn die aufrufende Richtungsmethode einen Referenztypparameter übergibt, weist der Aufrufer die Referenz der tatsächlichen Parametervariablen der entsprechenden formalen Parametervariablen zu. Die Referenz der tatsächlichen Parametervariablen stellt die Speicheradresse des Datenwerts dar, sodass die formale Parametervariable und die tatsächliche Parametervariable auf dieselbe Referenz verweisen.
Wenn der Datenwert, auf den die formale Parametervariable verweist, innerhalb der Methode geändert wird, wird auch der Datenwert geändert, auf den die tatsächliche Parametervariable verweist.
Da die Return-Anweisung jeweils nur ein Daten zurückgeben kann, können Sie diese Funktion von Referenzparametern verwenden, um dies zu erreichen, wenn Sie mehrere Daten zurückgeben müssen.
C# deklariert Referenzparameter über das Schlüsselwort ref. Unabhängig davon, ob es sich um einen formalen Parameter oder einen tatsächlichen Parameter handelt, müssen Sie das Schlüsselwort ref hinzufügen, solange Sie einen Verweis auf die Daten übertragen möchten.
Ausgabeparameter
Die Rückgabeanweisung in der Methode kann nur ein Operationsergebnis zurückgeben. Obwohl Referenzparameter auch zur Rückgabe des Berechnungsergebnisses verwendet werden können, müssen die tatsächlichen Parameter zuerst initialisiert werden.
Der Ausgabeparameter muss die tatsächlichen Parameter nicht initialisieren. Er wird speziell verwendet, um die Daten in der Methode über die formalen Parameter an die tatsächlichen Parameter zurückzugeben, der Wert der tatsächlichen Parameter wird jedoch nicht an die formalen Parameter übergeben . In einer Methode sind mehrere Ausgabeparameter zulässig.
C# deklariert Ausgabeparameter über das Schlüsselwort out. Unabhängig davon, ob es sich um einen formalen Parameter oder einen tatsächlichen Parameter handelt, muss das Schlüsselwort out hinzugefügt werden, solange es sich um einen Ausgabeparameter handelt.
Array-Typ-Parameter
Bei der Verwendung von Arrays als Parameter gibt es zwei Möglichkeiten, sie zu verwenden:
Die eine besteht darin, den Modifikator params nicht vor der formalen Parametergruppe hinzuzufügen.
Die andere besteht darin, params vor der formalen Parametergruppe hinzuzufügen Modifikator.
Der Unterschied zwischen den beiden Formen
Wenn der Parameter params nicht hinzugefügt wird, muss der entsprechende tatsächliche Parameter ein Array-Name sein.
Beim Hinzufügen des Parameters params kann der entsprechende tatsächliche Parameter ein Array-Name oder eine Liste von Array-Elementwerten sein.
Es ist zu beachten, dass die formale Parametergruppe unabhängig von der verwendeten Form die Array-Länge nicht definieren kann.
Überladung von
Methodenüberladung bezieht sich auf die Deklaration von zwei oder mehr Methoden mit demselben Namen im selben Typ. Methodenüberladung kann nützlich sein, wenn Sie denselben Vorgang mit einer anderen Parameterliste ausführen müssen.

2. Eigenschaften des Destruktors :
(1) Sie können keinen Destruktor in einer Struktur definieren, Sie können einen Destruktor nur für eine Klasse verwenden
(2) A Die Klasse kann nur einen Destruktor haben.
(3) Der Destruktor kann nicht vererbt oder überladen werden Die CLR des Frameworks fügt automatisch einen Aufruf der Basisklasse Object.
Final
ize-Methode hinzu, um die Szene zu bereinigen, sodass ein Aufruf der Object.Finalize-Methode nicht in den Destruktor aufgenommen werden kann. Beachten Sie, dass der Compiler standardmäßig automatisch einen leeren Destruktor generiert, sodass C# die Definition eines leeren Destruktors nicht zulässt
1. Definition der statischen-Klasse:
Die statische Klasse wird mit dem statischen Schlüsselwort deklariert, was angibt, dass sie nur statische Mitglieder enthält.
Sie können das Schlüsselwort new nicht verwenden, um Instanzen statischer Klassen zu erstellen.
Wenn in praktischen Anwendungen die Mitglieder einer Klasse nicht mit einem bestimmten Objekt verknüpft sind, kann sie als statische Klasse erstellt werden.

2. Die Hauptfunktionen statischer Klassen:
(1) Statische Klassen enthalten nur statische Mitglieder;
(3) Statische Klassen sind versiegelt ;
(4) Statische Klassen können keine Instanz-
-Konstruktoren enthalten.
3. Vorteile statischer Klassen:
(1) Der Compiler kann automatisch prüfen, ob Instanzmitglieder hinzugefügt werden
(2) Statische Klassen können die Programmimplementierung einfacher und schneller machen. weil Sie kein
ein Objekt erstellen müssen, um seine Methoden aufzurufen. Hinweis: Da statische Klassen versiegelt sind, können sie nicht vererbt werden. Darüber hinaus können statische Klassen keine Instanzkonstruktoren enthalten, können aber dennoch statische Konstruktoren deklarieren, um Anfangswerte zuzuweisen oder einen statischen Status festzulegen.
(1) Merkmale abgeleiteter Klassen
können ihre eigenen Mitglieder haben.
Sie können implizit alle Mitglieder der Basisklasse erben, einschließlich Methoden, Felder, Eigenschaften und Ereignisse, mit Ausnahme privater Mitglieder, Konstruktoren und Destruktoren.
Abgeleitete Klassen können nur von einer Klasse erben
Versiegelte Klasse
Durch die Verwendung einer versiegelten Klasse kann verhindert werden, dass der Code einer Klasse von anderen Klassen geerbt wird
Vorteile der Verwendung einer versiegelten Klasse:
Kann Verbessern Sie die Leistung der Anwendung. Zuverlässigkeit und Leistung (in der Common Language Runtime-CLR von .NET Framework werden Methodenaufrufe an versiegelte Klassen beim Laden versiegelter Klassen optimiert).
Softwareunternehmen können ihre geistigen Eigentumsrechte auch schützen, indem sie versiegelte Klassen verwenden, um zu verhindern, dass andere Code teilen.
Fügen Sie in C# das Schlüsselwort „sealed“ hinzu, um eine versiegelte Klasse zu deklarieren.

4. Um abgeleitete Klassen zum Ändern der Daten und des Verhaltens von Basisklassen zu verwenden, bietet C# zwei Optionen: 1. Verwenden Sie neue abgeleitete Klassenmitglieder, um Basismitglieder zu ersetzen. 2. Überschreiben Sie virtuelle Basismitglieder.
Beachten Sie bei der Verwendung von Virtual und Override die folgenden Punkte:
(1) Felder können nicht virtuell sein, sondern nur Methoden, Eigenschaften, Ereignisse und Nur Indexer kann virtuell sein;
(2) Nach Verwendung des virtuellen Modifikators dürfen die statischen, abstrakten oder überschreibenden Modifikatoren nicht verwendet werden
(3) Auch wenn ein abgeleitetes Klassenobjekt in ein Basisklassenobjekt umgewandelt wird, Die Referenz ist immer noch Mitglied der abgeleiteten Klasse. (4) Die abgeleitete Klasse kann die virtuelle Vererbung durch Versiegeln stoppen. Zu diesem Zeitpunkt werden die Mitglieder der abgeleiteten Klasse mithilfe einer versiegelten Überschreibung deklariert.


Eigenschaften abstrakter Klassen
: Abstrakte Klassen werden als Basisklassen verwendet und können nicht direkt instanziiert werden, sondern können nur mit dem Schlüsselwort abstract identifiziert werden. Der Zweck einer abstrakten Klasse besteht darin, eine gemeinsame Definition einer Basisklasse bereitzustellen, die von mehreren abgeleiteten Klassen gemeinsam genutzt werden kann. Abstrakte Klassen können abstrakte Mitglieder wie abstrakte Eigenschaften und abstrakte Methoden sowie nicht abstrakte Mitglieder und sogar virtuelle Methoden enthalten.
Eigenschaften abstrakter Attribute
Nachdem das abstrakte Schlüsselwort zu den Attributmitgliedern einer Klasse hinzugefügt wurde, werden sie zu abstrakten Attributen.
Abstrakte Eigenschaftsdeklarationen stellen nicht die Implementierung des Eigenschafts-Accessors bereit, sondern deklarieren nur die von der Klasse unterstützten Eigenschaften und überlassen die Implementierung des Accessors der abgeleiteten Klasse.
Abstrakte Eigenschaften können auch schreibgeschützte, schreibgeschützte oder Lese-/Schreibeigenschaften sein.
Wenn eine abgeleitete Klasse eine abstrakte Eigenschaft von einer abstrakten Klasse erbt, muss die abgeleitete Klasse die abstrakte Eigenschaft überschreiben.
Abstrakte Attribute werden mit dem Schlüsselwort abstract identifiziert

Eigenschaften abstrakter Methoden:
Nach dem Hinzufügen des Schlüsselworts abstract zu einem Methodenmitglied einer Klasse wird es zu einer abstrakten Methode.
Abstrakte Methodendeklaration stellt nicht die Implementierung der Methode bereit, es muss eine leere Methode sein und die Methodenimplementierung der abgeleiteten Klasse überlassen.
Wenn eine abgeleitete Klasse eine abstrakte Methode von einer abstrakten Klasse erbt, muss die abgeleitete Klasse die abstrakte Methode überschreiben.
Da die abstrakte Methode nicht implementiert ist, enthält die abstrakte Methode keinen regulären Methodenkörper und endet mit einem Semikolon.
1. Delegate ist eine Art Referenzmethode. Es ist dasselbe wie Klasse, Schnittstelle und Array und gehört zum Referenztyp.
In einem C#-Programm können Sie einen Delegate-Typ deklarieren, Variablen des Delegate-Typs definieren, Delegate-Variablen Methoden zuweisen und eine oder mehrere Methoden indirekt über Delegate aufrufen.
Sobald eine Methode einem Delegaten zugewiesen wird, verhält sich der Delegat genau so wie diese Methode.
C# ermöglicht die Zuweisung jeder Methode mit derselben Signatur (gleichem Rückgabewert und denselben Parametern) zu einer Delegate-Variablen.
Das Wesentliche eines Delegaten ist eine Referenz (d. h. eine Speicheradresse), die eine Methode darstellt. Es ist eine ideale Wahl für die Definition von Rückrufmethoden und ist auch die Hauptmethode für C#, um das Ereignis
gesteuert
Programmierung Modell. Delegaten haben die folgenden Eigenschaften: (1) Delegaten ähneln C++-Funktionszeigern
, die vollständig objektorientiert und sichere Datentypen sind.
(2) Delegate ermöglicht die Übergabe von Methoden als Parameter. (3) Delegate kann zum Definieren von Rückrufmethoden verwendet werden. (4) Delegierte können miteinander verknüpft werden. Beispielsweise können für ein Ereignis mehrere Methoden aufgerufen werden.
(5) Die Signatur des Delegaten muss nicht genau mit der Methode übereinstimmen.
Eine Sammlung ist eine Klasse, die beliebige Objekte auf hochstrukturierte Weise speichert. Im Vergleich zu Arrays, deren Größe nicht dynamisch geändert werden kann, können Sammlungen nicht nur nach Belieben in der Größe geändert werden, sondern bieten auch erweiterte Methoden zum Speichern oder Abrufen der darin gespeicherten Objekte . .
Sammlungen können eine Gruppe ähnlich typisierter Objekte zusammenfassen.
Bei der Auswahl einer Sammlungsklasse sollten Sie im Allgemeinen die folgenden Aspekte berücksichtigen:
(1) Benötigen Sie eine Sequenzliste? Wenn Sie ein First-In-First-Out-Verhalten benötigen, können Sie die Queue-Klasse verwenden Wenn Sie ein Last-In-First-Out-Verhalten benötigen, können Sie die Stack-Klasse verwenden.
(2) Unabhängig davon, ob Sie zufällig auf die Elemente in der Sammlung zugreifen müssen, können Sie die Warteschlangenklasse „Warteschlange“, die Stapelklasse „Stack“ und die Klasse „LinkedList“ mit doppelt verknüpfter Liste nicht auswählen.
(3) Müssen Sie über den Index auf jedes Element zugreifen? Nur die dynamische Array-Klasse ArrayList, die Zeichenfolgensammlungsklasse StringCollection usw. greifen nacheinander auf die Sammlungselemente zu, beginnend mit dem Element mit dem Index Null. HashTabelle Hash-Tabellen- und Wörterbuch-Wörterbuchklassen bieten Zugriff auf Elemente über den Schlüssel des Elements (d. h. den Elementnamen). Die NameValueCollection-Klasse und die generische SortedList-Klasse bieten Zugriff auf Elemente über den nullbasierten Index ihres Elements oder über den Schlüssel seines Elements.
(4) Ob es einen Wert, einen Schlüssel und eine Menge von Werten oder eine Menge aus einem Schlüssel und mehreren Werten enthält. Unter diesen ist die Sammlung „ein Wert“ eine Sammlung, die auf der IList-Listenschnittstelle basiert, die Sammlung „ein Schlüssel und ein Wert“ ist eine Sammlung basierend auf der IDictionary-Wörterbuchschnittstelle und die Sammlung „ein Schlüssel und mehrere“. Werte" ist vom Typ NameValueCollection.
(5) Ob die Elemente anders als die Eingabeelemente sortiert werden müssen. Die Hashtable-Hash-Tabellenklasse sortiert Elemente nach ihren Hash-Codes, die SortedList-Klasse für geordnete Listen und das SortedDictionary-Dictionary implementieren die Sortierung von Elementen nach Schlüssel gemäß der IComparer-Vergleichsschnittstelle, und die dynamische Array-Klasse ArrayList stellt die Sortiermethode Sort bereit.
(6) Unabhängig davon, ob Sie eine schnelle Suche und einen schnellen Informationsabruf benötigen, ist ListDictionary für kleine Sammlungen (10 Elemente oder weniger) schneller als Hashtable, und die generische Klasse SortedDictionary bietet eine schnellere Suche als die generische Klasse Dictionary.
(7) Müssen Sie nur eine Sammlung von Zeichenfolgen akzeptieren, z. B. die Verwendung von StringCollection und StringDictionary usw.
Die dynamische Array-Klasse ArrayList begrenzt die Anzahl und den Datentyp der Elemente nicht.
(1) Der Unterschied zwischen ArrayList und Array
Die Größe von Array ist fest, während die Größe von ArrayList nach Bedarf automatisch erweitert werden kann
Sie können jeweils nur den Wert eines Elements abrufen oder festlegen Zeit in Array, während ArrayList in Array das Hinzufügen, Einfügen oder Entfernen von Elementen innerhalb eines bestimmten Bereichs ermöglicht.
Die Untergrenze von Array kann angepasst werden, während die Untergrenze von ArrayList immer Null ist.
Array kann mehrere Dimensionen haben , während ArrayList immer nur eindimensional ist ;
Array befindet sich im System-Namespace und ArrayList befindet sich im System.Collections-Namespace.
(2) Erstellen Sie ein dynamisches Array:
ArrayList List-Objektname = new ArrayList(?);
Eigenschaften der Warteschlange
Eine First-In-First-Out-Datenstruktur, wenn ein Objekt eingefügt wird oder gelöscht, das Objekt an einem Ende der Warteschlange einfügen und am anderen Ende entfernen
Warteschlangenobjekt erstellen
Warteschlangenname = neue Warteschlange([Warteschlangenlänge][, Wachstumsfaktor]);
Erklärung, Die Warteschlangenlänge beträgt standardmäßig 32 und wächst. Der Faktor beträgt standardmäßig 2,0 (d. h. wenn die Warteschlangenkapazität nicht ausreicht, wird die Warteschlangenlänge auf das Zweifache des ursprünglichen Werts angepasst).
Beachten Sie, dass für die Anpassung der Warteschlangengröße ein gewisser Faktor erforderlich ist Aufgrund der Leistungskosten wird empfohlen, beim Erstellen der Warteschlange die Warteschlangenlänge anzugeben.
Zu den gängigen Warteschlangenbetriebsmethoden gehören „Enqueue“, um Daten am Ende der Warteschlange hinzuzufügen, „Dequeue“, um Daten vom Kopf der Warteschlange zu entfernen, „Peek“, um Daten vom Kopf der Warteschlange zurückzugeben, „Clear“, um die Warteschlange zu leeren, und „Contains to“. Überprüfen Sie, ob bestimmte Daten enthalten sind. Unter diesen können Enqueue und Dequeue jeweils nur ein Datenelement hinzufügen oder löschen.
Eigenschaften des Stapels:
Eine First-In-Last-Out-Datenstruktur. Beim Einfügen oder Löschen eines Objekts kann diese Datenstruktur nur oben im Stapel eingefügt oder gelöscht werden.
Erstellen Sie ein Stapelobjekt:
Stapelstapelname = neuer Stapel(?);
Zu den gängigen Stapelmethoden gehören „Push“, um Daten oben auf dem Stapel hinzuzufügen, „Pop“, um die obersten Daten des Stapels zu entfernen, „Peek“. um die obersten Daten des Stapels zurückzugeben, und „Clear“, um den Stapel zu löschen, und „Contain“, um zu überprüfen, ob er bestimmte Daten usw. enthält. Unter anderem kann Push and Pop jeweils nur ein Datenelement hinzufügen oder löschen.
Hash-Tabelle, auch Hash-Tabelle genannt, stellt eine Sammlung von Schlüssel/Wert-Paaren dar.
Merkmale der Hash-Tabelle: Beim Speichern eines Sammlungselements muss der Hash-Code automatisch basierend auf dem Schlüssel berechnet werden, um den Speicherort des Elements zu bestimmen, und dann wird der Wert des Elements in den Bucket gelegt, auf den gezeigt wird den entsprechenden Ort. Suchen Sie bei der Suche erneut in einem bestimmten Bucket anhand des Hash-Codes, der dem Schlüssel entspricht. Dadurch wird die Anzahl der zum Auffinden eines Elements erforderlichen Vergleiche erheblich reduziert.
Erstellen Sie ein Hash-Tabellenobjekt
Hashtable Hash-Tabellenname = new Hashtable([Hash-Tabellenlänge][, Wachstumsfaktor]);
Erklärung: Die Standardlänge ist 0 und der Standardwachstumsfaktor ist 1,0
Zu den gängigen Betriebsmethoden von Hash-Tabellen gehören „Hinzufügen“, um Daten hinzuzufügen, „Entfernen“, um Daten zu entfernen, „Löschen“, um die Hash-Tabelle zu löschen, und „Enthält“, um zu überprüfen, ob bestimmte Daten enthalten sind. Unter diesen erfordert die Add-Methode zwei Parameter, einer ist der Schlüssel und der andere ist der Wert; die Remove-Methode erfordert nur einen Schlüsselparameter.
Es gibt zwei Unterschiede zwischen Schnittstellenindexern und Klassenindexern:
Erstens verwenden Schnittstellenindexer keine Modifikatoren.
Zweitens enthalten Schnittstellenindexer nur den Accessor get oder set, keine Implementierungsanweisung.
Beim Erstellen einer benutzerdefinierten generischen Klasse müssen Sie besonders auf die folgenden Punkte achten:
(1) Welche Typen sollten als Typparameter verallgemeinert werden?
Die allgemeine Regel lautet: Je mehr Typen parametrisiert werden können Je flexibler Sie werden, desto besser ist Ihre Wiederverwendbarkeit, aber zu viel Verallgemeinerung kann es anderen Entwicklern erschweren, den Code zu lesen oder zu verstehen.
(2) Wenn es Einschränkungen gibt, welche Einschränkungen sollten auf die Typparameter angewendet werden?
Die allgemeine Regel lautet: Wenden Sie so viele Einschränkungen wie möglich an, aber seien Sie dennoch in der Lage, mit den Typen umzugehen, die vorhanden sind müssen bearbeitet werden. Wenn Sie beispielsweise wissen, dass eine generische Klasse nur für Referenztypen verwendet wird, wenden Sie Klasseneinschränkungen an. Dies verhindert, dass generische Klassen versehentlich für Werttypen verwendet werden.
(3) Ob generisches Verhalten in Basisklassen und Unterklassen zerlegt werden soll
Da generische Klassen als Basisklassen verwendet werden können, sind ihre Vorsichtsmaßnahmen dieselben wie bei nicht generischen Klassen.
(4) Ob eine oder mehrere generische Schnittstellen implementiert werden sollen.
EreignisverarbeitungKomponenten des Systems
(1) Ereignisquelle: bezieht sich auf das Objekt, das das Ereignis auslösen kann, manchmal auch als Absender des Ereignisses oder Herausgeber des Ereignisses bezeichnet;
(2) Listener: Bezieht sich auf ein Objekt, das Ereignismeldungen empfangen kann.
(3) Ereignishandler: Verarbeitet Ereignisse, die auch als Ereignisfunktionen oder Ereignismethoden bezeichnet werden Der Ereignishandler, der den Ereignishandler enthält, wird als Empfänger des Ereignisses oder auch als Abonnent des Ereignisses bezeichnet.
Ereignisse in C# haben die folgenden Eigenschaften:
(1) Ereignisse sind eine Möglichkeit für Klassen, Objekte darüber zu informieren, dass sie bestimmte Vorgänge ausführen müssen;
(2) Ereignisse können jedoch auch zu anderen Zeiten auftreten (z Signalzustandsänderungen) Sehr nützlich, wird aber normalerweise in grafischen Benutzeroberflächen verwendet;
(3) Ereignisse werden normalerweise mithilfe von Delegaten-Ereignishandlern deklariert.
(4) Ereignisse können anonyme Methoden anstelle von Delegaten aufrufen.
1. Grundlegende Konzepte von Ereignissen
Das Objekt, das das Ereignis auslöst, wird als Herausgeber bezeichnet, und das Objekt, das den Ereignishandler bereitstellt, wird als Abonnent bezeichnet. In .NET Framework verwenden ereignisgesteuerte Programme Delegaten, um Ereignisse und Ereignisfunktionen zu binden. In C# ist ein Ereignis tatsächlich eine Variable vom Typ Delegat.
C# ermöglicht Ihnen die Verwendung des integrierten EventHandler-Delegatentyps zum Deklarieren eines Standardereignisses und ermöglicht Ihnen außerdem, zuerst den Delegaten anzupassen und dann das benutzerdefinierte Ereignis zu deklarieren.
In .NET Framework verfügt der integrierte EventHandler-Delegat über zwei Parameter, ihre Datentypen sind Object- bzw. EventArgs-Typen und es gibt keinen Rückgabewert.
Der Name des Objektparameters ist normalerweise sender, was den Ereignisherausgeber selbst darstellt; der Parameter EventArgs ist normalerweise e, der eine neue Instanz der System.EventArgs-Klasse an die Ereignisfunktion übergibt. Bei der tatsächlichen Programmierung ist es manchmal erforderlich, eine benutzerdefinierte Ereignisparameterklasse von der EventArgs-Klasse abzuleiten, damit der Herausgeber bestimmte Daten an die Ereignisfunktion des Empfängers senden kann.
Ereignisdeklaration
(1) Verwenden Sie den integrierten EventHandler-Delegaten, um das Ereignis (Standardereignis) zu deklarieren.
Format: öffentlicher Event EventHandler-Ereignisname;
Unter diesen wird der Ereignisname normalerweise als verwendet das Präfix.
Zum Beispiel öffentliches Ereignis EventHandler onClick;
(2) Verwenden Sie einen benutzerdefinierten Delegattyp, um das Ereignis zu deklarieren
Format: öffentlicher Delegat-Rückgabewerttyp Name des Delegattyps ([Parameter]) ;
                                                                                                                                                                                                         Name der Delegationsart; > Die Parameter
übereinstimmend. Berücksichtigen Sie beim Abonnieren von Ereignissen unbedingt die folgenden Punkte: (1) Zuerst muss die empfangende Klasse eine Methode mit derselben Signatur (gleichem Rückgabewerttyp und denselben Parametern) wie das Ereignis selbst haben, und dann muss die Die Methode (sogenanntes Ereignisverarbeitungsprogramm) kann als Reaktion auf das Ereignis geeignete Maßnahmen ergreifen.
(2) Jedes Ereignis kann mehrere Handler haben und mehrere Handler werden nacheinander aufgerufen. Wenn ein Handler eine Ausnahme auslöst, haben Handler, die noch nicht aufgerufen wurden, keine Chance, das Ereignis zu empfangen. Aus diesem Grund wird empfohlen, dass Ereignishandler Ereignisse schnell verarbeiten und das Auslösen von Ausnahmen vermeiden.
(3) Um ein Ereignis zu abonnieren, muss der Empfänger einen Delegaten desselben Typs wie das Ereignis erstellen und den Ereignishandler als Delegatenziel verwenden, außerdem unter Verwendung des
additiven Zuweisungsoperators
(+= ) Fügen Sie den Delegaten zum Ereignis des Quellobjekts hinzu. (4) Um sich von einem Ereignis abzumelden, kann der Empfänger den Subtraktionszuweisungsoperator (?=) verwenden, um den Delegaten des Ereignisses aus dem Ereignis des Quellobjekts zu entfernen.




1. Windows Forms
Windows Forms ist der Ausgangspunkt für die Erstellung fensterbasierter Anwendungen mit C#. Aus Sicht des Formulars selbst handelt es sich jedoch nur um eine bewegliche Schnittstelle. Obwohl Benutzer Objekte und Text direkt auf dem Formular zeichnen können, besteht die eigentliche Rolle des Formulars darin, als Container für Windows-Steuerelemente zu fungieren.
Der Kern des Steuerelements ist das Mitgliedsobjekt des Formulars, das zum Anzeigen von Informationen und zum Empfangen von Informationseingaben durch den Benutzer verwendet wird.




2. Windows Forms-Namespace
Die Basisklasse von Windows Forms ist Form, in der System.Windows.Forms-Namespace-Definition.
Die meisten Steuerelemente in .NET werden von der Klasse System.Windows.Forms.Control abgeleitet, die die Grundfunktionalität des Steuerelements definiert.
Formularsteuerelemente in .NET Framework
Datenanzeige DataGridView
Datenbindung und Positionierung BindingSource, BindingNavigator
Textbearbeitung TextBox, RichTextBox, MaskedTextBox
Informationsanzeige Lable, StatusStrip, ProgressBar
Webseitenanzeige WebBrowser
Liste und Auswahl CheckBox, CheckedListBox, ComboBox, RadioButton, ListBox, ListView, NumericUpDown, TreeView, DomainUpDown, TrackBar,
Grafikanzeige PictureBox, ImageList
Datumseinstellungen DatumUhrzeitAuswahl, MonatKalender
Dialog SpalteoderD ialog, FontDialog , ÖffnenDateiDialog, DruckenDialog, DruckenVorheriewDialog, FolderBrowerDialog, SaveFileDialog
Befehl Schaltfläche, LinkLabel, NichtifyIcon, ToolStrip
Menu MenuStrip, ContextMenuStrip
Benutzerhilfe HelpProvider, ToolTrip
werden andere Steuerelemente gruppieren Panel, GroupBox, TabControl, SplitContainer, TableLayoutPanel, FlowLayoutPane
Eigenschaften des Steuerelements
Eigenschaftsname Beschreibung
Anchor Die Steuerelementbindungen abrufen oder festlegen an den Rand des Containers und bestimmt, wie sich die Größe des Steuerelements mit seinem übergeordneten Element ändert.
BackColor Die Hintergrundfarbe des Steuerelements
Unten Unter dem Steuerelement Der Abstand zwischen dem Rand und dem oberen Rand des Clientbereichs seines Containers (Einheit: Pixel)
Dock Ruft den an das übergeordnete Steuerelement angedockten Steuerelementrahmen ab oder legt diesen fest und bestimmt, wie die Größe des Steuerelements geändert wird mit seinem übergeordneten Element
Aktiviert Ob das Steuerelement auf Benutzerinteraktion reagieren kann
ForeColor Die Vordergrundfarbe des Steuerelements
Höhe Die Höhe des Steuerelements
Links Der Abstand (in Pixel) zwischen dem linken Rand des Steuerelements und dem linken Rand des Clientbereichs seines Containers
Standort Die obere linke Ecke des Steuerelements relativ zu den Koordinaten der oberen linken Ecke seines Containers.
Name Der Name des Steuerelements. Dieser Name kann verwendet werden, um im Code auf das Steuerelement zu verweisen.
Übergeordnet Der übergeordnete Container des Steuerelements
Rechts Der Abstand zwischen dem rechten Rand des Steuerelements und dem linken Rand des Clientbereichs von ​​sein Container (Einheit: Pixel)
Größe Die Höhe und Breite des Steuerelements
TabIndex Die Tab-Reihenfolge des Steuerelements
TabSoben Gibt an, ob der Benutzer die Tabulatortaste verwenden kann, um den Fokus auf das Steuerelement zu legen.
Text Der diesem Steuerelement zugeordnete Text
Oben Der Abstand (in Pixel) zwischen der Oberkante des Steuerelements und der Oberkante des Clientbereichs seines Containers
Sichtbar Gibt an, ob das Steuerelement angezeigt werden soll
Breite Die Breite des Steuerelements
SchaltflächeSteuerelement
Das Button-Steuerelement (Button) befindet sich im .NET Framework System.Windows.Forms-Namespace, der von der Basisklasse ButtonBase abgeleitet ist. Die Basisklasse ButtonBase wird verwendet, um die grundlegenden Operationen zu implementieren, die für Schaltflächensteuerelemente erforderlich sind.


Die Schaltflächensteuerung ist eine häufig verwendete Steuerung, wenn Benutzer eine Auswahl wie „OK“ oder „Abbrechen“ treffen müssen. Die Schaltflächensteuerung wird normalerweise verwendet. Das Button-Steuerelement unterstützt Mausklick- und Doppelklickvorgänge und kann auch mit der 148abe006775c52e28d07bbe171fd752-Taste bedient werden.
Beim Entwerfen fügen Sie normalerweise ein Steuerelement zum Formular hinzu, doppelklicken dann darauf und schreiben Code für das Click-Ereignis. Wenn das Programm ausgeführt wird, wird durch Klicken auf die Schaltfläche der Code im Click-Ereignis ausgeführt.
Namensattribut: Wird verwendet, um den Namen des Objekts als Referenz im Code festzulegen.


Das System benennt das Button-Steuerelement automatisch button1, button2...
Am besten legen Sie einen aussagekräftigen Namen für die Name-Eigenschaft fest.
Die Eigenschaft „Name“ verschiedener Steuerobjekte kann nur über das Fenster „Eigenschaften“ geändert werden. Diese Eigenschaft ist zur Entwurfszeit gültig und zur Laufzeit schreibgeschützt.
Textattribut: Der Titeltext, der auf der Schaltfläche in Textform angezeigt wird.
Zusätzlich zum Klicken auf die Schaltfläche können Sie auch „Alt + Tastenkombination“ für die Schaltfläche definieren, siehe Abbildung 7-2 auf P155.
Definieren Sie die Methode, indem Sie vor dem Tastenkombinationsbuchstaben ein „&“-Zeichen hinzufügen.
Zum Beispiel: button1.Text = "OK (&Y)" //Der Anzeigetitel ist "OK (Y)"


Sichtbares Attribut: bestimmt, ob die Schaltfläche sichtbar ist
Der Attributwert ist „true“, um sichtbar zu sein, und „false“, um auszublenden.


Wenn ein Steuerelement unsichtbar ist, kann es nicht auf die Maus- und Tastaturoperationen des Benutzers reagieren.
Die Visible-Eigenschaft wird zur Laufzeit wirksam.


Aktiviertes Attribut: bestimmt, ob die Schaltfläche gültig ist
Wenn der Attributwert falsch ist, wird der Schaltflächentext grau angezeigt und reagiert nicht auf Benutzervorgänge.

FlatStyle-Attribut: Bestimmt den Stil der Schaltfläche, der Wert ist der FlatStyle-Aufzählungstyp
Der FlatStyle-Aufzählungstyp hat 4 Aufzählungswerte, nämlich Flat (flache Anzeige), Popup (flache Anzeige, aber die Maus) das Erscheinungsbild ist dreidimensional), Standard (dreidimensionale Anzeige) und System (das Erscheinungsbild wird durch das Betriebssystem bestimmt). Der Effekt ist in Abbildung 7-3 auf P156 dargestellt.
Die FlatStyle-Eigenschaft des Button-Steuerelements ist standardmäßig auf Standard eingestellt.
Bildeigenschaft: Geben Sie ein Bild an, das auf der Schaltfläche angezeigt werden soll
ImageAlign-Eigenschaft: Legen Sie die Ausrichtung des Bildes auf der Schaltfläche fest
Label-Steuerelement
Funktion: Wird hauptsächlich zum Anzeigen von Text auf dem Formular verwendet
Steuerelementname:
Label: Standard-Windows-Label;
LinkLabel: ähnlich wie Label, aber angezeigt in Form eines Hyperlinks. Der Effekt ist in Abbildung 7-4 dargestellt.
Im Allgemeinen ist es nicht erforderlich, Ereignisbehandlungscode zum Label-Steuerelement hinzuzufügen, aber Ereignisse können bei Bedarf auch unterstützt werden
Allgemeine Eigenschaften von Label-Steuerelementen
Eigenschaftsname Beschreibung
BorderStyle Der Rahmenstil des Steuerelements, der Standardwert ist randlos
FlatStyle Legen Sie das Erscheinungsbild des flachen Stils fest. Bei der Einstellung „PopUp“ bedeutet dies einen flachen Stil. Wenn die Maus darauf zeigt, wird das Steuerelement im Popup-Stil angezeigt.
Bild Das auf dem Etikett angezeigte Bild
ImageAlign Die Ausrichtung des im Steuerelement angezeigten Bildes
LinkArea Der Text, der als angezeigt wird Linkbereich (nur für LinkLabel)
LinkColor Die Farbe, die bei der Anzeige gewöhnlicher Links verwendet wird (nur für LinkLabel)
Links Ruft die Sammlung der im LinkLabel enthaltenen Links ab ( Nur für LinkLabel)
LinkVisited Ob der Link als besuchter Link erscheint (nur für LinkLabel)
TextAlign? Ausrichtung des Textes im Label
VisitedLinkColor Die Farbe, die beim Anzeigen zuvor besuchter Links verwendet wird (nur für LinkLabel)
Textfeld-Steuerelement
.NET FrameWork verfügt über zwei integrierte Textfeld-Steuerelemente: TextBox-Steuerelement und RichTextBox-Steuerelement. Sie sind alle von TextBoxBase abgeleitet. die von der Control-Klasse abgeleitet ist.
TextBoxBase bietet grundlegende Funktionen zum Verarbeiten von Text in Textfeldern, z. B. Textauswahl, Ausschneiden und Einfügen sowie zugehörige Ereignisse. Der Hauptzweck von
TextBox besteht darin, Benutzern die Eingabe von Text zu ermöglichen. Sie können auch die Art der vom Benutzer eingegebenen Zeichen angeben, z. B. nur numerische Werte zulassen. Standardmäßig kann ein Textfeld bis zu 2048 Zeichen eingeben. Wenn Sie die Multiline-Eigenschaft auf true setzen, können Sie bis zu 32 KB Text eingeben. Benutzertext wird in der Text-Eigenschaft gespeichert, und der vom Benutzer eingegebene Text kann durch Verweisen auf die Text-Eigenschaft im Programm abgerufen werden. RichTextBox wird hauptsächlich zum Anzeigen und Eingeben von formatiertem Text verwendet (TextBox wird häufig zum Eingeben kürzerer Textzeichen verwendet, kann Text aus Dateien laden und eingebettete Bilder laden und wird auch als RichTextBox bezeichnet). ein erweitertes Textfeld.


TextBox-Steuerelement
Eigenschaftsname Beschreibung
UrsachenValidierung? Ob die Gültigkeit der Benutzereingabe überprüft werden soll
CharacterCasing Ob das Groß-/Kleinschreibungformat der Zeichen bei der Eingabe geändert werden soll
MaxLength? Legen Sie die maximale Anzahl der Zeichen fest, die eingegeben werden können. Wenn =0, gibt es keine Begrenzung
Mehrzeilig Ist es möglich? Mehrzeiligen Text anzeigen
PasswordChar Passwort-Anzeigezeichen festlegen
ReadOnly? Ob der Text schreibgeschützt ist
ScrollBars Ermitteln oder festlegen, welche Bildlaufleisten in einem mehrzeiligen TextBox-Steuerelement angezeigt werden sollen
SelectedText? Stellt den aktuell ausgewählten Text dar
SelectionLength? Die aktuelle Anzahl der Zeichen selected
SelectionStart? Der Startpunkt des aktuell ausgewählten Textes
Text Aktueller Text
WordWrap? Ob automatisch umbrechen
Ereignisname Beschreibung
Eingabe? Tritt beim Betreten des Steuerelements aufDiese 4 Ereignisse werden in der aufgeführten Reihenfolge ausgelöst, sie werden aufgerufen „Fokusereignisse“, wenn sich der Fokus des Steuerelements ändert, werden ausgelöst, Validating und Validated werden jedoch nur ausgelöst, wenn das Steuerelement den Fokus erhält und seine CausesValidation auf true
Leave? Tritt auf, wenn der Eingabefokus das Steuerelement verlässtValidierung?
Tritt auf, während das Steuerelement validiert wirdValidiert?
Tritt auf, wenn das Steuerelement die Validierung abschließt
KeyDown Diese drei Ereignisse werden zusammenfassend als „Tastenereignisse“ bezeichnet und dienen zur Überwachung und Änderung des in das Steuerelement eingegebenen Tastencodes, der der gedrückten Taste entspricht kann verwendet werden, um festzustellen, ob eine Sondertaste gedrückt wird, z. B. Umschalt, Strg oder F1. KeyPress empfängt die der Taste entsprechenden ZeichenKeyPress
KeyUp?
TextChanged?
Solange sich der Text im Textfeld ändert, wird dieses Ereignis ausgelöst RichTextBox-Steuerelement
Attributname
Beschreibung CanRedo?
Gibt an, ob es unter den Vorgängen, die innerhalb der RichTextBox ausgeführt wurden, Vorgänge gibt, die erneut angewendet werden können CanUndo?
Zeigt an, dass sich der Benutzer im Text befindet. Kann der vorherige Vorgang im Box-Steuerelement rückgängig gemacht werden? DetectUrls
Wenn eine URL in das Steuerelement eingegeben wird, stellt die RichTextBox automatisch das Format der URL fest Rtf
Ist dasselbe wie die Text-Eigenschaft? Ähnlich, kann aber Text im RTF-Format enthalten SelectedRtf
Den formatierten Text im aktuell im Steuerelement ausgewählten RTF-Format abrufen oder festlegen SelectedText
Auswahl in der RichTextBox abrufen oder festlegen. Text definierenSelectionAlignment
Ausrichtung des ausgewählten Inhalts oder Einfügepunkts, kann zentriert, links oder rechts seinSelectionBullet?
Gibt an, ob der Aufzählungsstil auf die aktuelle Auswahl oder den Einfügepunkt angewendet wirdBulletIndent?
Gibt den Einzugspixelwert des Aufzählungszeichens anSelectionColor
Gets oder legt die Textfarbe des aktuell ausgewählten Texts oder der Einfügemarke festSelectionFont
Ruft die Schriftart des aktuell ausgewählten Texts oder der Einfügemarke ab oder legt sie festSelectionLength?
Ruft ab oder legt sie fest die Anzahl der im Steuerelement ausgewählten ZeichenShowSelection
Margin Wenn Sie dieses Attribut auf true setzen, wird auf der linken Seite der RichTextBox ein Rand angezeigt, um die Textauswahl zu erleichternUndo
ActionName Get call Der Name des rückgängig zu machenden Vorgangs im Steuerelement nach der Undo-Methode SelectionProtected
Setzen Sie diese Eigenschaft auf true, um das bestimmte anzugeben Teile des Textes dürfen nicht geändert werden RadioButton-Steuerelement
Eigenschaftsname
BeschreibungAussehen Ruft einen Wert ab oder legt diesen fest, der das Erscheinungsbild des RadioButtons bestimmt.
Optionale Werte: Normal und Button. Jeder Typ kann Text oder Bilder oder beides anzeigen.
Darstellung nach Auswahl von Normal: . Darstellung nach Auswahl der Schaltfläche:
AutoCheck Wenn dieses Attribut wahr ist und der Benutzer auf das Optionsfeld klickt, wird ein Häkchen angezeigt. Wenn diese Eigenschaft falsch ist, müssen Sie das Optionsfeld
CheckAlign im Code des Click-Ereignishandlers manuell überprüfen, um die Ausrichtungsform des Kontrollkästchens des Optionsfelds, den Wert, zu ändern Kann einer der gültigen Werte der ContentAlignment-Enumeration sein. Der Standardwert ist MiddleLeft, was bedeutet, dass der Inhalt in der Mitte vertikal und linksbündig horizontal ausgerichtet ist.
Überprüft Ruft einen Wert ab oder legt diesen fest, der angibt, ob das Steuerelement ausgewählt wurde. Wenn das Steuerelement ausgewählt ist, ist es wahr, andernfalls ist es falsch
GroupBox-Steuerelement
Das GroupBox-Steuerelement (Gruppenfeld) wird verwendet, um identifizierbare Gruppierungen für andere Steuerelemente bereitzustellen. Normalerweise verwenden Sie Gruppenfelder, um Ihr Formular nach Funktion zu unterteilen.
Wenn ein einzelnes GroupBox-Steuerelement verschoben wird, werden auch alle darin enthaltenen Steuerelemente gemeinsam verschoben.
Wenn Sie ein GroupBox-Steuerelement und seine internen Steuerelemente in einem Formular erstellen, müssen Sie zuerst das GroupBox-Steuerelement und dann verschiedene darin enthaltene Steuerelemente erstellen.
Panel-Steuerung
Die Panel-(Panel-)Steuerung ähnelt der GroupBox-Steuerung. Der Unterschied zwischen den beiden besteht darin, dass nur das GroupBox-Steuerelement einen Titel anzeigen kann und nur das Panel-Steuerelement über Bildlaufleisten verfügen kann.
Um Bildlaufleisten anzuzeigen, setzen Sie die AutoScroll-Eigenschaft auf true.
Sie können das Erscheinungsbild des Panels anpassen, indem Sie die Eigenschaften BackColor, BackgroundImage und BorderStyle festlegen.
TabControl-Steuerelement
Eigenschaftsname Beschreibung
Ausrichtung Steuern Sie die Anzeigeposition der Registerkarte im Steuerelement, die Standardeinstellung ist die Oberseite des Steuerelements
Aussehen Steuern Sie, wie Registerkarten als normale Schaltflächen oder mit flachen Stilen angezeigt werden können.
HotTrack Wenn „true“, wenn sich der Mauszeiger über die Registerkarte auf dem Steuerelement bewegt, wird dessen Darstellung angezeigt ändert sich
Mehrzeilig Wenn wahr, können Tabs in mehreren Zeilen angezeigt werden
ZeileAnzahl Gibt die aktuell angezeigte Tab-Anzahl der Zeilen zurück
SelectedItem Ruft den Index der aktuell ausgewählten Tab-Seite ab oder legt diesen fest.
SelectedTab Ruft die aktuell ausgewählte Tab-Seite ab oder legt diesen fest. Diese Eigenschaft befindet sich in TabPages. Verwenden Sie
TabCount auf der Instanz, um die Anzahl der Tabs im Tabstrip zu erhalten.
TabPages Rufen Sie die Sammlung von Registerkartenseiten im Tab-Steuerelement ab. Verwenden Sie diese Sammlung, um TabPages-Objekte hinzuzufügen und zu löschen.


StatusStrip-Gemeinsame Eigenschaften von Bereichen im Steuerelement
Eigenschaftsname Beschreibung
AutoSize Ob die Größe des Elements basierend auf dem Bild und dem Text des Elements automatisch angepasst werden soll
Ausrichtung Legen Sie den oberen Bereich von fest Für die Ausrichtung des StatusStrip-Steuerelements stehen folgende Optionen zur Verfügung: Center, Left und Right
BorderStyle Legen Sie den Stil des Bereichsrands fest. Die Optionen lauten wie folgt:
Keine: Der Rand wird nicht angezeigt : Der Bereich ist in drei Dimensionen konvex. Versenkt: Der Bereich wird in einem dreidimensionalen erhabenen Modus angezeigt.
Bild Legen Sie das vom Bereich angezeigte Symbol fest.
Minimale Größe Einstellen das Symbol des Bereichs in der Statusleiste Mindestbreite
Spring Ob das angegebene Element den verbleibenden Raum ausfüllt
Text Legen Sie den angezeigten Text des Bereichs fest
Breite Legen Sie die Breite des Bereichs fest. Abhängig von der Einstellung der AutoSize-Eigenschaft kann sich der Eigenschaftswert ändern, wenn sich die Formulargröße ändert.


Die Show-Methode gibt einen DialogResult-Enumerationswert zurück, der angibt Rückgabewert des Dialogfelds
Mitglied Beschreibung
Abort Der Rückgabewert des Dialogfelds ist Abort (wird normalerweise von der Schaltfläche mit der Bezeichnung „Abort“ gesendet)?
Abbrechen Dialog Der Rückgabewert des Felds ist „Abbrechen“ (wird normalerweise über die Schaltfläche „Abbrechen“ gesendet).
Ignorieren Der Rückgabewert des Dialogfelds ist „Ignorieren“ (wird normalerweise gesendet von der Schaltfläche mit der Bezeichnung „Ignorieren“)?
Nein Der Rückgabewert des Dialogs ist „Nein“ (normalerweise gesendet von der Schaltfläche mit der Bezeichnung „Nein“)?
Keine hat „Nichts“ aus dem Dialog zurückgegeben. Dies zeigt an, dass der modale Dialog weiterhin ausgeführt wird?
OK Der Rückgabewert des Dialogs ist OK (normalerweise wird er von einer Schaltfläche mit der Bezeichnung „OK“ gesendet)?
Wiederholen Dialog Der Rückgabewert des Felds ist „Wiederholen“ (wird normalerweise von der Schaltfläche mit der Bezeichnung „Wiederholen“ gesendet).
Ja Der Rückgabewert des Dialogfelds ist „Ja“ (wird normalerweise von der Schaltfläche mit der Bezeichnung „Ja“ gesendet). )?


Driver
.NET Framework stellt die Klasse DriveInfo und den Aufzählungstyp DriverType bereit, um die direkte Verwendung von Laufwerken in Programmen zu erleichtern. Die DriveInfo-Klasse und die DriverType-Enumeration befinden sich im System.IO-Namespace.
DriveInfo-Klasse
Rolle: Informationen über das Laufwerk ermitteln, einschließlich Laufwerksbuchstabe, Laufwerkstyp, verfügbarer Speicherplatz auf dem Laufwerk usw.
Gemeinsame Mitglieder:
Feld: DriveFormat ( Dateisystem Format wie NTFS oder FAT32), DriveType (Laufwerkstyp), Name (Laufwerksname), TotalSize (Gesamtspeicherplatz), TotalFreeSpace (verfügbarer Speicherplatz)
Methode: GetDrives (Liste abrufen). der verfügbaren Laufwerke)
perType-Aufzählungstyp
Zu den Aufzählungswerten gehören CD-ROM (optisches Laufwerk), fest (Festplatte), Netzwerk (Netzwerklaufwerk), entfernbar (Diskette oder U-Disk) usw.
Directory
bereitgestellt von .NET FrameworkDirectory-Klasse und DirectoryInfo-Klasse, um die direkte Bearbeitung von Verzeichnissen im Programm zu erleichtern. Die Directory-Klasse und die DirectoryInfo-Klasse befinden sich im System.IO-Namespace und können zum Erstellen, Kopieren, Verschieben oder Löschen von Verzeichnissen verwendet werden.
Verzeichnisklasse
Funktionen: Statische Klasse, ihre Methodenmitglieder können direkt aufgerufen werden, aber jeder Aufruf von Methodenmitgliedern muss eine Sicherheitsüberprüfung durchführen, um die Betriebsberechtigungen des Benutzers zu ermitteln.
Gemeinsame Methodenmitglieder: CreateDirectory (ein neues Verzeichnis erstellen), Delete (das Verzeichnis löschen), Exists (bestimmen, ob das Verzeichnis vorhanden ist), Move (das Verzeichnis verschieben), GetFiles (die Dateiliste abrufen). des Verzeichnisses), GetDirectories (Liste der Unterverzeichnisse abrufen) usw.
DirectoryInfo-Klasse
Funktionen: nicht statische Klasse (muss instanziiert werden), eine Instanz muss erstellt werden, bevor ihre Methodenmitglieder aufgerufen werden können, Beim Erstellen einer Instanz werden Sicherheitsüberprüfungen durchgeführt.
Gemeinsame Feldmitglieder; Name (Name des Extrahierungsverzeichnisses), Exists (ob vorhanden), Parent (übergeordnetes Verzeichnis), Root (Stammverzeichnis)
Gemeinsame Methodenmitglieder: Create (Verzeichnis erstellen), CreateSubDirectory (Unterverzeichnis erstellen) , Delete (Verzeichnis löschen), MoveTO (Verzeichnis verschieben), GetFiles, GetDirectories usw.
Codebeispiel: P197
File
NET Framework stellt die File-Klasse und die FileInfo-Klasse bereit Erleichtern Sie dem Programm die direkte Bearbeitung von Dateien. Die File-Klasse und die FileInfo-Klasse befinden sich im System.IO-Namespace und können zum Erstellen, Kopieren, Löschen, Verschieben, Öffnen von Dateien und für andere Vorgänge verwendet werden.
Dateiklasse
Eigenschaften: Statische Klasse, ihre Methodenmitglieder können direkt aufgerufen werden.
Gemeinsame Methodenmitglieder: Open (eine Datei öffnen), Create (eine neue Datei erstellen), Copy (eine Datei kopieren), Delete (eine Datei löschen), Exists (bestimmen, ob eine Datei vorhanden ist), Move (eine Datei verschieben). ), Ersetzen (eine Datei ersetzen) ), AppendAllText (eine neue Datei erstellen und Text hinzufügen), ReadAllText (Textinhalt öffnen und lesen) usw.
FileInfo-Klasse
Funktionen: Nicht statische Klasse, Sie müssen zuerst eine Instanz erstellen.
Gemeinsame Feldmitglieder: Name (Name der extrahierten Datei), Verzeichnis (Verzeichnis, zu dem sie gehört), Exists (ob sie existiert), Erweiterung (Dateierweiterung), Länge (Dateilänge), IsReadOnly (ob es sich um eine Lesedatei handelt) nur Datei)
Gemeinsame Methodenmitglieder: Öffnen, Erstellen, CopyTo (in neue Datei kopieren), Löschen, MoveTo (Datei verschieben), Ersetzen, EnCrypt (Datei verschlüsseln), Decrypt (Datei entschlüsseln) , usw.
Codebeispiel: P198
Pfad
Der Speicherort der Datei wird als Pfad bezeichnet. Der Pfad besteht aus dem Laufwerksbuchstaben, dem Verzeichnisnamen, dem Dateinamen, der Dateierweiterung und dem Trennzeichen.
So drücken Sie den Pfad aus
Absoluter Pfad: Beginnen Sie mit dem Schreiben im Stammverzeichnis des Laufwerks, z. B. C:WindowsSystem32notepad.exe
Relativer Pfad: Beginnen Sie mit dem Schreiben im aktuellen Verzeichnisspeicherort, z. B. System32nodepad.exe (vorausgesetzt, das aktuelle Verzeichnis ist C:Windows)
C# behandelt das Zeichen „“ als Escape-Zeichen. Wenn der Pfad als Zeichenfolge ausgedrückt wird, verwenden Sie also zwei Backslashes, zum Beispiel:
“C:\Windows\ System32\notepad.exe"
C# ermöglicht das Hinzufügen des „@“-Zeichens vor einer Zeichenfolge, um den Compiler aufzufordern, das Zeichen „“ nicht als Escape-Zeichen, sondern als gewöhnliches Zeichen zu behandeln, zum Beispiel:
@“C :WindowsSystem32notepad.exe ”
NET Framework stellt die Path-Klasse bereit, um die Verwaltung von Datei- und Verzeichnispfaden in Programmen zu unterstützen. Die Path-Klasse befindet sich im System.IO-Namespace und ist eine statische Klasse.
Pfadklassenfunktion: Statische Klasse, die zum Bedienen jedes Felds des Pfads verwendet wird, z. B. Laufwerksbuchstabe, Verzeichnisname, Dateiname, Dateierweiterung und Trennzeichen usw.
Gemeinsame Pfad-Feldmitglieder: PathSeparator (Pfadtrennzeichen), DirectorySeparatorChar (Verzeichnistrennzeichen), VolumeSeparatorChar (Volume-Trennzeichen)
Gemeinsame Pfad-Methodenmitglieder: GetDirecotryName (Verzeichnisnamen abrufen), GetFileName (Dateinamen abrufen), GetExtension (Dateierweiterung abrufen) , GetFullPath (den vollständigen Pfad abrufen), GetTempPath (den temporären Dateipfad des Betriebssystems abrufen) usw. Der


-Ablauf umfasst die folgenden grundlegenden Vorgänge.
Lesen (Lesen): bedeutet das Übertragen von Daten aus einem Stream in eine bestimmte Datenstruktur, z. B. die Ausgabe in ein Byte-Array.
Schreiben (Schreiben): bedeutet das Übertragen von Daten aus einer bestimmten Datenstruktur in einen Stream , Daten in einem Byte-Array an einen Stream übertragen
Positionierung (Suche): bedeutet Abfrage oder Verschiebung der aktuellen Position im Stream.
Klassen zum Betreiben von Streams
(1) Stream-Klasse
Die Stream-Klasse ist die abstrakte Basisklasse für alle Streams.
Hauptattribute der Stream-Klasse: CanRead (ob Lesen angezeigt wird), CanSeek (ob Suche unterstützt wird), CanTimeout (ob Timeout möglich ist), CanWrite (ob Schreiben unterstützt wird), Length (Länge des Streams), Position (Position im aktuellen Stream abrufen oder festlegen), ReadTimeout (Timeout für den Lesevorgang abrufen oder festlegen), WriteTimeout (Timeout für den Schreibvorgang abrufen oder festlegen)
Die Hauptmethode der Stream-Klasse: BeginRead (asynchronen Lesevorgang starten), BeginWrite (asynchronen Schreibvorgang starten), Close (aktuellen Stream schließen), EndRead (asynchronen Lesevorgang beenden), EndWrite (asynchronen Schreibvorgang beenden), Flush (alle Puffer des Streams löschen und die gepufferten Daten auf das Basisgerät schreiben), Read (eine Bytesequenz lesen), ReadByte (ein Byte lesen), Seek (die Suchposition festlegen), Write (eine Bytesequenz schreiben) , WriteByte (einen Wortabschnitt schreiben)
(2) StreamReader- und StreamWriter-Klassen
Wird im Allgemeinen zum Betreiben von Textdateien verwendet
Die StreamReader-Klasse StreamReader wird zum Lesen von Zeichen aus einem Byte-Stream in einer bestimmten Codierung verwendet.
Die StreamWriter-Klasse wird verwendet, um Zeichen in einer bestimmten Codierung in einen Stream zu schreiben.
(3) FileStream-, MemoryStream- und BufferStream-Klassen
Dateistream FileStream-Klasse: Dateien in Form von Streams lesen, schreiben, öffnen und schließen.
MemoryStream-Klasse: Gibt an, dass ein Stream im Speicher erstellt wird, um Daten vorübergehend zu speichern. Damit ist es nicht erforderlich, temporäre Dateien auf der Festplatte zu erstellen.
CacheStream BufferStream-Klasse: Fügen Sie den Stream zuerst zum Puffer hinzu und führen Sie dann Lese-/Schreibvorgänge durch. Durch die Verwendung des Puffers kann die Anzahl der Aufrufe an das Betriebssystem beim Zugriff auf Daten reduziert werden.
Beachten Sie, dass die FileStream-Klasse auch über eine Pufferfunktion verfügt. Beim Erstellen einer Instanz der FileStream-Klasse müssen Sie nur die Puffergröße angeben.
Textdateien lesen und schreiben
Eine Textdatei ist eine Datei, die aus reinen Textdaten besteht und nur die Kodierung von Zeichen speichert.
Die von NET Framework unterstützte Zeichenkodierung
kann ASCIIEncoding, UTF7Encoding, UTF8Encoding, UnicodeEncoding oder UTF32Encoding sein.
Das Lesen und Schreiben von Textdateien in .NET Framework verwendet hauptsächlich:
Dateileser TextReader-Klasse und Textschreiber TextWriter Klasse
und ihre abgeleiteten Klassen, Stream Reader StreamReader-Klasse und Stream Writer StreamWriter-Klasse
oder StringReader- und StringWriter-Klassen
Gemeinsame Methoden der TextReader-Klasse und ihrer abgeleiteten Klassen:
Schließen (Leser schließen und Systemressourcen freigeben ), Read (lesen Sie das nächste Zeichen, wenn es nicht existiert, geben Sie -1 zurück), ReadBlock (lesen Sie einen Block von Zeichen), ReadLine (lesen Sie eine Zeile von Zeichen), ReadToEnd (lesen Sie von der aktuellen Position bis zu allen Zeichen bis zum Ende)
Gemeinsame Methoden der TextWriter-Klasse und ihrer abgeleiteten Klassen:
Close (Schließen Sie den Writer und geben Sie Systemressourcen frei), Flush (löschen Sie alle Puffer des aktuellen Writers, sodass alle gepufferten Daten in die Basis geschrieben werden Device), Write (Textstrom schreiben), WriteLine (eine Datenzeile schreiben)
ASP.NETEinführung
ASP.NET ist eine dynamische Webdesign-Technologie, die besser ist als alle anderen Dynamische Webdesign-Technik ist einfacher zu verwenden. Es handelt sich um eine skalierbare Webanwendungsentwicklungstechnologie, die sich besonders gut für die Benutzerinteraktion und Datenverarbeitung eignet.
ASP.NET ist keine Programmiersprache, sondern ein Programmierframework, das auf dem .NET Framework basiert. Es wird zum Erstellen von Webanwendungen verwendet.
Die Syntax von ASP.NET ist mit ASP kompatibel, ASP-Anwendungen können jedoch nicht direkt in der ASP.NET-Umgebung ausgeführt werden und müssen entsprechend geändert werden.
Der größte Unterschied zwischen ASP.NET und ASP besteht darin, dass es sich bei ersterem um eine kompilierte dynamische Webseitentechnologie handelt, während es sich bei letzterem um eine interpretierte dynamische Webseitentechnologie handelt.
Die beliebtesten Versionen von ASP.NET sind Version 1.1, Version 2.0 und Version 3.0. ASP.NET, das mit Visual Studio.NET 2003 veröffentlicht wurde, ist Version 1.1, und ASP.NET, das mit Visual Studio.NET 2005 veröffentlicht wurde, ist Version 2.0. ASP.NET, 2007 mit Visual Studio.NET 2008 veröffentlicht, ist Version 3.0.
Vorteile von ASP.NET
Gute Verwaltbarkeit
Hohe Sicherheit
Einfache Bereitstellung
Die Leistung ist im Vergleich zu ASP und JSP erheblich verbessert
Flexible Ausgabe-Caching-Technologie
Durch die Unicode-Kodierung wird eine Internationalisierung erreicht.
Unterstützt mobile Geräte
Gute Skalierbarkeit und Benutzerfreundlichkeit
Bietet Tracking-Dienste und DebuggingFunktionen
In .NET Framework integriert, leistungsstarke Funktionen
Datenbank Verbindung verwendet ADO.NET-Technologie
Allgemeine Schritte zum Entwerfen einer Webanwendung
Vorgangsschritte zum Entwerfen einer Webanwendung mit VS 2005
S1: Erstellen Sie eine neue Website
S2: Legen Sie den Standort der Website fest
S3: Webseiten hinzufügen
S4: Webformulare entwerfen
S5: Eigenschaften von Formularen und Formularsteuerelementen festlegen
S6: Programme schreiben
S7: Webanwendungen ausführen
S8: Laufergebnisse anzeigen
Hinweis: Einzelheiten finden Sie im Lehrbuch
(1) Webanwendung generieren
Vorgehensweise: Klicken Sie im Projektmappen-Explorer-Fenster von Visual Studio .NET 2005 mit der rechten Maustaste auf den Namen der Website und wählen Sie „Website generieren“. ”
(2) Überprüfen Sie, ob der Webserver normal ist.
Wenn Sie auf dem lokalen Computer veröffentlichen möchten, müssen Sie überprüfen, ob der lokale Computer installiert istIIS
Überprüfen Sie, ob IIS installiert ist ordnungsgemäß funktionieren


Tabellen, Datensätze und Felder
Relationale Datenbanksysteme verwenden das relationale Modell als Methode zum Organisieren von Daten.
Tabelle ist eine Gruppe ähnlicher Daten, die in einer gemeinsamen Struktur gespeichert sind, ähnlich der Tabelle im täglichen Leben.
Tabellen ordnen zusammengehörige Informationen in logischen Gruppen in Zeilen und Spalten. Jede Zeile in der Tabelle wird als Datensatz bezeichnet.
Spalten werden Felder genannt
Datenbank
Datenbank stellt eine Datentabelle als Sammlung mehrerer Tabellen dar und definiert die Struktur der Datenbank durch Herstellen von Beziehungen zwischen Tabellen
Der sogenannte Primärschlüssel bezieht sich auf die Eindeutige Identifikation der Tabelle. Ein Feld oder eine Reihe von Feldern in einem Datensatz. Primärschlüssel erlauben keine doppelten Werte.
Fremdschlüssel bezieht sich auf ein Feld, das zum Verbinden einer anderen Tabelle verwendet wird und als Primärschlüssel in einer anderen Tabelle dient.
Index
In relationalen Datenbanken werden Indizes häufig verwendet, um die Geschwindigkeit des Datenabrufs zu verbessern.
Datensätze werden in der physischen Reihenfolge der Eingabe in der Tabelle gespeichert. Bei der Indizierung des Primärschlüssels oder anderer Felder zeichnet das Datenbankverwaltungssystem den Inhalt der Indexfelder in einer bestimmten Reihenfolge auf.
Beim Abrufen von Daten ermittelt das Datenbankverwaltungssystem zunächst den Speicherort der Informationen aus der Indexdatei und liest dann die Daten aus der Tabelle.
Jeder Index verfügt über einen Indexausdruck, um die Reihenfolge des Indexes zu bestimmen. Der Indexausdruck kann entweder ein Feld oder eine Kombination mehrerer Felder sein.
Für eine Tabelle können mehrere Indizes generiert werden, und jeder Index stellt eine Folge von Verarbeitungsdaten dar.
Beziehung
Der größte Vorteil einer relationalen Datenbank besteht darin, dass sie unnötige Duplikate von Daten vermeiden kann, das heißt, sie kann eine Tabelle mit doppelten Daten in mehrere einfache Tabellen ohne doppelte Daten aufteilen und Beziehungen zwischen Tabellen herstellen um Datensätze in zugehörigen Tabellen abzurufen.
In der Beziehung zwischen Tabellen ist es üblich, die Haupttabelle als übergeordnete Tabelle zu bezeichnen, und andere durch die Beziehung verbundene Tabellen sind untergeordnete Tabellen.
Es kann 4 Arten von Beziehungen zwischen Tabellen geben
Eins-zu-eins-Beziehung: bedeutet, dass ein Datensatz in der übergeordneten Tabelle höchstens mit einem Datensatz in der untergeordneten Tabelle übereinstimmen kann und umgekehrt;
Eins -zu-viele-Beziehung: Bezieht sich auf die Datensätze in der übergeordneten Tabelle, die mit mehreren Datensätzen in der untergeordneten Tabelle verknüpft sind. Beispielsweise bezieht sich bei der Kundentabelle und der Bestelltabelle jede Bestellung nur auf einen Kunden, und jeder Kunde kann mehrere Bestellungen haben, sodass die Kundentabelle und die Bestelltabelle eine Eins-zu-Viele-Beziehung haben -zu-eins-Beziehung: Komplementär zu eins-zu-vielen, das heißt, mehrere Datensätze in der übergeordneten Tabelle beziehen sich auf einen Datensatz in der untergeordneten Tabelle.
Viele-zu-viele-Beziehung: bezieht sich auf mehrere Datensätze in der übergeordneten Tabelle Tabelle und mehrere Datensätze in der untergeordneten Tabelle verknüpft.
SQL-Einführung
SQL (Structured Query
Language) ist eine umfassende und allgemeine relationale Datenbanksprache, deren Funktionen Abfrage, Manipulation, Definition und Steuerung umfassen. Derzeit gibt es 3 Versionen des SQL-Standards.
SQL-89
SQL-92
SQL3
Transact-SQL, das von Microsoft SQL Server verwendet wird, ist eine Erweiterung des SQL-92-Standards.
Zusammensetzung von SQL
SQL besteht aus Elementen wie Befehlen, Klauseln und Operatoren, die zu Anweisungen zum Erstellen,
Aktualisieren und Bearbeiten von Daten kombiniert werden. SQL-Befehle sind in zwei Kategorien unterteilt: DDL-Befehle (Data Definition Language) und DML-Befehle (Data Manipulation Language). DDL-Befehle werden zum Erstellen und Definieren neuer Datenbanken, Felder und Indizes verwendet und umfassen hauptsächlich die Anweisungen: create, drop, alter. DML-Befehle werden zum Erstellen von Abfragen zum Sortieren, Filtern und Extrahieren von Daten aus der Datenbank verwendet. Sie umfassen hauptsächlich Anweisungen: Auswählen, Einfügen, Aktualisieren und Löschen. P258
SQL-Klauseln werden verwendet, um die Daten zu definieren, die ausgewählt oder manipuliert werden sollen.


select-Anweisung Die Funktion der
select-Anweisung besteht darin, Daten aus einer vorhandenen Datenbank abzurufen.

from-Klausel gibt die Quelle der Daten an, d. h., sie gibt an, aus welchen Tabellen die Datensätze stammen.
Where-Klausel gibt die Bedingungen an, die bei der Auswahl von Datensätzen erfüllt werden müssen. Die Group By-Klausel gruppiert Datensätze.
Die Have-Klausel bestimmt, welche Datensätze in der Abfrage mit der Group-by-Klausel speziell angezeigt werden. Mit der Have-Klausel können Sie Gruppen anzeigen, die die angegebenen Bedingungen erfüllen.
Die Order by-Klausel sortiert Datensätze. Ein Beispiel für die
-Anweisung finden Sie unter P258-260
delete-Anweisung. Die Funktion der
delete-Anweisung besteht darin, Datensätze in einer oder mehreren Tabellen zu löschen, die in der from-Klausel aufgeführt sind und die Bedingungen der where erfüllen Klausel.
Zum Beispiel:
löschen aus Bestellungen, bei denen OrderId=16 ist
Einfügeanweisung
Einfügeanweisung wird verwendet, um Datensätze zur Tabelle hinzuzufügen.
Zum Beispiel:
in Bestellungen einfügen
(CustID,ProductID,OrderDate,SendDate,Menge)
values('2','5','2008-8-12','2008- 8 -13',1)
Update-Anweisung
Update-Anweisung aktualisiert Feldwerte in einer bestimmten Tabelle gemäß einer bestimmten Bedingung.
Zum Beispiel:
update Products set Price=8900 where Products.ProductId=3
ADO.Net Overview
ADO.NET ist Microsofts neueste und leistungsstärkste Datenbankzugriffstechnologie. Anwendungen können ADO.NET verwenden Einfach auf Daten zugreifen und diese verarbeiten, die in verschiedenen Datenbanken gespeichert sind.
ADO.NET umfasst viele Klassen für die Datenverarbeitung. Diese Klassen verfügen über leistungsstarke Datenzugriffs- und -verarbeitungsfunktionen wie Indizierung, Sortierung, Durchsuchen und Aktualisieren.
ADO.NET ist in das .NET Framework integriert und kann in jeder Computersprache verwendet werden, die .NET unterstützt, wie z. B. C#.
ADO.NET umfasst hauptsächlich den System.Data-Namespace und seine verschachtelten Namespaces sowie einige spezielle Klassen im Zusammenhang mit dem Datenzugriff, wie z. B. den System.Xml-Namespace.
Data Provider
Data Provider stellt die Verbindung zwischen DataSet und Datenbank her und beinhaltet außerdem eine Reihe von Schnittstellen für den Zugriff auf die Datenbank. Über von Datenanbietern bereitgestellte Anwendungsprogrammierschnittstellen (API) kann problemlos auf Daten aus verschiedenen Datenquellen zugegriffen werden.
.NET-Datenanbieter umfassen Folgendes:
SQL Server .NET-Datenanbieter, verwendet für Microsoft SQL Server-Datenquellen, aus dem System.Data.SqlClient-Namespace;
OLE DB .NET-Datenanbieter, verwendet für OLE DB-Datenquellen stammen aus dem System.Data.OleDb-Namespace; die für ODBC verwendeten Datenquellen stammen aus dem System.Data.Odbc-Namespace Oracle .NET-Datenanbieter für Oracle-Datenquellen aus dem System.Data.OracleClient-Namespace.
Datenanbieter
.NET-Datenanbieter verfügt über 4 Kernobjekte:
Verbindungsobjekt wird verwendet, um eine Verbindung mit der Datenquelle herzustellen;
Befehlsobjekt wird verwendet, um bestimmte Befehle auf der Datenquelle auszuführen
DataReader-Objekt Wird verwendet, um einen vorwärtsgerichteten, schreibgeschützten Datenstrom von der Datenquelle zurückzugeben.
Das DataAdapter-Objekt wandelt verschiedene Operationen an den Daten automatisch in die entsprechenden SQL-Anweisungen der Datenquelle um.
DataSet
ADO.NET und die Kernkomponente ist das DataSet.
Sie können sich ein DataSet als eine In-Memory-Datenbank vorstellen. Es handelt sich um einen unabhängigen
Datensatz
, der nicht von der Datenbank abhängt. Unabhängig bedeutet, dass das DataSet auch dann noch verfügbar ist, wenn die Datenverbindung getrennt oder geschlossen wird. In ADO.NET wird DataSet speziell zum Verarbeiten von Daten verwendet, die aus Datenquellen stammen. Unabhängig von den zugrunde liegenden Daten kann dieselbe Methode zum Bearbeiten von Daten verwendet werden, die aus verschiedenen Datenquellen stammen. DataSet verwendet intern XML, um Daten zu beschreiben. XML ist eine plattform- und datenunabhängige Datenbeschreibungssprache, die komplexe Datenbeziehungen beschreiben kann.
ADO.NET-Datenbankbetriebsprozess
Verwenden Sie zunächst das Verbindungsobjekt
, um eine Verbindung zur Datenbank herzustellen
; Wenn Sie einen Datenbankausführungsbefehl oder eine gespeicherte Prozedur
ausführen Da kein Rückgabeergebnis erforderlich ist, können Sie das Command-Objekt verwenden; das DataReader-Objekt wird zum Lesen von Vorwärts- und Nur-Lese-Datenströmen aus der Datenquelle verwendet. DataSet ist eine speicherresidente Darstellung von Daten, die ein konsistentes relationales Programmiermodell bereitstellt, das von der Datenquelle unabhängig ist. DataSet stellt den gesamten Datensatz dar, der Tabellen, Einschränkungen und Beziehungen zwischen Tabellen enthält.
Die Interaktion mit vorhandenen Datenquellen wird über DataAdapter gesteuert. Das DataAdapter-Objekt wird verwendet, um Daten von der Datenquelle abzurufen, das DataSet sowie Tabellen und Einschränkungen zu füllen und Änderungen am DataSet an die Datenquelle zurückzusenden.
Verwenden Sie das Verbindungsobjekt, um auf die Datenbank zuzugreifen.
Schritte zum Herstellen einer Verbindung zur Datenbank.
(1) Definieren Sie die Verbindungszeichenfolge.
Verwenden Sie die SQL Server-Authentifizierung:
Datenquelle=Servername=Datenbank Name; Benutzer-ID =Benutzername;Pwd=Passwort
Windows-Authentifizierung verwenden:
Datenquelle=Servername;Anfangskatalog=Datenbankname;
Integrierte Sicherheit=True
(2) Verbindungsobjekt erstellen
SqlConnection Connection = new SqlConnection(connString);
(3) Öffnen Sie die Verbindung zur Datenbank
Connection.Open();
Verwenden Sie das Command-Objekt, um auf die Datenbank zuzugreifen
Schritte zur Verwendung von ExecuteNonQuery( ):
( 1) Verbindungsobjekt erstellen;
(3) Befehlsobjekt erstellen
(5) Prozess gemäß dem zurückgegebenen Ergebnis.

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