Introduction détaillée aux connaissances de base de C# dans ASP.NET

Cet article présente principalement les connaissances de base du C# dans ASP.NET. Il a une certaine valeur de référence, jetons-y un coup d'œil avec l'éditeur ci-dessous

Explication : En tant que framework de développementframeworkasp.net est désormais largement utilisé et sa base de développement est en en plus du front-end Le support linguistique le plus important pour les backends tels que html, css, JavaScript et ainsi de suite est C#. Ce qui suit est un résumé des principales connaissances de base utilisées pour l'apprentissage futur.

1. C# est un orienté objet langage de programmation , principalement utilisé pour développer des applications pouvant s'exécuter sur la plateforme .net. est un langage fortement typé, donc chaque variable doit avoir un type déclaré. Il existe deux types de données en C# : les types valeur et les types référence. (Lorsque les types valeur sont utilisés pour stocker des valeurs, les types référence sont utilisés pour stocker des références aux données réelles).

1. Type de valeur

Le type de valeur représente les données réelles et est stocké dans la pile. La plupart des types de base en C# sont des types numériques. Les types de valeur incluent les types simples, les types d’énumération et les types de structure.

Les types simples incluent les types numériques et les types booléens. (En général, choisissez le type numérique en fonction de vos besoins. Lorsque la valeur est petite, vous pouvez essayer de choisir le type d'octet).

2. Type de référence

Le type de référence représente un pointeur ou une référence à des données et peut stocker une référence à des données réelles. Lorsque le type référence est null, cela signifie qu'aucun objet n'est référencé. Les types de référence incluent les interfaces, les classes, les tableaux, les pointeurs, etc. Les cours comprennent des types de boxe, des délégués et des cours personnalisés. (Remarque : bien que la chaîne soit un type d'application, si l'opérateur d'égalité == ou != est utilisé, cela signifie comparer la valeur de l'objet chaîne).

3. Boxing et unboxing

En termes simples, la boxing est la conversion d'un type valeur en un type référence. De même, le déballage est une conversion d’un type référence en un type valeur. Grâce au déballage, vous pouvez utiliser des types de référence complexes tout comme des types simples, ce qui constitue également une fonctionnalité puissante de C#.

Exemples simples de boxing et de unboxing

class Test
 {
 static void Mian()
 {
  int i = 3;
  object a = i;//装箱
  int j = (int)a;//拆箱
 }
 }

Remarque : pendant le processus de boxing et de unboxing, tout type de valeur peut être considéré comme un type de référence d'objet. Lorsqu'une opération de boxe convertit une valeur

type en un type référence, aucune conversion explicite n'est requise ; tandis qu'une opération de déballage convertit un type référence en un type valeur, car elle peut contraindre Converts à tout type de valeur compatible, la conversion doit donc être effectuée explicitement.

2. Constantes et variables

1. Constantes : également appelées constantes, sont connues au moment de la compilation et restent inchangées pendant le fonctionnement. les constantes sont déclarées comme des champs. Lors de la déclaration, utilisez le

mot-clé const devant le type du champ. Les constantes doivent être initialisées lors de la déclaration. Les constantes peuvent être marquées comme publiques, privées, protégées, internes, protégées internes. Ces modificateurs d'accès définissent la manière dont les utilisateurs peuvent accéder à la constante.

2. Variables : Les règles de dénomination des variables doivent être conformes aux règles de dénomination du logo, et les

noms des variables doivent être aussi significatifs que possible pour une lecture facile. Les variables sont des quantités dont les valeurs changent continuellement au cours de l'exécution du programme. Elles sont généralement utilisées pour sauvegarder les données saisies lors de l'exécution du programme, les résultats intermédiaires obtenus par les calculs et les résultats finaux.

Les variables doivent être déclarées avant d'être utilisées. Les variables peuvent contenir une valeur d'un type donné. Lors de la déclaration d'une variable, vous devez également préciser son nom. La forme de déclaration d'une variable : [nom de la variable de type de données du modificateur d'accès].

Niveau d'accès du modificateur :

public : Rend le membre accessible de n'importe où

protected : Rend le membre accessible depuis la classe dans laquelle il est déclaré et Accès interne dans ses classes dérivées

private : rend le membre accessible uniquement depuis l'intérieur de la classe dans laquelle il est déclaré

interne : rend le membre accessible uniquement depuis l'assembly dans lequel il se trouve déclaré

3. Conversion de type

1. Conversion de type implicite

La conversion de type implicite signifie qu'il peut être effectué sans conversion de déclaration effectuée. Lors d'une conversion implicite, le compilateur peut effectuer la conversion

en toute sécurité sans vérification.

隐式类型转换表
源类型	目标类型
sbyte	short, int long double decimal
byte	short,ushort,int uint,ulong,float,double,decimal
short	int ,long,float,double,decimal
ushort	int ,uint,long ,ulong,float,double,decimal
int	long float,double,decimal
uint	long ulong float double decimal
char	ushort int unit long float double decimal
float	double
ulong	float double decimal
long	float double decimal

Remarque : une perte de précision se produira lors de la conversion du type simple int long ulong float en float.

2. Conversion de type explicite

La conversion de type explicite peut également être appelée conversion de type forcée, qui doit être effectuée dans le code Déclare le type à convertir. Si vous effectuez une conversion entre des types pour lesquels aucune conversion implicite n'existe, vous devez utiliser une conversion de type explicite.

La conversion de type forcée peut utiliser le mot-clé Convert pour effectuer une conversion forcée des types de données.

Par exemple : float f=123.345; ToInt32(f);

Remarque : Étant donné que la conversion de type explicite inclut toutes les conversions de type implicites et les conversions de type explicites, il est toujours possible d'utiliser une expression cast

from Convertit n'importe quel type numérique en n'importe quel autre type numérique.

4. Opérateurs et expressionsC# fournit un grand nombre d'opérateurs, qui spécifient quelles

opérations sont effectuées dans les expressions Symbole

. Une expression est un morceau de code qui peut être évalué et aboutit à une valeur, un objet, une méthode ou un espace de noms unique.

1, opérateurs arithmétiques et expressions arithmétiques

les opérateurs arithmétiques incluent + - * / et %. (C'est trop simple et ne sera pas décrit en détail) 2. Les opérateurs relationnels et les expressions relationnelles

Les opérateurs relationnels incluent : <. ;>! = == <= >= etc. (toutes les langues sont identiques) 3.

L'opérateur d'affectation

est utilisé pour attribuer une nouvelle valeur à une variable, une propriété, un événement ou un élément index . Les plus couramment utilisés sont : =, +=, -=, *=, /=, ^=, %=, <<= (affectation de décalage à droite), >>= (affectation de décalage à gauche), etc.

4. Opérateurs logiques et expressions logiques

Les opérateurs logiques incluent : & (opérateur ET) , ^ (exclusif OU opérateur), ! (pas d'opérateur), | (ou opérateur), utilisez des opérateurs logiques pour connecter les opérandes. 5. Opérateurs au niveau du bit

Les opérateurs au niveau du bit traitent leurs opérandes comme un ensemble binaire, chaque bit binaire peut prendre le valeur 0 ou 1. <>Déplacer vers la droite. 6. Autres opérateurs

Opérateurs d'incrémentation et de décrémentation : ++, --, a--, a++.

Opérateur conditionnel : ? : Renvoie l'une des deux valeurs basées sur la valeur d'une expression booléenne. Par exemple : int a=1; int b=2; a!=b?a++:a--; (Si a!=b, cette instance renvoie un résultat d'exécution de 2, sinon c'est 1). nouvel opérateur : utilisé pour créer des objets et appeler des constructeurs. Par exemple : int i=new int(); équivalent à int i=0;as Operator : utilisé pour effectuer des conversions entre types de référence compatibles. Par exemple : string s =someObject as string; L'opérateur as est similaire à un cast. Lorsque la conversion échoue, l'opérateur produit une valeur nulle au lieu de générer une valeur nulle.

7. Priorité des opérateurs

Basique> Shift >>

5. Traitement des chaînes

1. Comparer les chaînes

La classe String fournit une série de méthodes pour comparaison de chaînes, telle que CompareTo et Equals.

La méthode CompareTo est utilisée pour comparer si deux chaînes sont égales. Format : String.CompareTo(String); Renvoie le type numérique

La méthode Equals est utilisée pour déterminer si deux objets chaîne ont la même valeur. Format : String.Equals(String); Renvoie le type booléen

2. Positionnement et sa chaîne

Positionnement d'une des chaînes Utiliser l'IndexOf méthode à la position où le caractère ou Zichuan apparaît pour la première fois. Format : String.IndexOf(String) ; les paramètres représentent la chaîne à localiser. (Faites attention aux majuscules).

3. Formater la chaîne

.Net提供了一种灵活全面的方式，能够将任何数值、枚举、日期时间等基本数据类型表示为字符串。格式化由格式说明符的字符串表示，该字符串指示如何表示基类型。

格式为：String Format(String，Object);例如：

//格式化为Currency类型
string str1=String.Format("(C)Currency:{0:C}\n",-123.4556f);
//格式化为ShortDate类型
string str2=String.Format("(d)ShortDate:{0:d}\n",DateTime.Now);

4、截取字符串

SubString方法可以从指定字符串中截取子串。格式：String.SubString(Int32,Int32); 第一个参数表示子串的起始位置，第二个参数表示子串的结束位置。

5、分裂字符串

Split()方法可以把一个字符串按照某个分隔符分裂成一系列小的字符串。格式：String []Split(char[]);参数为分割字符串的数组。

string str="hello world";
string[] split=str.Split(new Char[]{'.','!'});
foreach(string s in split)
{
 if(s.Tirm()!='''')
 {
 Console.WriteLine(s);
 }
//或者修改为
 string []split=str.Split(','.'!');

6、插入和填充字符串

插入字符串：Insert()方法，用于在一个字符串的指定位置插入另外一个字符串，从而构造一个新的字符串。格式：String.Insert(int,String);第一个参数为指定插入的位置。

填充字符串：PadLeft()方法和PadRight()方法添加指定数量的空格实现左右对齐。格式：String PadLeft(int,char)。String PadRight(int Char);

7、删除和剪切字符串

删除字符串：Remove()方法用于在一个字符串的指定位置删除指定的字符。格式：String Remove(int ,int);第一个参数表示删除的位置，第二个参数表示删除字符的数量。

剪切字符串：常用的剪切首位的多余字符用到的方法有： Trim(),TrimStart(),TrimEnd()；格式如下：

String Trim(Char[]);//从字符串的开头和结尾处一处空白。
String TrimStart(Char[]);//从字符串的开头处移除字符串在字符数组中指定的字符。
String TrimEnd(Char[]);//从字符串的结尾处移除字符数组中指定的字符。

8、复制字符串

Copy()方法可以把一个字符串复制到另一个字符串中。格式：String Copy(String)；//参数为需要复制的字符串，方法返回目标字符串。

9、替换字符串

Replace()方法可以替换掉一个字符串中的某些特定的字符或者子串。格式：String Replace（string ,string ）；第一个参数为待替换子串，第二工人参数为替换后的新子串。

六、流程控制

1、分支语句

1>if... else语句

if(布尔表达式)

{ 代码片段1}

else{ 代码片段2}

2>switch语句

switch(条件)

{ case 条件1：

break;

'''''

}

2、循环语句

for（）循环

while()语句

do while语句

foreach语句

3、异常处理语句

try.....catch语句

try.....finally语句,finally块用于清除try块中分配的任何资源，以及运行任何即使在发生异常时也必须执行的代码。控制总是传递给finally块，与try块的退出方式无关。

try...catch..finally语句

throw语句，用于立即无条件地引发异常，控制永远不会到达紧跟在throw后面的语句。

七、数组

数组是从System.Array派生的引用类型。

1、数组的声明：

一般语法：type[]arrayName;type[,]arrayName;

2、初始化数据（数组初始化的方式很多，可以通过new运算符创建数组元素初始化为它们的默认值）

//举例
int []arr=new int[6];
int [,]arr=new int[2,3];
int []arr1=new int[3]{1,2,3};
int [,]arr2=new int[3,2]{{2,3},{5,5},{3,5}};
string []arr;
arr=new string[3]{"sd","dddd","aaaa"};
int [,]arr;
arr=new int[,]{{2,3},{4,5},{4,2}};
//创建数组时可以省略new和数组长度
string[]arr={"ddd","fff","sss"};
int [,]arr3={{2,3},{4,5},{3,2}};

3、数组的遍历

C#用foreach语句进行遍历数组，是一种简单的明了的方法来循环访问数组中的元素。

int []arr={2,3,6,3,2};
foreach(int i in arr){
 system.Console.write({0},i);
}

掌握以上的基本知识简单的asp.net开发后台部分就成功了一部分，学无止境。

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!