英文链接源链接 [8018]
contenteditable="true"

C# - Quick Guide 介绍

C#是由Microsoft开发并获得欧洲计算机制造商协会(ECMA)和国际标准组织(ISO)批准的一种现代的,通用的,面向对象的编程语言。

C#由Anders Hejlsberg及其团队在.Net Framework的开发过程中开发。

C#是为公共语言基础结构(CLI)设计的,它由可执行代码和运行时环境组成,允许在不同的计算机平台和体系结构上使用各种高级语言。

以下原因使C#成为广泛使用的专业语言-

  • 这是一种现代的通用编程语言
  • 它是面向对象的。
  • 它是面向组件的。
  • 这很容易学习。
  • 这是一种结构化语言。
  • 它产生高效的程序。
  • 它可以在各种计算机平台上进行编译。
  • 它是.Net Framework的一部分。

C#强大的编程功能

尽管C#的构造紧密遵循传统的高级语言,但C和C ++却是一种面向对象的编程语言。它与Java非常相似,它具有众多强大的编程功能,这使其受到了全世界众多程序员的青睐。

以下是C#的一些重要功能的列表-

  • 布尔条件
  • 自动垃圾收集
  • 标准库
  • 装配体版本控制
  • 属性和事件
  • 代表和活动管理
  • 易于使用的泛型
  • 索引器
  • 有条件的编译
  • 简单的多线程
  • LINQ和Lambda表达式
  • 与Windows集成

在线试用

我们已经在线设置了C#编程环境,因此您可以在线编译和执行所有可用的示例。它使您对正在阅读的内容充满信心,并可以使用不同的选项来验证程序。随意修改任何示例并在线执行。

使用 CodingGround 上的在线编译器尝试以下示例。

using System;

namespace HelloWorldApplication {
   
   class HelloWorld {

      static void Main(string[] args) {
         /* my first program in C# */
         Console.WriteLine("Hello World");
         Console.ReadKey();
      }
   }
}

对于本教程中给出的大多数示例,您将在我们的网站代码部分的右上角找到一个Try it选项,它将带您到在线编译器。因此,只需利用它并享受您的学习。

在本章中,我们将讨论创建C#编程所需的工具。我们已经提到C#是.Net框架的一部分,用于编写.Net应用程序。因此,在讨论运行C#程序的可用工具之前,让我们了解C#与.Net框架的关系。

.Net框架

.Net框架是一个革命性的平台,可帮助您编写以下类型的应用程序-

  • Windows applications
  • Web applications
  • Web services

.Net框架应用程序是多平台应用程序。该框架的设计方式使其可以从以下任何一种语言中使用:C#,C ++,Visual Basic,Jscript,COBOL等。所有这些语言都可以访问该框架并相互通信。

.Net框架由客户端语言(例如C#)使用的庞大代码库组成。以下是.Net框架的一些组件-

  • Common Language Runtime (CLR)
  • .Net框架 Class Library
  • Common Language Specification
  • Common Type System
  • Metadata and Assemblies
  • Windows Forms
  • ASP.Net and ASP.Net AJAX
  • ADO.Net
  • Windows Workflow Foundation (WF)
  • Windows Presentation Foundation
  • Windows Communication Foundation (WCF)
  • LINQ

有关每个组件执行的工作,请参见 ASP.Net-简介,并了解详细信息有关每个组件的信息,请查阅Microsoft的文档。

C#集成开发环境(IDE)

Microsoft为C#编程提供以下开发工具-

  • Visual Studio 2010(VS)
  • Visual C#2010 Express(VCE)
  • Visual Web Developer

后两个可从Microsoft官方网站免费获得。使用这些工具,您可以编写各种C#程序,从简单的命令行应用程序到更复杂的应用程序。您还可以使用基本的文本编辑器(如记事本)编写C#源代码文件,并使用命令行编译器将代码编译为程序集,而命令行编译器又是.NET Framework的一部分。

Visual C#Express和Visual Web Developer Express版本是Visual Studio的精简版本,并且外观相同。它们保留了Visual Studio的大多数功能。在本教程中,我们使用了Visual C#2010 Express。

您可以从 Microsoft Visual Studio 下载。它会自动安装在您的计算机上。

注意:您需要活动的Internet连接才能安装Express Edition。

在Linux或Mac OS上编写C#程序

尽管.NET Framework在Windows操作系统上运行,但是在其他操作系统上仍有一些替代版本。 Mono 是.NET Framework的开源版本,其中包括C#编译器,可在多种操作系统上运行,包括各种Linux和Mac OS。请检查转到Mono

Mono声明的目的不仅是能够跨平台运行Microsoft .NET应用程序,而且还为Linux开发人员带来更好的开发工具。 Mono可以在许多操作系统上运行,包括Android,BSD,iOS,Linux,OS X,Windows,Solaris和UNIX。

在研究C#编程语言的基本构建块之前,让我们看一下最低限度的C#程序结构,以便在以后的章节中作为参考。

创建Hello World程序

一个C#程序包括以下部分-

  • 命名空间声明
  • 一个班级
  • 类方法
  • 类属性
  • 主要方法
  • 陈述和表达方式
  • 评论

让我们看一个简单的代码,它打印出单词" Hello World"-

using System;

namespace HelloWorldApplication {
   
   class HelloWorld {
      
      static void Main(string[] args) {
         /* my first program in C# */
         Console.WriteLine("Hello World");
         Console.ReadKey();
      }
   }
}

编译并执行此代码后,将产生以下结果-

Hello World

让我们看一下给定程序的各个部分-

  • 程序的第一行 using System; - using 关键字用于在程序中包含 System 命名空间。一个程序通常具有多个 using 语句。

  • 下一行具有 namespace 声明。 命名空间是类的集合。 HelloWorldApplication 命名空间包含类 HelloWorld

  • 下一行具有 class 声明,类 HelloWorld 包含程序使用的数据和方法定义。类通常包含多个方法。方法定义类的行为。但是, HelloWorld 类只有一个方法 Main

  • 下一行定义 Main 方法,这是所有C#程序的入口点 Main 方法说明该类在执行时的作用。

  • 下一行/*...*/被编译器忽略,并在程序中添加注释

  • Main方法使用语句 Console.WriteLine(" Hello World"); 指定其行为。

    WriteLine System 命名空间中定义的 Console 类的方法。该语句导致出现消息" Hello,World!"。在屏幕上显示。

  • 最后一行 Console.ReadKey(); 用于VS.NET用户。这使程序等待按键,并且阻止了从Visual Studio .NET启动程序时屏幕的快速运行和关闭。

值得注意以下几点-

  • C#区分大小写。
  • 所有语句和表达式必须以分号(;)结尾。
  • 程序执行从Main方法开始。
  • 与Java不同,程序文件名可能与类名不同。

编译并执行程序

如果您使用Visual Studio.Net编译和执行C#程序,请执行以下步骤-

  • 启动Visual Studio。

  • On the menu bar, choose File -> New -> Project.

  • 从模板中选择Visual C#,然后选择Windows。

  • 选择控制台应用程序。

  • 为您的项目指定一个名称,然后单击"确定"按钮。

  • 这将在解决方案资源管理器中创建一个新项目。

  • 在代码编辑器中编写代码。

  • 单击运行按钮或按F5键执行项目。将出现一个命令提示符窗口,其中包含" Hello World"行。

您可以使用命令行而不是Visual Studio IDE来编译C#程序-

  • 打开文本编辑器并添加上述代码。

  • 将文件另存为 helloworld.cs

  • 打开命令提示符工具,然后转到保存文件的目录。

  • 键入 csc helloworld.cs ,然后按Enter键编译代码。

  • 如果代码中没有错误,则命令提示符将您带到下一行并生成 helloworld.exe 可执行文件。

  • 键入 helloworld 来执行程序。

  • 您可以在屏幕上看到输出的Hello World。

C#是一种面向对象的编程语言。在面向对象编程方法中,程序由各种对象组成,这些对象通过动作相互交互。对象可能采取的动作称为方法。相同种类的对象被称为具有相同的类型,或者被称为同一类。

例如,让我们考虑一个Rectangle对象。它具有长度和宽度等属性。根据设计的不同,可能需要一些方法来接受这些属性的值,计算面积并显示详细信息。

让我们看一下Rectangle类的实现并讨论C#基本语法-

using System;

namespace RectangleApplication {
   
   class Rectangle {
      // member variables
      double length;
      double width;
      
      public void Acceptdetails() {
         length = 4.5;    
         width = 3.5;
      }
      
      public double GetArea() {
         return length * width; 
      }
      
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }
   
   class ExecuteRectangle {
   
      static void Main(string[] args) {
         Rectangle r = new Rectangle();
         r.Acceptdetails();
         r.Display();
         Console.ReadLine(); 
      }
   }
}

编译并执行上述代码后,将产生以下结果-

Length: 4.5
Width: 3.5
Area: 15.75

The using Keyword

任何C#程序中的第一条语句是

using System;

using 关键字用于在程序中包含名称空间。一个程序可以包含多个using语句。

The class Keyword

class 关键字用于声明一个类。

C#中的注释

注释用于解释代码。编译器将忽略注释条目。 C#程序中的多行注释以/ *开头,并以字符* /结束,如下所示-

/* This program demonstrates
The basic syntax of C# programming 
Language */

单行注释由" //"符号表示。例如,

}//end class Rectangle    

成员变量

变量是用于存储数据的类的属性或数据成员。在前面的程序中, Rectangle 类具有两个名为 length width 的成员变量。

会员职能

函数是执行特定任务的语句集。类的成员函数在类中声明。我们的示例类Rectangle包含三个成员函数: AcceptDetails GetArea Display

实例化一个类

在前面的程序中,类 ExecuteRectangle 包含 Main()方法并实例化 Rectangle 类。

身份标识

标识符是用于标识类,变量,函数或任何其他用户定义项的名称。 C#中命名类的基本规则如下-

  • 名称必须以字母开头,后跟字母,数字(0-9)或下划线。标识符中的第一个字符不能是数字。

  • It must not contain any embedded space or symbol such as? - + ! @ # % ^ & * ( ) [ ] { } . ; : " ' / and \. However, an underscore ( _ ) can be used.

  • 它不应该是C#关键字。

C#关键字

关键字是预定义给C#编译器的保留字。这些关键字不能用作标识符。但是,如果要使用这些关键字作为标识符,则可以在关键字前面加上@字符。

在C#中,某些标识符在代码的上下文中具有特殊含义,例如get和set称为上下文关键字。

下表列出了C#中的保留关键字和上下文关键字-

保留的关键字
抽象 as 基本 bool 休息 byte 案例
抓住 char 选中 class const 继续十进制
默认委托 double else 枚举事件
明确外部 false 最终固定 float
foreach 转到如果隐含 in(通用修饰符) int
界面内部锁定 long 命名空间
为空对象操作员输出 out(通用修饰符)覆盖参数
私人受保护的 public 只读 ref 返回 sbyte
密封 short sizeof stackalloc 静态 string struct
开关这个 true 尝试 typeof uint
ulong 未选中不安全 ushort 使用虚拟 void
volatile 同时
上下文关键字
添加别名升序下降动态来自获取
全局放入加入 orderby 部分(类型)
partial
(方法)
删除选择设置

C#中的变量分为以下几种类型:

  • 值类型
  • 引用类型
  • 指针类型

值类型

值类型变量可以直接分配一个值。它们是从 System.ValueType 类派生的。

值类型直接包含数据。 int,char和float 是一些示例,它们分别存储数字,字母和浮点数。声明 int 类型时,系统会分配内存以存储该值。

下表列出了C#2010中的可用值类型-

类型代表范围默认值
布尔布尔值对还是错错误
字节 8位无符号整数 0到255 0
字符 16位Unicode字符 U +0000至U + ffff '\ 0'
十进制具有28-29个有效数字的128位精确十进制值(-7.9 x 10 28 至7.9 x 10 28 )) / 10 0 至28 0.0M
double 64位双精度浮点类型(+/-)5.0 x 10 -324 至(+/-)1.7 x 10 308 0.0D
浮动 32位单精度浮点类型-3.4 x 10 38 至+ 3.4 x 10 38 0.0F
int 32位带符号整数类型-2,147,483,648至2,147,483,647 0
64位有符号整数类型 -9,223,372,036,854,775,808至 9,223,372,036,854,775,807 0L
字节 8位有符号整数类型 -128至127 0
16位带符号整数类型-32,768至32,767 0
uint 32位无符号整数类型 0到4,294,967,295 0
乌龙 64位无符号整数类型 0到18,446,744,073,709,551,615 0
超短裤 16位无符号整数类型 0到65,535 0

要获取特定平台上类型或变量的确切大小,可以使用 sizeof 方法。表达式 sizeof(type)产生对象或类型的存储大小(以字节为单位)。以下是在任何计算机上获取 int 类型的大小的示例-

using System;

namespace DataTypeApplication {
   
   class Program {

      static void Main(string[] args) {
         Console.WriteLine("Size of int: {0}", sizeof(int));
         Console.ReadLine();
      }
   }
}

编译并执行上述代码后,将产生以下结果-

Size of int: 4

参考类型

引用类型不包含存储在变量中的实际数据,但是它们包含对变量的引用。

In other words, they refer to a memory location. Using multiple variables, the reference types can refer to a memory location. If the data in the memory location is changed by one of the variables, the other variable automatically reflects this change in value. 例 of built-in reference types are: object, dynamic, and string.

对象类型

The 对象类型 is the ultimate base class for all data types in C# Common Type System (CTS). Object is an alias for System.Object class. The object types can be assigned values of any other types, value types, reference types, predefined or user-defined types. However, before assigning values, it needs type conversion.

值类型转换为对象类型时,称为装箱;另一方面,当对象类型转换为值类型时,称为拆箱

object obj;
obj = 100; // this is boxing

动态类型

您可以在动态数据类型变量中存储任何类型的值。这些类型的变量的类型检查在运行时进行。

声明动态类型的语法是-

dynamic <variable_name> = value;

例如,

dynamic d = 20;

动态类型与对象类型类似,不同之处在于,对对象类型变量的类型检查在编译时进行,而对动态类型变量的类型检查在运行时进行。

字符串类型

The 字符串类型 allows you to assign any string values to a variable. The string type is an alias for the System.String class. It is derived from object type. The value for a string type can be assigned using string literals in two forms: quoted and @quoted.

例如,

String str = "Tutorials Point";

@quoted字符串文字如下所示-

@"Tutorials Point";

用户定义的引用类型为:类,接口或委托。我们将在后面的章节中讨论这些类型。

指针类型

指针类型变量存储另一种类型的内存地址。 C#中的指针具有与C或C ++中的指针相同的功能。

声明指针类型的语法是-

type* identifier;

例如,

char* cptr;
int* iptr;

我们将在"不安全代码"一章中讨论指针类型。

类型转换将一种类型的数据转换为另一种类型。也称为类型转换。在C#中,类型转换具有两种形式-

  • 隐式类型转换-这些转换由C#以类型安全的方式执行。例如,是从较小的整数类型到较大的整数类型的转换,以及从派生类到基类的转换。

  • 显式类型转换-这些转换由用户使用预定义的函数显式完成。显式转换需要强制转换运算符。

以下示例显示了显式类型转换-

using System;

namespace TypeConversionApplication {

   class ExplicitConversion {
   
      static void Main(string[] args) {
         double d = 5673.74; 
         int i;
         
         // cast double to int.
         i = (int)d;
         Console.WriteLine(i);
         Console.ReadKey();
      }
   }
}

编译并执行上述代码后,将产生以下结果-

5673

C#类型转换方法

C#提供以下内置类型转换方法-

Sr.No.Methods & Description
1

ToBoolean

尽可能将类型转换为布尔值。

2

ToByte

将类型转换为字节。

3

ToChar

尽可能将类型转换为单个Unicode字符。

4

ToDateTime

将类型(整数或字符串类型)转换为日期时间结构。

5

ToDecimal

将浮点或整数类型转换为十进制类型。

6

ToDouble

将类型转换为双精度类型。

7

ToInt16

将类型转换为16位整数。

8

ToInt32

将类型转换为32位整数。

9

ToInt64

将类型转换为64位整数。

10

ToSbyte

将类型转换为带符号的字节类型。

11

ToSingle

将类型转换为较小的浮点数。

12

ToString

将类型转换为字符串。

13

ToType

将类型转换为指定的类型。

14

ToUInt16

将类型转换为无符号的int类型。

15

ToUInt32

将类型转换为无符号长类型。

16

ToUInt64

将类型转换为无符号的大整数。

以下示例将各种值类型转换为字符串类型-

using System;

namespace TypeConversionApplication {
   
   class StringConversion {
      
      static void Main(string[] args) {
         int i = 75;
         float f = 53.005f;
         double d = 2345.7652;
         bool b = true;

         Console.WriteLine(i.ToString());
         Console.WriteLine(f.ToString());
         Console.WriteLine(d.ToString());
         Console.WriteLine(b.ToString());
         Console.ReadKey();
            
      }
   }
}

编译并执行上述代码后,将产生以下结果-

75
53.005
2345.7652
True

变量不过是我们程序可以操作的存储区域的名称。 C#中的每个变量都有特定的类型,该类型确定变量的内存大小和布局,可以存储在该内存中的值的范围以及可以应用于该变量的一组操作。

C#中提供的基本值类型可以归类为-

Type
Integral typessbyte, byte, short, ushort, int, uint, long, ulong, and char
Floating point typesfloat and double
Decimal typesdecimal
Boolean typestrue or false values, as assigned
Nullable typesNullable data types

C#还允许定义变量的其他值类型(例如 enum )和变量的引用类型(例如 class ),我们将在后续章节中介绍。

定义变量

C#中变量定义的语法为-

<data_type> <variable_list>;

在此,data_type必须是有效的C#数据类型,包括char,int,float,double或任何用户定义的数据类型,variable_list可能包含一个或多个用逗号分隔的标识符名称。

这里显示了一些有效的变量定义-

int i, j, k;
char c, ch;
float f, salary;
double d;

您可以在定义时将变量初始化为-

int i = 100;

初始化变量

变量使用等号后跟一个常量表达式初始化(​​分配一个值)。初始化的一般形式是-

variable_name = value;

变量可以在它们的声明中初始化。初始化程序由等号组成,后跟一个常量表达式,如-

<data_type> <variable_name> = value;

一些例子是-

int d = 3, f = 5;    /* initializing d and f. */
byte z = 22;         /* initializes z. */
double pi = 3.14159; /* declares an approximation of pi. */
char x = 'x';        /* the variable x has the value 'x'. */

正确初始化变量是一种好的编程习惯,否则有时程序可能会产生意外的结果。

以下示例使用各种类型的变量-

using System;

namespace VariableDefinition {

   class Program {
   
      static void Main(string[] args) {
         short a;
         int b ;
         double c;

         /* actual initialization */
         a = 10;
         b = 20;
         c = a + b;
         Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
         Console.ReadLine();
      }
   }
}

编译并执行上述代码后,将产生以下结果-

a = 10, b = 20, c = 30

接受用户的值

System 命名空间中的 Console 类提供了 ReadLine()函数,用于接受来自用户的输入并将其存储到变量中。

例如,

int num;
num = Convert.ToInt32(Console.ReadLine());

函数 Convert.ToInt32()将用户输入的数据转换为int数据类型,因为 Console.ReadLine()接受字符串格式的数据。

C#中的左值和右值表达式

C#中有两种表达式-

  • 左值-作为左值的表达式可以显示在作业的左侧或右侧。

  • rvalue -作为右值的表达式可能会出现在分配的右侧,而不是左侧。

变量是左值,因此它们可能出现在赋值的左侧。数字文字是右值,因此它们可能没有被赋值并且不能出现在左侧。以下是有效的C#语句-

int g = 20;

但是以下不是有效的语句,并且会生成编译时错误-

10 = 20;

常量指的是程序在执行过程中不得更改的固定值。这些固定值也称为文字。常数可以是任何基本数据类型,例如整数常数,浮点常数,字符常数或字符串文字。也有枚举常量。

常量的处理方式与常规变量相同,只是其值在定义后无法修改。

整数字面量

整数文字可以是十进制或十六进制常量。前缀指定基数或基数:十六进制为0x或0X,十进制没有前缀id。

整数文字也可以具有后缀,该后缀是U和L的组合,分别表示无符号和长整数。后缀可以是大写或小写,并且可以是任何顺序。

这是整数文字的一些例子-

212         /* Legal */
215u        /* Legal */
0xFeeL      /* Legal */

以下是各种类型的Integer文字的其他示例-

85         /* decimal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */

浮点文字

浮点文字具有整数部分,小数点,小数部分和指数部分。您可以用十进制或指数形式表示浮点文字。

这是浮点文字的一些示例-

3.14159       /* Legal */
314159E-5F    /* Legal */
510E          /* Illegal: incomplete exponent */
210f          /* Illegal: no decimal or exponent */
.e55          /* Illegal: missing integer or fraction */

以十进制形式表示时,必须包括小数点和/或指数;并且在使用指数形式表示时,您必须包括整数部分,小数部分或两者。有符号数由e或E引入。

字符常量

Character literals are enclosed in single quotes. 例如, 'x' and can be stored in a simple variable of char type. A character literal can be a plain character (such as 'x'), an escape sequence (such as '\t'), or a universal character (such as '\u02C0').

在C#中,某些字符前面带有反斜杠。它们具有特殊含义,用于表示换行符(\ n)或制表符(\ t)。这是一些此类转义序列代码的列表-

转义序列含义
\\ \字符
\''字符
\" "字符
\??字符
\ a 警报或响铃
\ b Backspace
\ f 换页
\ n 换行符
\ r 回车
\ t "水平"标签
\ v "垂直"标签
\ xhh。 。 。十六进制的一位或多位数字

以下是显示一些转义序列字符的示例-

using System;

namespace EscapeChar {

   class Program {
   
      static void Main(string[] args) {
         Console.WriteLine("Hello\tWorld\n\n");
         Console.ReadLine();
      }
   }
}

编译并执行上述代码后,将产生以下结果-

Hello   World

字符串文字

字符串文字或常量用双引号""或@""引起来。字符串包含与字符文字相似的字符:纯字符,转义序列和通用字符。

您可以使用字符串文字将长行分成多行,并使用空格分隔各部分。

这是字符串文字的一些示例。这三种形式都是相同的字符串。

"hello, dear"
"hello, \
dear"
"hello, " "d" "ear"
@"hello dear"

定义常数

常量是使用 const 关键字定义的。定义常量的语法是-

const <data_type> <constant_name> = value;

以下程序演示了如何在程序中定义和使用常量-

using System;

namespace DeclaringConstants {

    class Program {
    
        static void Main(string[] args) {
            const double pi = 3.14159;   
            
            // constant declaration 
            double r;
            Console.WriteLine("Enter Radius: ");
            r = Convert.ToDouble(Console.ReadLine());
            double areaCircle = pi * r * r;
            Console.WriteLine("Radius: {0}, Area: {1}", r, areaCircle);
            Console.ReadLine();
        }
    }
}

编译并执行上述代码后,将产生以下结果-

Enter Radius: 
3
Radius: 3, Area: 28.27431

运算符是一个符号,告诉编译器执行特定的数学或逻辑操作。 C#具有丰富的内置运算符集,并提供以下类型的运算符-

  • 算术运算符
  • 关系运算符
  • 逻辑运算符
  • 按位运算符
  • 赋值运算符
  • Misc Operators

本教程逐一说明算术,关系,逻辑,按位,赋值和其他运算符。

算术运算符

下表显示了C#支持的所有算术运算符。假设变量 A 保持10,变量 B 保持20,然后-

Show 例s

OperatorDescription
+Adds two operandsA + B = 30
-Subtracts second operand from the firstA - B = -10
*Multiplies both operandsA * B = 200
/Divides numerator by de-numeratorB / A = 2
%Modulus Operator and remainder of after an integer divisionB % A = 0
++Increment operator increases integer value by oneA++ = 11
--Decrement operator decreases integer value by oneA-- = 9

关系运算符

下表显示了C#支持的所有关系运算符。假设变量 A 保持10,变量 B 保持20,则-

Show 例s

OperatorDescription
==Checks if the values of two operands are equal or not, if yes then condition becomes true.(A == B) is not true.
!=Checks if the values of two operands are equal or not, if values are not equal then condition becomes true.(A != B) is true.
>Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true.(A > B) is not true.
<Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true.(A < B) is true.
>=Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true.(A >= B) is not true.
<=Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true.(A <= B) is true.

逻辑运算符

下表显示了C#支持的所有逻辑运算符。假设变量 A 保持布尔值true,变量 B 保持布尔值false,则-

Show 例s

OperatorDescription
&&Called Logical AND operator. If both the operands are non zero then condition becomes true.(A && B) is false.
||Called Logical OR Operator. If any of the two operands is non zero then condition becomes true.(A || B) is true.
!Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false.!(A && B) is true.

按位运算符

Bitwise operator works on bits and perform bit by bit operation. The truth tables for &, |, and ^ are as follows −

pqp & qp | qp ^ q
00000
01011
11110
10011

假设A = 60;和B = 13;然后以二进制格式如下:

A = 0011 1100

B = 0000 1101

-------------------

A&B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

〜A = 1100 0011

下表列出了C#支持的按位运算符。假设变量A保持60,变量B保持13,则-

Show 例s

OperatorDescription
&Binary AND Operator copies a bit to the result if it exists in both operands.(A & B) = 12, which is 0000 1100
|Binary OR Operator copies a bit if it exists in either operand.(A | B) = 61, which is 0011 1101
^Binary XOR Operator copies the bit if it is set in one operand but not both.(A ^ B) = 49, which is 0011 0001
~Binary Ones Complement Operator is unary and has the effect of 'flipping' bits.(~A ) = -61, which is 1100 0011 in 2's complement due to a signed binary number.
<<Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.A << 2 = 240, which is 1111 0000
>>Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.A >> 2 = 15, which is 0000 1111

赋值运算符

C#支持以下赋值运算符-

Show 例s

OperatorDescription
=Simple assignment operator, Assigns values from right side operands to left side operandC = A + B assigns value of A + B into C
+=Add AND assignment operator, It adds right operand to the left operand and assign the result to left operandC += A is equivalent to C = C + A
-=Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operandC -= A is equivalent to C = C - A
*=Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operandC *= A is equivalent to C = C * A
/=Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operandC /= A is equivalent to C = C / A
%=Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operandC %= A is equivalent to C = C % A
<<=Left shift AND assignment operatorC <<= 2 is same as C = C << 2
>>=Right shift AND assignment operatorC >>= 2 is same as C = C >> 2
&=Bitwise AND assignment operatorC &= 2 is same as C = C & 2
^=bitwise exclusive OR and assignment operatorC ^= 2 is same as C = C ^ 2
|=bitwise inclusive OR and assignment operatorC |= 2 is same as C = C | 2

杂项运算符

还有其他几个重要的运算符,包括 sizeof,typeof ? :受C#支持。

Show 例s

OperatorDescription
sizeof()Returns the size of a data type.sizeof(int), returns 4.
typeof()Returns the type of a class.typeof(StreamReader);
&Returns the address of an variable.&a; returns actual address of the variable.
*Pointer to a variable.*a; creates pointer named 'a' to a variable.
? :Conditional ExpressionIf Condition is true ? Then value X : Otherwise value Y
isDetermines whether an object is of a certain type.If( Ford is Car) // checks if Ford is an object of the Car class.
asCast without raising an exception if the cast fails.Object obj = new StringReader("Hello");

StringReader r = obj作为StringReader;

C#中的运算符优先级

运算符优先级确定表达式中术语的分组。这会影响表达式的评估。某些运算符的优先级比其他运算符高;例如,乘法运算符的优先级高于加法运算符。

例如x = 7 + 3 * 2;在这里,x被赋值为13,而不是20,因为运算符*的优先级比+高,因此对3 * 2进行第一个求值,然后将7加。

在这里,优先级最高的运算符出现在表格的顶部,而优先级最低的运算符出现在表格的底部。在表达式中,优先级较高的运算符将首先求值。

Show 例s

CategoryOperatorAssociativity
Postfix() [] -> . ++ - -Left to right
Unary+ - ! ~ ++ - - (type)* & sizeofRight to left
Multiplicative* / %Left to right
Additive+ -Left to right
Shift<< >>Left to right
Relational< <= > >=Left to right
Equality== !=Left to right
Bitwise AND&Left to right
Bitwise XOR^Left to right
Bitwise OR|Left to right
Logical AND&&Left to right
Logical OR||Left to right
Conditional?:Right to left
Assignment= += -= *= /= %=>>= <<= &= ^= |=Right to left
Comma,Left to right

决策结构要求程序员指定一个或多个要由程序评估或测试的条件,以及确定条件为真的情况下要执行的一条或多条语句,以及如果条件被确定为其他要执行的语句确定为假。

以下是大多数编程语言中常见的典型决策结构的一般形式-

Decision making statements in C#

C#提供以下类型的决策声明。单击以下链接以查看其详细信息。

Sr.No.Statement & Description
1 if statement

if语句由布尔表达式和一个或多个语句组成。

2 if...else statement

if语句之后可以跟可选的 else语句,该语句在布尔表达式为false时执行。

3 nested if statements

您可以在另一个 if else if 语句中使用一个 if else if 语句。

4 switch statement

switch 语句允许针对值列表对变量进行相等性测试。

5 nested switch statements

您可以在另一个 switch 语句中使用一个 switch 语句。

? :运算符

我们已经介绍了条件运算符? :在上一章中,可用于替换 if ... else 语句。它具有以下一般形式-

Exp1 ? Exp2 : Exp3;

其中Exp1,Exp2和Exp3是表达式。注意冒号的使用和放置。

a的值表达式确定如下:计算Exp1。如果为true,则将评估Exp2并成为整个?的值。表达。如果Exp1为false,则对Exp3求值,其值成为表达式的值。

在某些情况下,您需要多次执行一个代码块。通常,这些语句是按顺序执行的:函数中的第一个语句首先执行,然后执行第二个,依此类推。

编程语言提供了各种控制结构,允许更复杂的执行路径。

循环语句使我们可以多次执行一个语句或一组语句,以下是大多数编程语言中循环语句的概述-

Loop Architecture

C#提供了以下类型的循环来处理循环需求。单击以下链接以查看其详细信息。

Sr.No.Loop Type & Description
1 while loop

当给定条件为真时,它将重复一个语句或一组语句。它在执行循环体之前测试条件。

2 for loop

它多次执行一系列语句,并简化了管理循环变量的代码。

3 do...while loop

它类似于while语句,除了它在循环主体的末尾测试条件

4 nested loops

您可以在while,for或do..while循环中使用一个或多个循环。

循环控制语句

循环控制语句从其正常顺序更改执行。当执行离开作用域时,在该作用域中创建的所有自动对象都将被销毁。

C#提供以下控制语句。单击以下链接以查看其详细信息。

Sr.No.Control Statement & Description
1 break statement

终止 loop switch 语句,并在循环或切换后立即将执行转移到该语句。

2 continue statement

使循环跳过其其余部分,并在重新进行迭代之前立即重新测试其状况。

无限循环

如果条件永远不会为假,则循环将变为无限循环。传统上, for 循环用于此目的。由于形成for循环的三个表达式都不是必需的,因此可以通过将条件表达式保留为空来进行无限循环。

using System;

namespace Loops {

   class Program {
   
      static void Main(string[] args) {
         for (; ; ) {
            Console.WriteLine("Hey! I am Trapped");
         }
      }
   }
} 

当条件表达式不存在时,假定它为真。您可能有一个初始化和增量表达式,但是程序员通常使用for(;;)构造来表示无限循环。

封装被定义为"将一个或多个项目封装在物理或逻辑包装中的过程"。面向对象编程方法中的封装可防止访问实现细节。

抽象和封装是面向对象编程中的相关功能。抽象允许使相关信息可见,封装使程序员可以实现所需的抽象级别

封装是通过使用访问说明符实现的。 访问说明符定义了类成员的范围和可见性。 C#支持以下访问说明符-

  • 公开
  • 私人
  • 受保护的
  • 内部
  • 受保护的内部

公共访问说明符

公共访问说明符允许类将其成员变量和成员函数公开给其他函数和对象。可以从班级外部访问任何公共成员。

以下示例说明了这一点-

using System;

namespace RectangleApplication {

   class Rectangle {
      //member variables
      public double length;
      public double width;
      
      public double GetArea() {
         return length * width;
      }
      
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }//end class Rectangle
   
   class ExecuteRectangle {
      static void Main(string[] args) {
         Rectangle r = new Rectangle();
         r.length = 4.5;
         r.width = 3.5;
         r.Display();
         Console.ReadLine();
      }
   }
}

编译并执行上述代码后,将产生以下结果-

Length: 4.5
Width: 3.5
Area: 15.75

在前面的示例中,成员变量length和width被声明为 public ,因此可以使用名为 r 的Rectangle类实例从函数Main()访问它们。 。

成员函数 Display() GetArea()也可以直接访问这些变量,而无需使用类的任何实例。

成员函数 Display()也被声明为 public ,因此也可以使用Rectangle类的实例从 Main()对其进行访问,名为 r

专用访问说明符

私有访问说明符允许类从其他函数和对象中隐藏其成员变量和成员函数。只有同一个类的函数才能访问其私有成员。甚至一个类的实例也无法访问其私有成员。

以下示例说明了这一点-

using System;

namespace RectangleApplication {

   class Rectangle {
      //member variables
      private double length;
      private double width;
      
      public void Acceptdetails() {
         Console.WriteLine("Enter Length: ");
         length = Convert.ToDouble(Console.ReadLine());
         Console.WriteLine("Enter Width: ");
         width = Convert.ToDouble(Console.ReadLine());
      }
      
      public double GetArea() {
         return length * width;
      }
      
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }//end class Rectangle
   
   class ExecuteRectangle {
      static void Main(string[] args) {
         Rectangle r = new Rectangle();
         r.Acceptdetails();
         r.Display();
         Console.ReadLine();
      }
   }
}

编译并执行上述代码后,将产生以下结果-

Enter Length:
4.4
Enter Width:
3.3
Length: 4.4
Width: 3.3
Area: 14.52

在前面的示例中,成员变量length和width被声明为 private ,因此无法从函数Main()进行访问。成员函数 AcceptDetails() Display()可以访问这些变量。由于成员函数 AcceptDetails() Display()被声明为 public ,因此可以从 Main()使用名为 r 的Rectangle类的实例。

受保护的访问说明符

受保护的访问说明符允许子类访问其基类的成员变量和成员函数。这样,它有助于实现继承。我们将在继承一章中对此进行更详细的讨论。

内部访问说明符

内部访问说明符允许类将其成员变量和成员函数公开给当前程序集中的其他函数和对象。换句话说,任何具有内部访问说明符的成员都可以从定义该成员的应用程序内定义的任何类或方法中进行访问。

以下程序说明了这一点-

using System;

namespace RectangleApplication {

   class Rectangle {
      //member variables
      internal double length;
      internal double width;
      
      double GetArea() {
         return length * width;
      }
      
      public void Display() {
         Console.WriteLine("Length: {0}", length);
         Console.WriteLine("Width: {0}", width);
         Console.WriteLine("Area: {0}", GetArea());
      }
   }//end class Rectangle
   
   class ExecuteRectangle {
      static void Main(string[] args) {
         Rectangle r = new Rectangle();
         r.length = 4.5;
         r.width = 3.5;
         r.Display();
         Console.ReadLine();
      }
   }
}

编译并执行上述代码后,将产生以下结果-

Length: 4.5
Width: 3.5
Area: 15.75

在前面的示例中,请注意,没有使用任何访问说明符声明成员函数 GetArea()。如果我们不提及,那么该类成员的默认访问说明符是什么?它是私有

Protected 内部访问说明符

受保护的内部访问说明符允许类在同一应用程序中的子类之外的其他类对象和函数中隐藏其成员变量和成员函数。在实现继承时也使用此方法。

方法是一起执行任务的一组语句。每个C#程序至少都有一个类,带有一个名为Main的方法。

要使用一种方法,您需要-

  • 定义方法
点我分享笔记