Résumé des systèmes conceptuels en C#

1. Qu'est-ce que .Net
.Net est une plate-forme de développement d'applications lancée par Microsoft qui peut être utilisée pour créer et exécuter une nouvelle génération d'applications Microsoft Windows et Web.

2. La technologie de base de .Net
.Net Framework : le cœur de la plate-forme .Net, fournissant le framework de base pour le fonctionnement des applications sous la plate-forme .Net. .
.Net Enterprise Server : fait partie des services techniques de Microsoft pour les entreprises, comprenant divers kits d'outils de développement.
Service de module de construction : le service de composants COM+ et la technologie de service Web XML fournis par Microsoft utilisent le service de module de construction pour développer des modules d'application, qui peuvent rapidement assembler un logiciel entièrement fonctionnel.
Visual Studio.Net : Le principal outil de développement pour la plateforme .Net

3..Net Framework se compose de différents composants pour prendre en charge la création et l'exécution d'applications basées sur la plateforme .NET.

4. La couche inférieure du framework Net Framework est constituée de divers composants de service d'application fournis par le système d'exploitation Windows. Ces composants incluent : le service de messages file d'attente , le service de composants COM+, le service d'information Internet ( IIS), outils de gestion Windows (WMI), etc.

5..Net Framework peut être intégré à eux pour développer des applications. Le niveau supérieur de .Net Framework est le langage de programmation. .Net Framework prend en charge plus de 20 langages de programmation informatique. Dans l'environnement de développement Visual Studio.Net, vous pouvez utiliser directement cinq langages : VB, C#, C++, J# et Jscript pour développer n'importe quelle application.

6..Net Framework comporte deux composants principaux : Common Language Runtime (CLR) et .Net FrameworkClass Library, en plus d'ADO.NET, ASP.NET, XML Web, etc.

7..Net Framework prend en charge 3 types d'interfaces utilisateur :
Console de commande, utilisée pour concevoir des applications avec des interfaces en caractères purs
Windows Forms, utilisé pour concevoir des applications avec une interface Windows
Formulaires Web , applications utilisées pour concevoir des interfaces Web

8.ADO.NET est la nouvelle génération de technologie de traitement de données orientée objet de Microsoft fournie par le .Net Framework, qui permet de développer des applications de base de données facilement et rapidement.
ASP.Net est une nouvelle technologie de développement d'applications Web fournie par .Net Framework. Utiliser ASP.NET pour développer des applications WEB est aussi simple que développer des applications Windows.
Xml Web Service est un composant qui peut être appelé directement dans l'environnement Internet. Le .Net Framework fournit des outils et des classes pour créer, tester et déployer des services Web XML.

9.Net Framework fournit aux développeurs d'applications un environnement de développement
indépendant de la plate-forme. L'utilisation de .Net Framework pour développer des programmes présente les avantages suivants :
Standards basés sur le Web
.Net. Framework prend entièrement en charge les technologies Internet existantes et d’autres normes Web.
2. Utilisez un modèle d'application unifié
Tout langage compatible avec .NET peut utiliser la bibliothèque de classes .Net Framework.
3. Facile à utiliser pour les développeurs
Lorsque les développeurs doivent appeler une classe de la bibliothèque de classes .Net Framework, il leur suffit d'ajouter l'attribut de classe espace de noms à Citez simplement dans la solution.
4. Classes extensibles
.Net Framework fournit un système de types universel. Les développeurs peuvent accéder aux classes de la bibliothèque de classes via hériter , et peuvent également étendre les classes de la bibliothèque de classes, ou même créer votre propre classe. propre bibliothèque de classe.


Avantages de C# : (1) C# est un langage précis, simple, de typesûr, orienté objet.
(2) C# a la capacité de générer des composants persistants au niveau du système.
(3) C# utilise le système de types universels du .Net Framework pour interagir avec d'autres langages de programmation.
(4) C# prend en charge le service MSMQ (Microsoft Message Queuing), le service de composants COM+, le service Web XML et .Net Framework.
(5) C# permet de personnaliser les types de données avec des métadonnées étendues.
(6) C# améliore l'efficacité du développement tout en conservant la flexibilité requise par les développeurs.
Caractéristiques des programmes C# : 4. La structure des méthodes dans les programmes C#
Une méthode dans un programme C# est regroupée en deux parties : l'en-tête de méthode et le corps de la méthode.
En-tête de la méthode : l'en-tête de la méthode est la première ligne de la méthode, comprenant le type de valeur de retour, le nom de la méthode, le nom du paramètre formel et la description du type de paramètre formel.
Corps de la méthode : le corps de la méthode est entouré d'une paire d'accolades "{ }" et contient généralement des instructions de déclaration et des instructions d'exécution.

5. Déclarations du programme C#
Chaque déclaration dans un programme C# doit se terminer par un point-virgule. Lors de l'écriture, vous pouvez écrire plusieurs déclarations sur une seule ligne, ou vous pouvez écrire une déclaration sur plusieurs lignes.

6. Opérations d'entrée et de sortie des programmes C#
Le langage C# lui-même n'a pas d'instructions d'entrée et de sortie, donc l'application console C# doit utiliser les méthodes de la classe Console dans la bibliothèque de classes ( ReadLine, WriteLine, etc.) pour effectuer des opérations d'entrée, de sortie et autres, tandis que les applications Windows C# et les applications Web doivent utiliser la classe Control (telle que les étiquettes, les zones de texte, etc.) du bibliothèque de classes pour obtenir des entrées et des sorties.

7. Commentaires pour les programmes C#
Vous pouvez utiliser "//" ou "/*...*/" pour ajouter des commentaires. L'ajout de commentaires appropriés peut grandement améliorer la lisibilité du programme.
Le type simple représente un type de données avec une valeur unique, comprenant les 4
types suivants : 1. Entier type 2. Type à virgule flottante3. Type booléen
type flottant : la plage de valeurs est de ±1,5e?45 à ±3,4e38 La précision est de 7 chiffres
type double : la plage de valeurs est de ±5,0e?324 à ±. 1.7 La précision de e308 est de 15 à 16 chiffres

3 Type décimal décimal Afin de répondre aux besoins des champs de calcul financier et financier de haute précision, C# fournit un type de données de type décimal
avec une plage de valeurs. de ±1,0?×?10e ​​?28 à ± 7,9? )
5 Lors de l'exécution du programme, la grandeur dont la valeur reste inchangée est appelée
constante
1. constantes
les constantes entières sont divisées en constantes entières signées, constantes entières non signées et constantes entières longues
Les constantes entières signées sont écrites directement, telles que 5
Les constantes entières non signées ajoutent le signe u ou U lors de l'écriture, comme 5U
entier long Ajoutez la marque l ou L lors de l'écriture de constantes de type, telles que 5L
2 Constantes à virgule flottante
Les constantes à virgule flottante sont divisées en constantes à virgule flottante simple précision et flottantes double précision. -constantes point
Les constantes de type à virgule flottante simple précision sont marquées par f ou F lorsqu'elles sont écrites, telles que 5F
Les constantes double précision sont marquées par d ou D, telles que 5D
lorsqu'elles sont écrites directement. sous forme décimale, elles sont automatiquement interprétées comme des constantes à virgule flottante double précision, par exemple 5,0 est une constante à virgule flottante double précision.
3. Constantes décimales
La marque m ou M doit être ajoutée après la constante décimale, sinon elle sera interprétée comme une donnée à virgule flottante.
4. Constantes de caractères (caractères Unicode) :
Les constantes de caractères sont marquées par deux guillemets simples, tels que '5', 'A', '中', '@'
C# escape Les constantes de caractères commencent par une barre oblique inverse'' et sont utilisés pour représenter des caractères de contrôle et invisibles. Par exemple, 'b' signifie revenir en arrière d'un caractère. Pour plus de détails, voir le tableau 2-3 sur P26 du manuel
5 Il n'y a que deux constantes booléennes
, vrai signifie logiquement vrai et faux signifie logiquement faux.
6.
String
ConstantLa constante String représente une séquence de caractères composée de plusieurs caractères Unicode, marqués par des guillemets doubles, tels que "5", "abc", "Chinois". Les types structurels doivent être marqués avec struct.
Les membres structurels sont autorisés à contenir des membres de données, des membres de méthode, etc.
Les membres de données représentent des éléments de données de la structure
Les membres de méthode représentent des opérations sur des éléments de données.

1.
La notion de variable
Lors du fonctionnement du programme, le montant dont la valeur peut être modifiée est appelé une variable.
Nom de la variable
 : Chaque variable doit avoir un nom. La dénomination des variables doit suivre les règles de dénomination des identifiants. Par exemple, elle doit commencer par une lettre ou un trait de soulignement et ne peut contenir que des lettres, des chiffres et des traits de soulignement anglais, et ne peut pas contenir d'espaces, etc. Valeur de la variable : la valeur de la variable est stockée en mémoire ; différents types de variables occupent différents nombres d'unités de mémoire (octets). Dans un programme, la valeur d'une variable est référencée par son nom. 2. Définition des variables
La forme générale de définition des variables est :
Nom de la variable de type de données 1, nom de la variable 2,...
Par exemple :

int  a,b,c; 
long  x,y；
float  p1,p2;

3. Initialisation des variables

Par exemple :

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.  多态
多态性是指在基类中定义的属性或服务被派生类继承后，可以具有不同的数据类型或表现出不同的行为。
为了实现多态性，需要在派生类中更改从基类中自动继承来的数据类型或方法。
这种为了替换基类的部分内容而在派生类中重新进行定义的操作，在面向对象概念中称之为覆盖。
例如，假设机动车类是一个基类，它具有一个称为更换轮胎的方法，但是当从机动车派生火车类时，火车更话车轮的方法与一般的机动车不同，于是只能通过覆盖的方法在火车类中重新定义一个更换车轮的方法，以替换其基类的方法。
多态性的优势在于使软件开发更加方便，增加程序的可读性。
Le membre constant d'une classe est une constante symbolique, et le nom et la valeur doivent être spécifiés
Les modificateurs d'accès incluent : public, privé, interne, protégé, protégé interne.
Lorsque vous utilisez des modificateurs d'accès pour définir des espaces de noms, des structures, des classes et leurs membres
, veuillez noter :
(1) Un membre ou un type ne peut avoir qu'un seul modificateur d'accès, lors de l'utilisation d'une combinaison interne protégée, sauf.
(2) Les modificateurs d'accès ne sont pas autorisés sur les espaces de noms, et il n'y a aucune restriction d'accès sur les espaces de noms.
(3) Si le modificateur d'accès n'est pas spécifié, l'accessibilité par défaut est utilisée et les membres de la classe sont par défaut privés.
(4) L'accessibilité des types de niveau supérieur (types non imbriqués dans d'autres types) ne peut être qu'interne ou publique, et l'accessibilité par défaut est interne.
Description détaillée de la définition des méthodes
(1) Les modificateurs d'accès contrôlent le niveau d'accès des méthodes. Les modificateurs qui peuvent être utilisés pour les méthodes incluent : public, protégé, privé, interne, etc.
(2) Le type de valeur de retour d'une méthode peut être n'importe quel type de données légal, y compris les types valeur et les types référence. Lorsqu'il n'y a pas de valeur de retour, le type de valeur de retour est représenté par le mot clé void.
(3) Le nom de la méthode doit être conforme à la convention de dénomination C#, qui est la même que la règle de dénomination des noms de variables.
(4) La liste des paramètres correspond aux données d'entrée que la méthode peut accepter. Lorsqu'une méthode ne nécessite pas de paramètres, la liste des paramètres peut être omise, mais les parenthèses ne peuvent pas être omises. Lorsqu'il y a plusieurs paramètres, des virgules doivent être utilisées comme séparation et chaque paramètre doit déclarer le type de données, même si les types de données de ces paramètres sont les mêmes.
(5) Le contenu entre accolades {} est le corps de la méthode, qui se compose de plusieurs instructions. Chaque instruction doit se terminer par un point-virgule. Si vous devez renvoyer le résultat de l'opération à la fin de la méthode, utilisez l'instruction return pour revenir. À ce stade, veuillez noter que le type de valeur renvoyé par l'instruction return doit correspondre au type de valeur de retour de la méthode. . Si la méthode est marquée comme void et n'a aucune valeur de retour, l'instruction return peut être omise.

1. Paramètres de type valeur
Lors de l'appel d'une méthode de direction pour transmettre un paramètre de type valeur, l'appelant attribuera la valeur de la variable paramètre réelle à la variable paramètre formelle correspondante, c'est-à-dire le paramètre réel. La variable et la variable de paramètre formel sont deux variables différentes.
Lorsque la valeur de la variable paramètre réelle est transmise à la variable paramètre formelle, il s'agit d'un transfert de valeur unidirectionnel. Les
Les paramètres de type référence
sont différents des paramètres de valeur. Lorsque la méthode de direction appelante transmet un paramètre de type référence, l'appelant attribuera la référence de la variable paramètre réelle à la variable paramètre formelle correspondante. La référence de la variable paramètre réelle représente l'adresse mémoire de la valeur des données, de sorte que la variable paramètre formelle et la variable paramètre réelle pointeront vers la même référence.
Si la valeur des données référencée par la variable paramètre formelle est modifiée dans la méthode, la valeur des données référencée par la variable paramètre réelle est également modifiée.
Étant donné que l'instruction return ne peut renvoyer qu'une seule donnée à la fois, si vous devez renvoyer plusieurs données, vous pouvez utiliser cette fonctionnalité de paramètres de référence pour y parvenir.
C# déclare les paramètres de référence via le mot-clé ref. Qu'il s'agisse d'un paramètre formel ou d'un paramètre réel, tant que vous souhaitez transférer une référence aux données, vous devez ajouter le mot-clé ref.
Paramètre de sortie
L'instruction return dans la méthode ne peut renvoyer qu'un seul résultat d'opération. Bien que les paramètres de référence puissent également être utilisés pour renvoyer le résultat du calcul, les paramètres réels doivent d'abord être initialisés.
Le paramètre de sortie n'a pas besoin d'initialiser les paramètres réels. Il est spécialement utilisé pour renvoyer les données de la méthode aux paramètres réels via les paramètres formels, mais la valeur des paramètres réels ne sera pas transmise aux paramètres formels. . Plusieurs paramètres de sortie sont autorisés dans une méthode.
C# déclare les paramètres de sortie via le mot-clé out. Qu'il s'agisse d'un paramètre formel ou d'un paramètre réel, tant qu'il s'agit d'un paramètre de sortie, le mot-clé out doit être ajouté.
Paramètres de type tableau
En utilisant des tableaux comme paramètres, il existe deux formes d'utilisation :
L'une consiste à ne pas ajouter le modificateur params avant le groupe de paramètres formel
L'autre consiste à ajouter des paramètres avant le modificateur de groupe de paramètres formel .
La différence entre les deux formes
Lorsque le modificateur params n'est pas ajouté, le paramètre réel correspondant doit être un nom de tableau.
Lors de l'ajout du modificateur params, le paramètre réel correspondant peut être un nom de tableau ou une liste de valeurs d'éléments de tableau.
Il convient de noter que quelle que soit la forme utilisée, le groupe de paramètres formels ne peut pas définir la longueur du tableau.
Surcharge de
La surcharge de méthodes fait référence à la déclaration de deux ou plusieurs méthodes portant le même nom dans le même type. La Surcharge de méthode peut être utile lorsque vous devez effectuer la même opération avec une liste de paramètres différente.

2. Caractéristiques du destructeur :
(1) Vous ne pouvez pas définir un destructeur dans une structure, vous ne pouvez utiliser un destructeur que sur une classe
(2) A ; la classe ne peut avoir qu'un seul destructeur ;
(3) Le destructeur ne peut pas être hérité ou surchargé ;
(4) Le destructeur n'a ni modificateurs ni paramètres
(5) dans Lorsque le destructeur est appelé, .Net Le CLR de Framework ajoute automatiquement un appel à la méthode de classe de base Object.Finalize pour nettoyer la scène, donc un appel à la méthode Object.Finalize ne peut pas être inclus dans le destructeur.
Notez que par défaut, le compilateur génère automatiquement un destructeur vide, donc C# ne permet pas la définition d'un destructeur vide

1. Définition de la classe static :
La classe statique est déclarée à l'aide du mot-clé static , indiquant qu'elle ne contient que des membres statiques.
Vous ne pouvez pas utiliser le nouveau mot-clé pour créer des instances de classes statiques.
Dans les applications pratiques, lorsque les membres d'une classe ne sont pas associés à un objet spécifique, celle-ci peut être créée comme une classe statique.

2. Les principales fonctions des classes statiques :
(1) Les classes statiques ne contiennent que des membres statiques
(2) Les classes statiques ne peuvent pas être instanciées ; ;
(4) Les classes statiques ne peuvent pas contenir d'instances
constructeurs .
3.Avantages des classes statiques :
(1) Le compilateur peut effectuer automatiquement des vérifications pour s'assurer que les membres de l'instance ne sont pas ajoutés
(2) Les classes statiques peuvent rendre la mise en œuvre du programme plus simple et plus rapide, car vous n'avez pas besoin de
créer un objet pour appeler ses méthodes. Remarque : les classes statiques étant scellées, elles ne peuvent pas être héritées. De plus, les classes statiques ne peuvent pas contenir de constructeurs d'instances, mais elles peuvent toujours déclarer des constructeurs statiques pour attribuer des valeurs initiales ou définir un état statique.
(1) Les caractéristiques des classes dérivées
peuvent avoir leurs propres membres.
Vous pouvez implicitement hériter de tous les membres de la classe de base, y compris les méthodes, les champs, les propriétés et les événements, à l'exception des membres privés, des constructeurs et des destructeurs.
Les classes dérivées ne peuvent hériter que d'une seule classe
Classe scellée
L'utilisation d'une classe scellée peut empêcher que le code d'une classe soit hérité par d'autres classes
Avantages de l'utilisation d'une classe scellée :
Peut améliorer les performances de l'application Fiabilité et performances (dans le Common Language Runtime CLR du .NET Framework, les appels de méthode aux classes scellées sont optimisés lors du chargement des classes scellées).
Les éditeurs de logiciels peuvent également protéger leurs droits de propriété intellectuelle en utilisant des classes scellées pour empêcher d'autres personnes de partager du code.
En C#, ajoutez le mot clé scellé pour déclarer une classe scellée.

4. Afin d'utiliser des classes dérivées pour modifier les données et le comportement des classes de base, C# propose deux options : 1. Utiliser de nouveaux membres de classe dérivés pour remplacer les membres de base 2. Remplacer les membres de base virtuels
Faites attention aux points suivants lors de l'utilisation de virtual et override :
(1) Les champs ne peuvent pas être virtuels, uniquement les méthodes, propriétés, événements et uniquement les indexeurs peut être virtuel ;
(2) Après avoir utilisé le modificateur virtuel, les modificateurs statiques, abstraits ou de remplacement ne peuvent pas être utilisés
(3) Même si un objet de classe dérivé est converti en un objet de classe de base, La référence est toujours membre de la classe dérivée ;
(4) La classe dérivée peut arrêter l'héritage virtuel en scellant. À ce stade, les membres de la classe dérivée sont déclarés en utilisant un remplacement scellé.


Caractéristiques des classes abstraites : Les classes abstraites sont utilisées comme classes de base et ne peuvent pas être directement instanciées, et ne peuvent être identifiées qu'à l'aide du mot-clé abstract. Le but d’une classe abstraite est de fournir une définition commune d’une classe de base pouvant être partagée par plusieurs classes dérivées.
Les classes abstraites peuvent contenir des membres abstraits, tels que des propriétés abstraites et des méthodes abstraites, ainsi que des membres non abstraits, et même des méthodes virtuelles.
Caractéristiques des attributs abstraits
Une fois le mot-clé abstract ajouté aux attributs membres d'une classe, ils deviennent des attributs abstraits.
La déclaration de propriété abstraite ne fournit pas l'implémentation de l'accesseur de propriété, elle déclare uniquement les propriétés prises en charge par la classe et laisse l'implémentation de l'accesseur à la classe dérivée.
Les propriétés abstraites peuvent également être des propriétés en lecture seule, en écriture seule ou en lecture-écriture.
Lorsqu'une classe dérivée hérite d'une propriété abstraite d'une classe abstraite, la classe dérivée doit remplacer la propriété abstraite.
Les attributs abstraits sont identifiés à l'aide du mot-clé abstract.

Caractéristiques des méthodes abstraites :
Après avoir ajouté le mot-clé abstract à une méthode membre d'une classe, celle-ci devient une méthode abstraite.
La déclaration de méthode abstraite ne fournit pas l'implémentation de la méthode, il doit s'agir d'une méthode vide, laissant l'implémentation de la méthode à la classe dérivée.
Lorsqu'une classe dérivée hérite d'une méthode abstraite d'une classe abstraite, la classe dérivée doit remplacer la méthode abstraite.
Comme la méthode abstraite n'est pas implémentée, la méthode abstraite ne contient pas de corps de méthode régulier et se termine par un point-virgule.
1. Delegate est un type de méthode de référence. Il est identique à la classe, à l'interface et au tableau et appartient au type de référence.
Dans un programme C#, vous pouvez déclarer un type délégué, définir des variables du type délégué, attribuer des méthodes aux variables déléguées et appeler indirectement une ou plusieurs méthodes via des délégués.
Une fois qu'une méthode est attribuée à un délégué, le délégué se comportera exactement de la même manière que cette méthode.
C# permet à n'importe quelle méthode avec la même signature (même valeur de retour et mêmes paramètres) d'être assignée à une variable déléguée.
L'essence d'un délégué est une référence (c'est-à-dire une adresse mémoire) qui représente une méthode. C'est un choix idéal pour définir des méthodes de rappel et c'est également le principal moyen pour C# d'implémenter l'événement
piloté <.>programmation modèle. Le délégué a les caractéristiques suivantes : (1) La délégation est similaire au
Pointeur de fonction
C++, qui est entièrement orienté objet et un type de données sûr. (2) Delegate permet de transmettre des méthodes en tant que paramètres. (3) Delegate peut être utilisé pour définir des méthodes de rappel.
(4) Les délégués peuvent être reliés entre eux. Par exemple, plusieurs méthodes peuvent être appelées sur un événement.
(5) La signature du délégué n'a pas besoin de correspondre exactement à la méthode.
Une collection est une classe qui stocke des objets arbitraires de manière hautement structurée. Par rapport aux tableaux qui ne peuvent pas être redimensionnés dynamiquement, les collections peuvent non seulement être redimensionnées à volonté, mais fournissent également des méthodes plus avancées pour stocker ou récupérer les objets qui y sont stockés. .
Les collections peuvent regrouper un groupe d'objets typés similaires.
Lors du choix d'une classe de collection, vous devez généralement prendre en compte les problèmes suivants :
(1) Avez-vous besoin d'une liste de séquences ? Si vous avez besoin d'un comportement premier entré, premier sorti, vous pouvez utiliser la classe Queue When. vous avez besoin d'un comportement du dernier entré, premier sorti, vous pouvez utiliser la classe Stack.
(2) Que vous ayez besoin d'accéder de manière aléatoire aux éléments de la collection, vous ne pouvez pas choisir la classe de file d'attente Queue, la classe Stack stack, LinkedList classe de liste doublement chaînée.
(3) Avez-vous besoin d'accéder à chaque élément via l'index ? Seules la classe de tableau dynamique ArrayList, la classe de collection de chaînes StringCollection, etc. accèdent aux éléments de la collection un par un en commençant par l'élément avec l'index zéro. Hashtable Les classes de table de hachage et de dictionnaire de dictionnaire permettent d'accéder aux éléments via la clé de l'élément (c'est-à-dire le nom de l'élément). La classe NameValueCollection et la classe générique SortedList permettent d'accéder aux éléments via l'index de base zéro de leur élément ou via la clé de son élément.
(4) Qu'il contienne une valeur, une clé et un ensemble de valeurs, ou un ensemble de clés et plusieurs valeurs. Parmi eux, la collection « une valeur » est une collection dérivée basée sur l'interface de liste IList, la collection « une clé et une valeur » est une collection basée sur l'interface de dictionnaire IDictionary et la collection « une clé et plusieurs valeurs" est du type NameValueCollection.
(5) Si les éléments doivent être triés différemment des éléments d'entrée. La classe de table de hachage Hashtable trie les éléments en fonction de leurs codes de hachage, la classe de liste ordonnée SortedList et le dictionnaire ordonné SortedDictionary implémentent le tri des éléments par clé selon l'interface comparable IComparer, et la classe de tableau dynamique ArrayList fournit la méthode de tri Sort.
(6) Que vous ayez besoin d'une recherche et d'une récupération rapides d'informations, pour de petites collections (10 éléments ou moins), ListDictionary est plus rapide que Hashtable et la classe générique SortedDictionary fournit une recherche plus rapide que la classe générique Dictionary.
(7) Devez-vous accepter uniquement une collection de chaînes, comme l'utilisation de StringCollection et StringDictionary, etc.
La classe de tableau dynamique ArrayList ne limite pas le nombre et le type de données des éléments.
(1) La différence entre ArrayList et Array
La taille de Array est fixe, tandis que la taille de ArrayList peut être automatiquement étendue selon les besoins
Vous ne pouvez obtenir ou définir la valeur d'un élément à la fois ; le temps dans Array, tandis que dans Array ArrayList permet d'ajouter, d'insérer ou de supprimer une plage d'éléments
La limite inférieure de Array peut être personnalisée, tandis que la limite inférieure de ArrayList est toujours nulle
Array peut avoir plusieurs dimensions, tandis qu'ArrayList n'est toujours qu'unidimensionnel ;
Array est situé dans l'espace de noms System et ArrayList est situé dans l'espace de noms System.Collections.
(2) Créer un tableau dynamique :
ArrayList List object name = new ArrayList(?);
Caractéristiques de la file d'attente
Une structure de données premier entré, premier sorti Lorsqu'un objet est inséré. ou supprimé, l'objet Insérer à une extrémité de la file d'attente et supprimer de l'autre extrémité
Créer un objet de file d'attente
Nom de la file d'attente = new Queue([longueur de la file d'attente][, facteur de croissance]);
Explication, la longueur de la file d'attente est par défaut de 32 et augmente. Le facteur est par défaut de 2,0 (c'est-à-dire que chaque fois que la capacité de la file d'attente est insuffisante, la longueur de la file d'attente est ajustée à 2 fois la valeur d'origine)
Notez que puisque l'ajustement de la taille de la file d'attente nécessite un certain coût de performance, il est recommandé de spécifier la longueur de la file d'attente lors de la construction de la file d'attente.
Les méthodes courantes de fonctionnement de la file d'attente incluent Enqueue pour ajouter des données à la fin de la file d'attente, Dequeue pour supprimer les données de la tête de la file d'attente, Peek pour renvoyer les données de la tête de la file d'attente, Clear pour vider la file d'attente et Contains pour vérifiez si certaines données sont incluses. Parmi eux, Enqueue et Dequeue ne peuvent ajouter ou supprimer qu’une seule donnée à la fois.
Caractéristiques de la pile :
Une structure de données premier entré, dernier sorti Lors de l'insertion ou de la suppression d'un objet, cette structure de données ne peut être insérée ou supprimée qu'en haut de la pile.
Créez un objet de pile :
Nom de la pile de pile = new Stack (?);
Les méthodes de pile courantes incluent Push pour ajouter des données en haut de la pile, Pop pour supprimer les données supérieures de la pile, Peek pour renvoyer les données supérieures de la pile, et Clear pour effacer la pile et Contain pour vérifier si elle contient certaines données, etc. Parmi eux, Push et Pop ne peuvent ajouter ou supprimer qu’une seule donnée à la fois.
La table de hachage, également connue sous le nom de table de hachage, représente une collection de paires clé/valeur.
Caractéristiques de la table de hachage : lors de l'enregistrement d'un élément de collection, le code de hachage doit être automatiquement calculé en fonction de la clé pour déterminer l'emplacement de stockage de l'élément, puis la valeur de l'élément est placée dans le bucket pointé par l'emplacement correspondant. Lors de la recherche, recherchez à nouveau dans un compartiment spécifique par le code de hachage correspondant à la clé. Cela réduit considérablement le nombre de comparaisons nécessaires pour trouver un élément.
Créer un objet de table de hachage
Nom de la table de hachage Hashtable = new Hashtable([longueur de la table de hachage][, facteur de croissance]);
Explication, la longueur par défaut est 0 et le facteur de croissance par défaut est 1,0
Les méthodes de fonctionnement courantes des tables de hachage incluent Ajouter pour ajouter des données, Supprimer pour supprimer des données, Effacer pour effacer la table de hachage et Contient pour vérifier si certaines données sont incluses. Parmi eux, la méthode Add nécessite deux paramètres, l'un est la clé et l'autre est la valeur ; la méthode Remove ne nécessite qu'un seul paramètre clé.
Il existe deux différences entre les indexeurs d'interface et les indexeurs de classe :
Premièrement, les indexeurs d'interface n'utilisent pas de modificateurs
Deuxièmement, les indexeurs d'interface contiennent uniquement l'accesseur get ou ; set, aucune déclaration d'implémentation.
Lors de la création d'une classe générique personnalisée, vous devez accorder une attention particulière aux points suivants :
(1) Quels types doivent être généralisés en tant que paramètres de type
La règle générale est la suivante : plus il y a de types pouvant être paramétrés , meilleur sera le code. Plus vous devenez flexible, meilleure sera sa réutilisabilité, mais trop de généralisation peut rendre difficile la lecture ou la compréhension du code par les autres développeurs.
(2) S'il y a des contraintes , quelles contraintes doivent être appliquées aux paramètres de type
La règle générale est la suivante : appliquez autant de contraintes que possible, mais soyez toujours capable de gérer les types qui doivent être traités. Par exemple, si vous savez qu'une classe générique ne sera utilisée que pour les types référence, appliquez des contraintes de classe. Cela évite que les classes génériques soient accidentellement utilisées pour les types valeur.
(3) S'il faut décomposer le comportement générique en classes et sous-classes de base
Puisque les classes génériques peuvent être utilisées comme classes de base, leurs précautions sont les mêmes que celles des classes non génériques.
(4) S'il faut implémenter une ou plusieurs interfaces génériques.
Traitement des événementsComposants du système
(1) Source de l'événement : désigne l'objet pouvant déclencher l'événement, parfois aussi appelé l'expéditeur de l'événement ou l'éditeur de l'événement ;
(2 ) Listener : fait référence à un objet qui peut recevoir des messages d'événement. Windows fournit des services d'écoute d'événements de base ;
(3) Gestionnaire d'événements : gère les événements lorsque des événements se produisent, également appelés fonctions d'événement ou méthodes d'événement, l'objet contenant le gestionnaire d'événements est appelé le destinataire de l'événement, également appelé abonné à l'événement.
Les événements en C# ont les caractéristiques suivantes :
(1) Les événements sont un moyen pour les classes de notifier les objets dont ils ont besoin pour effectuer certaines opérations
(2) Bien que les événements puissent se produire à d'autres moments (comme par exemple) changements d'état du signal) Très utile, mais généralement utilisé dans les interfaces utilisateur graphiques ;
(3) les événements sont généralement déclarés à l'aide de gestionnaires d'événements délégués
(4) les événements peuvent appeler des méthodes anonymes au lieu de délégués ;
1. Concepts de base des événements
L'objet qui déclenche l'événement est appelé l'éditeur, et l'objet qui fournit le gestionnaire d'événements est appelé l'abonné. Dans le .NET Framework, les programmes basés sur les événements utilisent des délégués pour lier des événements et des fonctions d'événement. En C#, un événement est en réalité une variable de type délégué.
C# vous permet d'utiliser le type de délégué EventHandler intégré pour déclarer un événement standard, et vous permet également de personnaliser d'abord le délégué, puis de déclarer l'événement personnalisé.
Dans le .NET Framework, le délégué EventHandler intégré a deux paramètres, leurs types de données sont respectivement de type Object et EventArgs, et il n'y a pas de valeur de retour.
Le nom du paramètre Object est généralement sender, qui représente l'éditeur d'événement lui-même ; le paramètre EventArgs est généralement e, qui transmet une nouvelle instance de la classe System.EventArgs à la fonction événement. Dans la programmation réelle, il est parfois nécessaire de dériver une classe de paramètres d'événement personnalisée à partir de la classe EventArgs afin que l'éditeur puisse envoyer des données spécifiques à la fonction événementielle du récepteur.
Déclaration d'événement
(1) Utilisez le délégué EventHandler intégré pour déclarer l'événement (événement standard)
Format : événement public Nom de l'événement EventHandler ;
Parmi eux, le nom de l'événement est généralement utilisé comme le préfixe.
Par exemple, événement public EventHandler onClick;
(2) Utilisez un type de délégué personnalisé pour déclarer l'événement
Format : type de valeur de retour du délégué public nom du type de délégué ([paramètre]) ;
                                                                                                                                                                                                                                Nom du type de délégation ; Les paramètres de la fonction
correspondent. Assurez-vous de bien comprendre les points suivants lorsque vous vous abonnez à des événements : (1) Tout d'abord, la classe réceptrice doit avoir une méthode avec la même signature (même type de valeur de retour et mêmes paramètres) que l'événement lui-même, puis le (appelée programme de traitement d'événements) peut prendre les mesures appropriées en réponse à l'événement.
(2) Chaque événement peut avoir plusieurs gestionnaires, et plusieurs gestionnaires sont appelés dans l'ordre. Si un gestionnaire lève une exception, les gestionnaires qui n'ont pas encore été appelés n'ont aucune chance de recevoir l'événement. Pour cette raison, il est recommandé aux gestionnaires d’événements de gérer les événements rapidement et d’éviter de générer des exceptions.
(3) Pour s'abonner à un événement, le destinataire doit créer un délégué du même type que l'événement, utiliser le gestionnaire d'événement comme cible du délégué, et également utiliser l'
opérateur d'affectation additive
(+ =) Ajoutez le délégué à l'événement de l'objet source. (4) Pour se désinscrire d'un événement, le destinataire peut utiliser l'opérateur d'affectation de soustraction (?=) pour supprimer le délégué de l'événement gestionnaire de l'événement de l'objet source.




1. Windows Forms
Windows Forms est le point de départ pour créer des applications basées sur des fenêtres à l'aide de C#. Cependant, du point de vue du formulaire lui-même, il ne s’agit que d’une interface mobile. Bien que les utilisateurs puissent dessiner des objets et du texte directement sur le formulaire, le véritable rôle du formulaire est de servir de conteneur pour les contrôles Windows.
L'essence du contrôle est l'objet membre du formulaire, qui est utilisé pour afficher des informations et recevoir des informations saisies par l'utilisateur.




2. Espace de noms Windows Forms
La classe de base de Windows Forms est Form, dans la définition de l'espace de noms System.Windows.Forms.
La plupart des contrôles dans .NET sont dérivés de la classe System.Windows.Forms.Control, qui définit les fonctionnalités de base du contrôle.
Contrôles de formulaire dans .NET Framework
Affichage des données DataGridView
Liaison des données et positionnement BindingSource, BindingNavigator
Text Edit TextBox, RichTextBox, MaskedTextBox
Affichage des informations Lable, StatusStrip, ProgressBar
Affichage de la page Web WebBrowser
Liste et sélection CheckBox, CheckedListBox, ComboBox, RadioButton, ListBox, ListView, NumericUpDown, TreeView, DomainUpDown, TrackBar,
Affichage graphique PictureBox, ImageList
Paramètres de date DateHeureSélecteur, MoisCalendrier
Dialogue ColouD ialog, FontDialog , OuvrirFichierDialog, ImprimerDialog, ImprimerPreviewDialog, FolderBrowerDialog, SaveFileDialog
Command Button, LinkLabel, NotifyIcon, ToolStrip
Menu MenuStrip, ContextMenuStrip
Aide utilisateur HelpProvider, ToolTrip
d'autres contrôles du groupe Panel, GroupBox, TabControl, SplitContainer, TableLayoutPanel, FlowLayoutPane
Propriétés du contrôle
Nom de la propriété Description
Anchor Obtenir ou définir les liaisons du contrôle au bord du conteneur et détermine comment le contrôle se redimensionne avec son parent
BackColor La couleur d'arrière-plan du contrôle
Bottom Sous le contrôle La distance entre le bord et le bord supérieur de la zone client de son conteneur (unité : pixels)
Dock Obtient ou définit la bordure du contrôle ancrée à son contrôle parent et détermine comment le contrôle se redimensionne avec son parent
Enabled Si le contrôle peut répondre à l'interaction de l'utilisateur
ForeColor La couleur de premier plan du contrôle
Hauteur La hauteur du champ
Gauche La distance (en pixels) entre le bord gauche du champ et le bord gauche de la zone client de son conteneur
Emplacement Le coin supérieur gauche du contrôle par rapport aux coordonnées du coin supérieur gauche de son conteneur.
Nom Le nom du contrôle Ce nom peut être utilisé pour référencer le contrôle dans le code.
Parent Le conteneur parent du contrôle
Droite La distance entre le bord droit du contrôle et le bord gauche de la zone client de ​​son conteneur (unité : pixels)
Taille La hauteur et la largeur du contrôle
TabIndex L'ordre de tabulation du contrôle
TabStop Indique si l'utilisateur peut utiliser la touche Tab pour placer le focus sur le contrôle.
Texte Le texte associé à ce contrôle
Haut La distance (en pixels) entre le bord supérieur du contrôle et le bord supérieur de la zone client de son conteneur
Visible Indique s'il faut afficher le champ
Largeur La largeur du champ
BoutonContrôle
Le contrôle Button (bouton) se trouve dans l’espace de noms .NET Framework System.Windows.Forms, qui est dérivé de la classe de base ButtonBase. La classe de base ButtonBase est utilisée pour implémenter les opérations de base requises par les contrôles de boutons.


Le contrôle par bouton est un contrôle couramment utilisé. Lorsque les utilisateurs doivent effectuer des sélections telles que « OK » ou « Annuler », le contrôle par bouton est généralement utilisé. Le contrôle Button prend en charge les opérations de clic de souris et de double-clic et peut également être utilisé avec la touche 604dcb765a48d8d44d65da3c957a4ba5.
Lors de la conception, vous ajoutez généralement un contrôle sur le formulaire, puis double-cliquez dessus et écrivez le code pour l'événement Click. Lorsque le programme est exécuté, cliquer sur le bouton exécutera le code dans l'événement Click.
Attribut Name : utilisé pour définir le nom de l'objet pour référence dans le code.


Le système nomme automatiquement le contrôle Button bouton1, bouton2...
Il est préférable de définir un nom significatif pour la propriété Nom.
La propriété Name de divers objets de contrôle ne peut être modifiée que via la fenêtre "Propriétés". Cette propriété est valide au moment de la conception et est en lecture seule au moment de l'exécution.
Attribut de texte : le texte du titre affiché sur le bouton sous forme de texte.
En plus de cliquer sur le bouton, vous pouvez également définir "Alt + touche de raccourci" pour le bouton, voir Figure 7-2 sur P155.
Définissez la méthode en ajoutant un caractère "&" avant la lettre de la touche de raccourci.
Par exemple : bouton1.Text = "OK (&Y)"; //Le titre affiché est "OK (Y)"


Attribut Visible : détermine si le bouton est visible
La valeur de l'attribut est true pour être visible, false pour se cacher.


Lorsqu'un contrôle est invisible, il ne peut pas répondre aux opérations de la souris et du clavier de l'utilisateur.
La propriété Visible prend effet au moment de l'exécution.


Attribut activé : détermine si le bouton est valide.
Lorsque la valeur de l'attribut est fausse, le texte du bouton s'affiche en gris et ne répond pas aux opérations de l'utilisateur.

Attribut FlatStyle : détermine le style du bouton, la valeur est de type énumération FlatStyle
Le type d'énumération FlatStyle a 4 valeurs d'énumération, à savoir Flat (affichage plat), Popup (affichage plat, mais souris lorsqu'elle est déplacée, l'apparence est tridimensionnelle), Standard (affichage tridimensionnel) et Système (l'apparence est déterminée par le système d'exploitation). L'effet est illustré dans la figure 7-3 sur P156.
La propriété FlatStyle du contrôle Button est par défaut Standard.
Propriété Image : Spécifier une image à afficher sur le bouton
Propriété ImageAlign : Définir l'alignement de l'image sur le bouton
Contrôle Label
Fonction : Principalement utilisée pour afficher du texte sur le formulaire
Nom du contrôle :
Label : label Windows standard ;
LinkLabel : similaire à Label, mais affiché sous la forme de hyperlien L'effet est illustré dans la figure 7-4.
Généralement, il n'est pas nécessaire d'ajouter du code de gestion des événements au contrôle Label, mais les événements peuvent également être pris en charge si nécessaire
Propriétés communes des contrôles label
Nom de la propriété Description
BorderStyle Le style de bordure du contrôle, la valeur par défaut est sans bordure
FlatStyle Définit l'apparence du style plat. S'il est défini sur PopUp, cela signifie un style plat Lorsque la souris pointe dessus, le contrôle apparaîtra dans un style pop-up.
Image L'image affichée sur le Label
ImageAlign L'alignement de l'image affichée dans le contrôle
LinkArea Le texte affiché sous forme de link Range (uniquement pour LinkLabel)
LinkColor La couleur utilisée lors de l'affichage des liens ordinaires (uniquement pour LinkLabel)
Links Obtenir la collection de liens contenus dans LinkLabel (Uniquement pour LinkLabel)
LinkVisited Le lien apparaît-il comme lien visité (uniquement pour LinkLabel)
TextAlign ? Alignement du texte dans l'étiquette
VisitedLinkColor La couleur utilisée lors de l'affichage des liens précédemment visités (uniquement pour LinkLabel)
Contrôle de zone de texte
.NET FrameWork possède deux contrôles de zone de texte intégrés : le contrôle TextBox et le contrôle RichTextBox. Ils dérivent tous de TextBoxBase, qui dérive de la classe Control.
TextBoxBase fournit des fonctions de base pour le traitement du texte dans les zones de texte, telles que la sélection de texte, le couper-coller et les événements associés. Le but de
TextBox est principalement de permettre aux utilisateurs de saisir du texte. Vous pouvez également spécifier le type de caractères saisis par l'utilisateur, par exemple en autorisant uniquement des valeurs numériques. Par défaut, une zone de texte peut saisir jusqu'à 2 048 caractères. Si vous définissez la propriété Multiline sur true, vous pouvez saisir jusqu'à 32 ko de texte. Le texte utilisateur est stocké dans la propriété Text et le texte saisi par l'utilisateur peut être obtenu en référençant la propriété Text dans le programme. RichTextBox est principalement utilisé pour afficher et saisir du texte formaté (TextBox est souvent utilisé pour saisir des caractères de texte plus courts). RichTextBox peut afficher des polices, des couleurs et des liens, charger du texte à partir de fichiers et charger des images intégrées, et rechercher des caractères spécifiés. une zone de texte améliorée.


Contrôle TextBox
Nom de la propriété Description
CausesValidation ? S'il faut vérifier la validité de la saisie de l'utilisateur
CharacterCasing S'il faut modifier le format de casse des caractères lors de la saisie
MaxLength ? Définir le nombre maximum de caractères pouvant être saisis, si =0, il n'y a pas de limite
Multiligne Est-ce possible ? Afficher un texte multiligne
PasswordChar Définir le caractère d'affichage du mot de passe
ReadOnly ? Si le texte est en lecture seule
ScrollBars Obtenir ou définir quelles barres de défilement doivent apparaître dans un contrôle TextBox multiligne
SelectedText? Représente le texte actuellement sélectionné
SelectionLength? Le nombre de caractères actuellement selected
SelectionStart? Le point de départ du texte actuellement sélectionné
Texte Texte actuel
WordWrap? Si pour envelopper automatiquement les lignes
Nom de l'événement Description
Entrée ? Se produit lors de la saisie du contrôleCes 4 événements sont déclenchés dans l'ordre indiqué, ils sont appelés « événements de focus » lorsque le focus du contrôle change est déclenché, mais Validating et Validatingd ne sont déclenchés que lorsque le contrôle reçoit le focus et que son CausesValidation est défini sur trueLeave?
Se produit lorsque le focus d'entrée quitte le contrôleValidating?
Se produit pendant la validation du contrôleValidé
Se produit lorsque le contrôle termine la validation
KeyDown Ces trois événements sont collectivement appelés « événements clés » et sont utilisés pour surveiller et modifier le contenu saisi dans le contrôle KeyDown et KeyUp ? qui peut être utilisé pour déterminer si une touche spéciale est enfoncée, telle que Shift , Ctrl ou F1. KeyPress reçoit les caractères correspondant à la toucheKeyPress
KeyUp?
TextChanged?
Tant que le texte dans la zone de texte change, cet événement sera déclenché Contrôle RichTextBox
Nom de l'attribut
Description CanRedo?
Indique s'il existe des opérations pouvant être réappliquées parmi les opérations survenues dans la RichTextBox CanUndo?
Indique que l'utilisateur est dans le texte L'opération précédente peut-elle être annulée dans le contrôle box ? DetectUrls
Lorsqu'une URL est saisie dans le contrôle, la RichTextBox définira-t-elle automatiquement le format de l'URL Rtf
Est-elle identique à la propriété Text ? Similaire, mais peut inclure du texte au format RTF SelectedRtf
Obtenir ou définir le texte formaté au format RTF actuellement sélectionné dans le contrôle. SelectedText
Obtenir ou définir la sélection dans RichTextBox Définir le texteSelectionAlignment
L'alignement du contenu sélectionné ou du point d'insertion, peut être Cente, Left ou RightSelectionBullet ?
Indique si le style de puce est appliqué à la sélection ou au point d'insertion actuelBulletIndent?
Spécifie la valeur du pixel d'indentation de la puceSelectionColor
Obtient ou définit la couleur du texte du texte ou du point d'insertion actuellement sélectionnéSelectionFont
Obtient ou définit la police du texte ou du point d'insertion actuellement sélectionnéSelectionLength?
Obtient ou définit le nombre de caractères sélectionnés dans le contrôleShowSelection
Margin Si cet attribut est défini sur true, une marge apparaîtra sur le côté gauche de la RichTextBox pour faciliter la sélection de texteUndo
ActionName Get call Le nom de l'opération annulable dans le contrôle après la méthode Undo SelectionProtected
Définissez cet attribut sur true pour spécifier que certains certaines parties du texte ne doivent pas être modifiées Contrôle RadioButton
Nom de la propriété
DescriptionApparence Obtient ou définit une valeur qui détermine l'apparence du RadioButton.
Valeurs facultatives : Normal et Bouton. Chaque type peut afficher du texte ou des images, ou les deux.
Apparence après avoir sélectionné Normal : . Apparence après avoir sélectionné le bouton :
AutoCheck Si cet attribut est vrai, lorsque l'utilisateur clique sur le bouton radio, une coche s'affichera. Si cette propriété est fausse, vous devez cocher manuellement le bouton radio
CheckAlign dans le code du gestionnaire d'événement Click pour changer la forme d'alignement de la case à cocher du bouton radio, la valeur Peut être l'une des valeurs valides de l'énumération ContentAlignment. La valeur par défaut est MiddleLeft, ce qui signifie que le contenu est aligné au milieu verticalement et aligné horizontalement à gauche
Checked Obtient ou définit une valeur indiquant si le contrôle a été sélectionné. Si le contrôle est sélectionné, il est vrai, sinon il est faux
Contrôle GroupBox
Le contrôle GroupBox (zone de groupe) est utilisé pour fournir un regroupement identifiable pour d'autres contrôles. En règle générale, vous utilisez des zones de groupe pour subdiviser votre formulaire par fonction.
Lorsqu’un seul contrôle GroupBox est déplacé, tous les contrôles qu’il contient se déplacent également ensemble.
Lors de la création d'un contrôle GroupBox et de ses contrôles internes sur un formulaire, vous devez d'abord créer le contrôle GroupBox, puis créer divers contrôles à l'intérieur de celui-ci.
Contrôle du panneau
Le contrôle Panel (panneau) est similaire au contrôle GroupBox. La différence entre les deux est que seul le contrôle GroupBox peut afficher un titre et que seul le contrôle Panel peut avoir des barres de défilement.
Pour afficher les barres de défilement, définissez la propriété AutoScroll sur true.
Vous pouvez personnaliser l'apparence du panneau en définissant les propriétés BackColor, BackgroundImage et BorderStyle.
Contrôle TabControl
Nom de la propriété Description
Alignement Contrôlez la position d'affichage de l'onglet dans le contrôle, la valeur par défaut est le haut du contrôle
Apparence Contrôlez la façon dont les onglets sont affichés. Les onglets peuvent être affichés sous forme de boutons normaux ou avec un style plat
HotTrack Si c'est vrai, lorsque le pointeur de la souris se déplace sur l'onglet du contrôle, c'est l'apparence changera
Multiline Si vrai, les onglets peuvent être affichés sur plusieurs lignes
RowCount Renvoie l'onglet actuellement affiché Nombre de lignes
SelectedItem Obtient ou définit l'index de la page à onglet actuellement sélectionnée
SelectedTab Obtient ou définit la page à onglet actuellement sélectionnée. Cette propriété se trouve dans TabPages Utilisez
TabCount sur l'instance pour obtenir le nombre d'onglets dans la bande d'onglets. TabPages
Obtenir la collection de pages à onglet dans le contrôle onglet Utilisez cette collection pour ajouter et supprimer des objets TabPages

Propriétés communes StatusStrip des volets dans le contrôle
Nom de la propriété
DescriptionAutoSize
S'il faut ajuster automatiquement la taille de l'élément en fonction de l'image et du texte de l'élémentAlignement
Définir le volet supérieur de le contrôle StatusStrip Alignement, les options incluent : Center, Left et RightBorderStyle
Définissez le style de la bordure du volet Les options sont les suivantes : Aucun : Ne pas afficher la bordure en relief ; : Le volet est convexe en trois dimensions Enfoncé : Le volet est affiché en mode relief tridimensionnel
Image
Définir l'icône affichée par le voletTaille minimale
Définir l'icône du volet dans la barre d'état Largeur minimalePrintemps
Si l'élément spécifié remplit l'espace restantTexte
Définir le texte affiché du voletLargeur
Définir le volet La largeur, en fonction du paramètre de la propriété AutoSize, la valeur de la propriété peut changer lorsque la taille du formulaire change

La méthode Show renverra une valeur d'énumération DialogResult indiquant le valeur de retour de la boîte de dialogue
Membre
DescriptionAbandonner
La valeur de retour de la boîte de dialogue est Abandonner (généralement envoyée à partir du bouton intitulé « Abandonner ») ? Annuler
Dialogue La valeur de retour de la boîte de dialogue est Annuler (généralement envoyée à partir du bouton intitulé "Annuler") ?Ignorer
La valeur de retour de la boîte de dialogue est Ignorer (généralement envoyée à partir du bouton intitulé "Ignorer") ?Non
La valeur de retour de la boîte de dialogue est Non (généralement envoyée à partir du bouton intitulé "Non") ?Aucun n'a renvoyé Rien de la boîte de dialogue. Cela indique que la boîte de dialogue modale continue de s'exécuter ?
OK La valeur de retour de la boîte de dialogue est OK (généralement envoyée à partir d'un bouton intitulé "OK") ?
Réessayer Boîte de dialogue La valeur de retour de la boîte de dialogue est Réessayer (généralement envoyée à partir du bouton intitulé "Réessayer") 
Oui La valeur de retour de la boîte de dialogue est Oui (généralement envoyée à partir du bouton intitulé "Oui" ? ) 


Driver
.NET Framework fournit la classe DriveInfo et le type d'énumération DriverType pour faciliter l'utilisation directe des lecteurs dans les programmes. La classe DriveInfo et l'énumération DriverType se trouvent dans l'espace de noms System.IO.
Classe DriveInfo
Rôle : Détermine les informations sur le lecteur, y compris la lettre du lecteur, le type de lecteur, l'espace disponible sur le lecteur, etc.
Membres communs :
Champ : DriveFormat ( Format du système de fichiers , tel que NTFS ou FAT32), DriveType (type de lecteur), Name (nom du lecteur), TotalSize (espace total), TotalFreeSpace (espace disponible)
Méthode : GetDrives (obtenir la liste de lecteurs disponibles)
type d'énumération parType
Les valeurs d'énumération incluent CDRom (lecteur optique), Fixe (disque dur), Réseau (lecteur réseau), Amovible (disquette ou disque U), etc.
Répertoire
fourni par .NET FrameworkClasse Directoryclasse DirectoryInfo pour faciliter la manipulation directe des répertoires dans le programme. Les classes Directory et DirectoryInfo se trouvent dans l'espace de noms System.IO et peuvent être utilisées pour créer, copier, déplacer ou supprimer des répertoires.
Classe de répertoire
Caractéristiques : Classe statique, ses membres de méthode peuvent être appelés directement, mais chaque membre de méthode appelé doit effectuer un contrôle de sécurité pour déterminer les autorisations d'opération de l'utilisateur.
Membres de la méthode commune : CreateDirectory (créer un nouveau répertoire), Delete (supprimer le répertoire), Exists (déterminer si le répertoire existe), Move (déplacer le répertoire), GetFiles (obtenir la liste des fichiers du répertoire), GetDirectories (Obtenir une liste de sous-répertoires), etc.
Classe DirectoryInfo
Caractéristiques : classe non statique (doit être instanciée), une instance doit être créée avant que ses membres de méthode puissent être appelés, et des contrôles de sécurité sont effectués lors de la création d'une instance.
Membres du champ commun ; Nom (nom du répertoire d'extraction), Exists (s'il existe), Parent (répertoire parent), Root (répertoire racine)
Membres de la méthode commune : Create (créer un répertoire), CreateSubDirectory (créer un sous-répertoire) , Supprimer (supprimer le répertoire), MoveTO (déplacer le répertoire), GetFiles, GetDirectories, etc.
Exemple de code : P197
File
NET Framework fournit la classe File et la classe FileInfo pour faciliter le programme manipuler directement les fichiers. Les classes File et FileInfo se trouvent dans l'espace de noms System.IO et peuvent être utilisées pour créer, copier, supprimer, déplacer, ouvrir des fichiers et d'autres opérations.
Classe de fichiers
Caractéristiques : Classe statique, ses membres de méthode peuvent être appelés directement.
Membres de la méthode commune : Open (ouvrir un fichier), Create (créer un nouveau fichier), Copy (copier un fichier), Supprimer (supprimer un fichier), Exists (déterminer si un fichier existe), Move (déplacer un fichier ), Remplacer (remplacer un fichier) ), AppendAllText (créer un nouveau fichier et ajouter du texte), ReadAllText (ouvrir et lire le contenu du texte), etc.
Classe FileInfo
Caractéristiques : Classe non statique, vous devez d'abord créer une instance.
Membres du champ commun : Nom (nom du fichier extrait), Répertoire (répertoire auquel il appartient), Exists (s'il existe), Extension (extension du fichier), Longueur (longueur du fichier), IsReadOnly (s'il s'agit d'un fichier en lecture). uniquement le fichier)
Membres de la méthode commune : Open, Create, CopyTo (copier dans un nouveau fichier), Delete, MoveTo (déplacer le fichier), Replace, EnCrypt (crypter le fichier), Decrypt (déchiffrer le fichier) , etc.
Exemple de code : P198
Chemin
L'emplacement du fichier est appelé le chemin. Le chemin comprend la lettre du lecteur, le nom du répertoire, le nom du fichier, l'extension du fichier et le délimiteur.
Comment exprimer le chemin
Chemin absolu : commencez à écrire à partir du répertoire racine du lecteur, tel que C:WindowsSystem32notepad.exe
Chemin relatif : commencez à écrire à partir de l'emplacement du répertoire actuel, tel que System32nodepad.exe (en supposant que le répertoire actuel est C :Windows)
C# traite le caractère "" comme un caractère d'échappement, donc lorsque le chemin est exprimé sous forme de chaîne, utilisez deux barres obliques inverses, par exemple :
"C:\Windows\ System32\notepad.exe"
C# permet d'ajouter le signe "@" avant une chaîne pour demander au compilateur de ne pas traiter le caractère "" comme un caractère d'échappement mais comme un caractère ordinaire, par exemple :
@"C :WindowsSystem32notepad.exe ”
NET Framework fournit la classe Path pour aider à gérer les chemins de fichiers et de répertoires dans les programmes. La classe Path se trouve dans l'espace de noms System.IO et est une classe statique.
Fonction de classe Path : classe statique, utilisée pour exploiter chaque champ du chemin, tel que la lettre de lecteur, le nom du répertoire, le nom du fichier, l'extension et le délimiteur du fichier, etc.
Membres du champ commun du chemin : PathSeparator (séparateur de chemin), DirectorySeparatorChar (séparateur de répertoire), VolumeSeparatorChar (séparateur de volume)
Membres de la méthode commune du chemin : GetDirecotryName (obtenir le nom du répertoire), GetFileName (obtenir le nom du fichier), GetExtension (obtenir l'extension du fichier) , GetFullPath (obtenir le chemin complet), GetTempPath (obtenir le chemin du fichier temporaire du système d'exploitation), etc. Le flux


comprend les opérations de base suivantes.
Lire (lire) : signifie transférer des données d'un flux vers une certaine structure de données, comme la sortie vers un tableau d'octets
Écrire (écrire) : signifie transférer des données d'une certaine structure de données vers un flux, par exemple ; , transmettre des données dans un tableau d'octets vers un flux ;
positionnement (recherche) : signifie interroger ou déplacer la position actuelle dans le flux.
Classes pour les flux d'exploitation
(1) Classe Stream
La classe Stream est la classe de base abstraite pour tous les flux.
Principaux attributs de la classe Stream : CanRead (si la lecture est indiquée), CanSeek (si la recherche est supportée), CanTimeout (si le timeout est possible), CanWrite (si l'écriture est supportée), Longueur (longueur du flux), Position (obtenir ou définir la position dans le flux actuel), ReadTimeout (obtenir ou définir le délai d'attente pour l'opération de lecture), WriteTimeout (obtenir ou définir le délai d'attente pour l'opération d'écriture)
La méthode principale de la classe Stream : BeginRead (démarrer l'opération de lecture asynchrone), BeginWrite (démarrer l'opération d'écriture asynchrone), Close (fermer le flux en cours), EndRead (terminer l'opération de lecture asynchrone), EndWrite (terminer l'opération d'écriture asynchrone), Flush (effacer tous les tampons du flux et écrire les données mises en mémoire tampon sur le périphérique de base), Read (lire une séquence d'octets), ReadByte (lire un octet), Seek (définir la position de recherche), Write (écrire une séquence d'octets) , WriteByte (section écrire un mot)
(2) Classes StreamReader et StreamWriter
Généralement utilisée pour faire fonctionner des fichiers texte
La classe StreamReader StreamReader est utilisée pour lire les caractères d'un flux d'octets dans un encodage spécifique.
La classe StreamWriter est utilisée pour écrire des caractères dans un flux dans un encodage spécifique.
(3) Classes FileStream, MemoryStream et BufferStream
Classe File stream FileStream : lit, écrit, ouvre et ferme des fichiers sous forme de flux.
Classe MemoryStream : Indique la création d'un flux en mémoire pour enregistrer temporairement des données. Avec elle, il n'est pas nécessaire de créer des fichiers temporaires sur le disque dur.
CacheClasse Stream BufferStream : ajoutez d'abord le flux au tampon, puis effectuez des opérations de lecture/écriture. L'utilisation du tampon peut réduire le nombre d'appels au système d'exploitation lors de l'accès aux données.
Notez que la classe FileStream dispose également d'une fonction de mise en mémoire tampon. Lors de la création d'une instance de la classe FileStream, il vous suffit de spécifier la taille du tampon.
Lire et écrire des fichiers texte
Un fichier texte est un fichier composé de données textuelles pures, qui enregistre uniquement l'encodage des caractères.
Le codage de caractères pris en charge par NET Framework
peut être ASCIIEncoding, UTF7Encoding, UTF8Encoding, UnicodeEncoding ou UTF32Encoding
La lecture et l'écriture de fichiers texte dans .NET Framework utilisent principalement :
Lecteur de fichiers Classe TextReader et rédacteur de texte TextWriter classe
et leurs classes dérivées, classe StreamReader de lecteur de flux et classe Stream Writer de streamwriter
ou classes StringReader et StringWriter
Méthodes courantes de la classe TextReader et de ses classes dérivées :
Close (Ferme le lecteur et libère les ressources système ), Read (lire le caractère suivant, s'il n'existe pas, renvoyer -1), ReadBlock (lire un bloc de caractères), ReadLine (lire une ligne de caractères), ReadToEnd (lire depuis la position actuelle vers tous les caractères jusqu'au end)
Méthodes communes de la classe TextWriter et de ses classes dérivées :
Close (ferme le rédacteur et libère les ressources système), Flush (efface tous les tampons du rédacteur actuel, afin que toutes les données mises en mémoire tampon soient écrites dans la base Device), Write (écrire un flux de texte), WriteLine (écrire une ligne de données)
ASP.NETIntroduction
ASP.NET est une technologie de conception Web dynamique qui est meilleure que toute autre. la technique de conception Web dynamique est plus facile à utiliser. Il s'agit d'une technologie de développement d'applications Web évolutive particulièrement efficace pour l'interaction avec les utilisateurs et le traitement des données.
ASP.NET n'est pas un langage de programmation. C'est un framework de programmation basé sur le .NET Framework. Il est utilisé pour créer des applications Web.
La syntaxe d'ASP.NET est compatible avec ASP, mais les applications ASP ne peuvent pas s'exécuter directement dans l'environnement ASP.NET et doivent être modifiées en conséquence.
La plus grande différence entre ASP.NET et ASP est que le premier est une technologie de page Web dynamique compilée, tandis que le second est une technologie de page Web dynamique interprétée.
Les versions les plus populaires d'ASP.NET sont la version 1.1, la version 2.0 et la version 3.0. ASP.NET publié avec Visual Studio.NET 2003 est la version 1.1 et ASP.NET publié avec Visual Studio.NET 2005 est la version 2.0. ASP.NET, publié en 2007 avec Visual Studio.NET 2008, est la version 3.0.
Avantages d'ASP.NET
Bonne gestion
Haute sécurité
Facile à déployer
Les performances sont grandement améliorées par rapport à ASP et JSP
Technologie de mise en cache de sortie flexible
Grâce à l'encodage Unicode, l'internationalisation est obtenue
Prend en charge les appareils mobiles
Bonne évolutivité et convivialité
Fournit des services de suivi et des débogagefonctions
Intégré dans .NET Framework, fonctions puissantes
Base de données la connexion utilise la technologie ADO.NET
Étapes générales pour la conception d'une application Web
Étapes opérationnelles pour la conception d'une application Web à l'aide de VS 2005
S1 : Créer un nouveau site Web
S2 : Définir l'emplacement du site Web
S3 : Ajouter des pages Web
S4 : Concevoir des formulaires Web
S5 : Définir les propriétés des formulaires et des contrôles de formulaire
S6 : Écrire des programmes
S7 : Exécuter des applications Web
S8 : Afficher les résultats en cours d'exécution
Remarque, pour plus de détails, veuillez vous référer au manuel
(1) Générer une application Web
Comment fonctionner : dans la fenêtre Explorateur de solutions de Visual Studio .NET 2005, cliquez avec le bouton droit sur le nom du site Web et sélectionnez " Générer un site Web »
(2) Vérifiez si le serveur Web est normal
Si vous souhaitez publier sur l'ordinateur local, vous devez vérifier si l'ordinateur local est installéIIS
Vérifiez si IIS est fonctionne correctement


Tables, enregistrements et champs
Les systèmes de bases de données relationnelles utilisent le modèle relationnel comme moyen d'organiser les données.
Tableau est un groupe de données similaires stockées dans une structure commune, similaire à la table de la vie quotidienne.
Les tableaux organisent les informations associées en groupes logiques en lignes et en colonnes. Chaque ligne du tableau est appelée un enregistrement.
Les colonnes sont appelées champs
Base de données
La base de données représente une table de données comme une collection de plusieurs tables et définit la structure de la base de données en établissant des relations entre les tables
La clé dite primaire fait référence à la identification unique de la table Un champ ou un ensemble de champs dans un enregistrement. Les clés primaires n'autorisent pas les valeurs en double.
La clé étrangère fait référence à un champ utilisé pour connecter une autre table et servir de clé primaire dans une autre table.
Index
Dans les bases de données relationnelles, les index sont souvent utilisés pour améliorer la vitesse de récupération des données.
Les enregistrements sont stockés dans la table dans l'ordre physique de saisie. Lors de l'indexation de la clé primaire ou d'autres champs, le système de gestion de base de données enregistre le contenu des champs d'index dans un fichier d'index dans un ordre spécifique.
Lors de la récupération des données, le système de gestion de base de données trouve d'abord l'emplacement des informations dans le fichier d'index, puis lit les données dans la table.
Chaque index a une expression d'index pour déterminer l'ordre de l'index. L'expression d'index peut être soit un champ, soit une combinaison de plusieurs champs.
Plusieurs index peuvent être générés pour une table, et chaque index représente une séquence de données de traitement.
Relation
Le plus grand avantage d'une base de données relationnelle est qu'elle peut éviter la duplication inutile de données, c'est-à-dire qu'elle peut diviser une table contenant des données en double en plusieurs tables simples sans données en double et établir des relations entre les tables. pour récupérer des enregistrements dans des tables liées.
Dans la relation entre les tables, il est d'usage d'appeler la table principale la table parent, et les autres tables connectées via la relation sont des tables enfants.
Il peut y avoir 4 types de relations entre les tables
Relation un-à-un : signifie qu'un enregistrement de la table parent ne peut correspondre qu'à un seul enregistrement de la table enfant, et vice versa
Un ; Relation -à plusieurs : fait référence aux enregistrements de la table parent qui sont liés à plusieurs enregistrements de la table enfant. Par exemple, pour la table des clients et la table des commandes, chaque commande n'est liée qu'à un seul client, et chaque client peut avoir plusieurs commandes, donc la table des clients et la table des commandes ont une relation un-à-plusieurs ; Relation -à-un : Complémentaire au un-à-plusieurs, c'est-à-dire que plusieurs enregistrements de la table parent sont liés à un enregistrement de la table enfant
Relation plusieurs-à-plusieurs : fait référence à plusieurs enregistrements dans la table parent ; table et plusieurs enregistrements dans la table enfant liés.
Introduction à SQL
Le langage SQL (Structured Query
Language) est un langage de base de données relationnelle complet et général dont les fonctions incluent l'interrogation, la manipulation, la définition et le contrôle. Actuellement, il existe 3 versions du standard SQL.
SQL-89
SQL-92
SQL3
Transact-SQL utilisé par Microsoft SQL Server est développé sur la norme SQL-92.
Composition de SQL
SQL est composé d'éléments tels que des commandes, des clauses et des opérateurs, qui sont combinés pour former des instructions permettant de créer, de
mettre à jour et de manipuler des données. Les commandes SQL sont divisées en deux catégories : les commandes DDL (langage de définition de données) et les commandes DML (langage de manipulation de données). Les commandes DDL sont utilisées pour créer et définir de nouvelles bases de données, champs et index, comprenant principalement des instructions : créer, supprimer, modifier. Les commandes DML sont utilisées pour créer des requêtes pour trier, filtrer et extraire des données de la base de données. Elles incluent principalement des instructions : sélectionner, insérer, mettre à jour et supprimer. P258
Les clauses SQL permettent de définir les données à sélectionner ou à manipuler.


instruction select La fonction de l'instruction
select est de récupérer des données à partir d'une base de données existante.

clause from précise la source des données, c'est-à-dire indique de quelles tables proviennent les enregistrements.
clause Where précise les conditions à remplir lors de la sélection des enregistrements. La clause group by regroupe les enregistrements.
La clause have détermine quels enregistrements sont spécifiquement affichés dans la requête avec la clause group by. Vous pouvez utiliser la clause have pour afficher les groupes qui répondent aux conditions spécifiées.
La clause order by trie les enregistrements. Pour un exemple de l'instruction
, voir P258-260 Instruction
delete La fonction de l'instruction
delete est de supprimer les enregistrements dans une ou plusieurs tables répertoriées dans la clause from et qui remplissent les conditions de la clause Where clause.
Par exemple :
delete from Orders Where OrderId=16
insert Statement
insert Statement est utilisé pour ajouter des enregistrements à la table.
Par exemple :
insérer dans les commandes
(CustID,ProductID,OrderDate,SendDate,Qty)
values('2','5','2008-8-12','2008- 8 -13',1)
instruction update
instruction update met à jour les valeurs des champs dans une table spécifique selon une certaine condition.
Par exemple :
update Products set Price=8900 which Products.ProductId=3
Aperçu d'ADO.Net
ADO.NET est la technologie d'accès aux bases de données la plus récente et la plus puissante de Microsoft. Les applications peuvent utiliser ADO.NET. accéder et traiter facilement les données stockées dans diverses bases de données.
ADO.NET regroupe de nombreuses classes pour le traitement des données. Ces classes disposent de puissantes fonctions d'accès et de traitement des données, telles que l'indexation, le tri, la navigation et la mise à jour.
ADO.NET est intégré au .NET Framework et peut être utilisé dans n'importe quel langage informatique prenant en charge .NET, tel que C#.
ADO.NET inclut principalement l'espace de noms System.Data et ses espaces de noms imbriqués, ainsi que certaines classes spéciales liées à l'accès aux données telles que l'espace de noms system.Xml.
Data Provider
Data Provider fournit la connexion entre DataSet et la base de données, et comprend également une série d'interfaces pour accéder à la base de données. Les données provenant de diverses sources de données sont facilement accessibles via les interfaces de programmation d'applications (API) fournies par les fournisseurs de données.
Les fournisseurs de données .NET incluent les éléments suivants :
Fournisseur de données SQL Server .NET, utilisé pour les sources de données Microsoft SQL Server, à partir de l'espace de noms System.Data.SqlClient
Fournisseur de données OLE DB .NET, utilisé pour ; Sources de données exposées OLE DB. Les sources de données proviennent de l'espace de noms System.Data.OleDb ;
fournisseur de données ODBC.NET, utilisé pour ODBC. Fournisseur de données Oracle .NET pour les sources de données Oracle, à partir de l'espace de noms System.Data.OracleClient.
Fournisseur de données
Le fournisseur de données .NET comporte 4 objets principaux :
L'objet Connexion est utilisé pour établir une connexion avec la source de données ;
L'objet Commande est utilisé pour exécuter les commandes spécifiées sur la source de données ; 🎜>Objet DataReader Utilisé pour renvoyer un flux de données en lecture seule en avant uniquement à partir de la source de données
L'objet DataAdapter transforme automatiquement diverses opérations sur les données en instructions SQL correspondantes de la source de données.
DataSet
ADO.NET et le composant principal est le DataSet.
Vous pouvez considérer un DataSet comme une base de données en mémoire. Il s'agit d'un
ensemble de données
indépendant qui ne dépend pas de la base de données. Indépendant signifie que le DataSet est toujours disponible même si la connexion de données est déconnectée ou fermée. Dans ADO.NET, DataSet est spécialement utilisé pour traiter les données obtenues à partir de sources de données. Quelle que soit la nature des données sous-jacentes, la même méthode peut être utilisée pour exploiter les données obtenues à partir de différentes sources de données. DataSet utilise XML en interne pour décrire les données. XML est un langage de description de données indépendant de la plate-forme et des données et peut décrire des relations de données complexes.
Processus d'opération de la base de données ADO.NET
Utilisez d'abord l'objet Connexion
pour vous connecter à la base de données
Si vous exécutez une commande d'exécution de base de données ou une procédure stockée
qui le fait ne nécessite pas de résultat de retour, vous pouvez utiliser l'objet Command ; l'objet DataReader est utilisé pour lire les flux de données en avant uniquement et en lecture seule à partir de la source de données. DataSet est une représentation de données résidant en mémoire qui fournit un modèle de programmation relationnelle cohérent et indépendant de la source de données. DataSet représente l'intégralité de l'ensemble de données, qui contient des tables, des contraintes et des relations entre les tables.
L'interaction avec les sources de données existantes est contrôlée via DataAdapter. L'objet DataAdapter est utilisé pour obtenir des données de la source de données, remplir le DataSet, les tables et les contraintes, et soumettre les modifications apportées au DataSet à la source de données.
Utilisez l'objet Connection pour accéder à la base de données
Étapes pour vous connecter à la base de données
(1) Définissez la chaîne de connexion
Utilisez l'authentification SQL Server :
Source de données=nom du serveur=base de données ; nom ; ID utilisateur = Nom d'utilisateur ; Pwd = Mot de passe
Utiliser l'authentification Windows :
Source de données = Nom du serveur ; Catalogue initial = Nom de la base de données ;
Sécurité intégrée = Vrai
(2) Créer un objet de connexion
SqlConnection connection = new SqlConnection(connString);
(3) Ouvrez la connexion à la base de données
connection.Open();
Utilisez l'objet Command pour accéder à la base de données
Étapes pour utiliser ExecuteNonQuery( ):
( 1) Créer un objet de connexion ;
(2) Définir l'instruction SQL ;
(3) Créer un objet de commande
(4) Exécuter la méthode ExecuteNonQuery() ; Traiter en fonction du résultat renvoyé .

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