C#入门基础知识总结

最新推荐文章于 2024-02-25 09:57:30 发布

山鸟同学

最新推荐文章于 2024-02-25 09:57:30 发布

阅读量4k

点赞数 7

文章标签： c# 开发语言

本文链接：https://blog.csdn.net/qq_46086519/article/details/126679021

版权

C#入门

C#与.Net的关系

.Net 框架是一个革命性的平台，能帮您编写出下面类型的应用程序：

Windows 应用程序
Web 应用程序
Web 服务

.Net是由多种语言搭建的框架，有着有种组件，常用的C#继承开发环境有vs

在Linux或者Mac OS上编写C#程序使用的的开源工具一般是Mono（常用的）

C#程序结构

using System;//相当于import
namespace HelloWorldApplication//相当于有个这样的文件夹
{
   class HelloWorld
   {
      static void Main(string[] args)
      {
      /* 我的第一个 C# 程序（这是多行注释，上边是单行注释）*/
         Console.WriteLine("Hello World");//sout
         Console.ReadKey();//等待按键之后才可以关闭
      }
   }
}

一个 C# 程序主要包括以下部分：

命名空间声明
一个类
类方法
类属性
一个 Main 方法
语句和表达式
注释
C# 是大小写敏感的。
所有的语句和表达式必须以分号（;）结尾。
程序的执行从 Main 方法开始。
与 Java 不同的是，文件名可以不同于类的名称

编写C#程序步骤：

启动 Visual Studio。
在菜单栏上，选择 File -> New -> Project。
从模板中选择 Visual C#，然后选择 Windows。
选择 Console Application。
为您的项目制定一个名称，然后点击 OK 按钮。
新项目会出现在解决方案资源管理器中。
在代码编辑器中编写代码。
点击 Run 按钮或者按下 F5 键来运行程序。会出现一个命令提示符窗口，显示 Hello World。

您也可以使用命令行代替 Visual Studio IDE 来编译 C# 程序：

打开一个文本编辑器，添加上面提到的代码。
保存文件为 helloworld.cs。
打开命令提示符工具，定位到文件所保存的目录。
键入 csc helloworld.cs 并按下回车键来编译代码。
如果代码没有错误，命令提示符会进入下一行，并生成 helloworld.exe 可执行文件。
接下来，键入 helloworld 来执行程序。
您将看到 “Hello World” 打印在屏幕上。

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();
        }
    }
}

输出的时候可以使用{0},…进行占位，当然作为一个java程序员来说来得进行连接符的拼接。

（通用干嘛不用一致的）

成员变量就是类的属性

成员函数就是类的方法

实例化类就是new一个

标识符（正常起名就ok）

标识符必须以字母开头，后面可以跟一系列的字母、数字（0 - 9）或下划线（_）。标识符中的第一个字符不能是数字。
标识符必须不包含任何嵌入的空格或符号，比如 ? - + ! @ # % ^ & * ( ) [ ] { } . ; : " ' / \。但是，可以使用下划线（_）。
标识符不能是 C# 关键字。

C#数据类型

数据类型

值类型（Value types）
引用类型（Reference types）
指针类型（Pointer types）

值类型包含：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ygNhA4CC-1662193113307)(C:\Users\23236\AppData\Roaming\Typora\typora-user-images\image-20220902091401953.png)]

内置的引用类型：object、dynamic和string

对象类型可以分配各种其他类型的值，分配之前需要进行类型转换。当一个值的类型转化为对象类型时，这个过程叫做装箱；一个对象类型转化为值类型的时候叫做拆箱

dynamic d = 20;

动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时进行的，而动态类型变量的类型检查是在运行时进行的。

字符串类型与java差不多但是有个@" "这样的定义方式

还有指针类型

char* cptr;

int* iptr;

对于类型转换（和java真的像）

隐式类型转换：从小的整数类型转换为大的数据类型，从派生类到基类

显式类型转换：强制类型转换

内置了许多转换方法，可以使用To+数据类型

C#变量

int d = 3, f = 5;    /* 初始化 d 和 f. */
byte z = 22;         /* 初始化 z. */
double pi = 3.14159; /* 声明 pi 的近似值 */
char x = 'x';        /* 变量 x 的值为 'x' */

int num;
num = Convert.ToInt32(Console.ReadLine());
//RedaLine()接收用户的输入，并且把它存储到一个变量之中，但是它接收到的数据是String类型的
//我们需要convert.ToInt32()把用户输入的数据转换为int数据类型

C# 中的 Lvalues 和 Rvalues

lvalue表达式可以出现在赋值语句的左边或者右边（变量）

rvalue表达式可以出现在赋值语句的右边，不能出现在赋值语句的左边（常量）

C#判断

判断结构需要程序员指定一个或多个要评估或测试的条件，以及条件为真时要执行的语句（必需的）和条件为假时要执行的语句（可选的）。

语句	描述
if 语句	一个if 语句由一个布尔表达式后跟一个或多个语句组成。
if…else 语句	一个if 语句后跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。
嵌套 if 语句	您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。
switch 语句	一个 switch 语句允许测试一个变量等于多个值时的情况。
嵌套 switch 语句	您可以在一个 switch 语句内使用另一个 switch 语句。

三元表达式：Exp1 ? Exp2（true） : Exp3（false）;

C#循环

有的情况下，可能需要多次执行同一块代码。一般情况下，语句是顺序执行的：函数中的第一个语句先执行，然后是第二个语句，以此类推。

循环类型	描述
while 循环	当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。
for 循环	多次执行一个语句序列，简化管理循环变量的代码。
do…while 循环	除了它是在循环主体结尾测试条件外，其他与 while 语句类似。
嵌套循环	您可以在 do…while 循环内使用一个或多个循环。

循环控制语句：

控制语句	描述
break 语句	终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。
continue 语句	引起循环跳过主体的剩余部分，立即重新开始测试条件。

无线循环：

for (; ; ) or while（true）

C#封装

就是把它按在一个物理和逻辑结构的包里，防止实现对细节的访问

C#支持的访问控制修饰符

public：程序集及引用的程序集，都能访问修改。
internal：只能同一程序集访问。
protected：类及派生类能够访问，一般是子类查询基类。
protected internal：成员可由任何嵌套类型、任何派生类型（不管在什么程序集）或者定义程序集中的任何方法访问。
private：只能类自己访问。

Public 访问修饰符允许一个类将其成员变和成员函数暴露给其他的函数和对象。任何公有成员可以被外部的类访问。

Private 访问修饰符允许一个类将其成员变量和成员函数对其他的函数和对象进行隐藏。只有同一个类中的函数可以访问它的私有成员。即使是类的实例也不能访问它的私有成员。

命名空间相同时： protected internal=internal;
命名空间不同时： protected internal=protected;

C#方法

元素组成：

访问说明符：它用于从一个类中确定一个变量或方法的可见性。
返回类型：方法可能会返回一个值。返回类型是方法返回值的数据类型。如果该方法不返回任何值，那么返回类型是 void。
方法名称：方法名称是唯一的标识符，并区分大小写。它不能与在类中声明的任何其他标识符相同。
参数列表：括号括起来，使用参数从方法中传递和接收数据。参数列表是指类型、顺序和方法的参数数目。参数是可选的；方法可能包含任何参数。
方法主体：它包含的一组指令完成所需要的活动所需。

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      //比较大小的方法
      public int FindMax(int num1, int num2)
      {
         /* local variable declaration */
         int result;

         if (num1 > num2)
            result = num1;
         else
            result = num2;
         return result;
      }
      static void Main(string[] args)
      {
         /* local variable definition */
         int a = 100;
         int b = 200;
         int ret;
         NumberManipulator n = new NumberManipulator();

         //calling the FindMax method
         ret = n.FindMax(a, b);
         Console.WriteLine("Max value is : {0}", ret );
         Console.ReadLine();
      }
   }
}

递归调用：

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public int factorial(int num)
      {
         /* local variable declaration */
         int result;
         if (num == 1)
         {
            return 1;
         }
         else
         {
            result = factorial(num - 1) * num;
            return result;
         }
      }

      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         //calling the factorial method
         Console.WriteLine("Factorial of 6 is : {0}", n.factorial(6));
         Console.WriteLine("Factorial of 7 is : {0}", n.factorial(7));
         Console.WriteLine("Factorial of 8 is : {0}", n.factorial(8));
         Console.ReadLine();
      }
   }
}

C#可空类型

这个东西就是没有值的意思

using System;
namespace CalculatorApplication
{
   class NullablesAtShow
   {
      static void Main(string[] args)
      {
         int? num1 = null;
         int? num2 = 45;
         double? num3 = new double?();
         double? num4 = 3.14157;

         bool? boolval = new bool?();

         // display the values

         Console.WriteLine("Nullables at Show: {0}, {1}, {2}, {3}", num1, num2, num3, num4);
         Console.WriteLine("A Nullable boolean value: {0}", boolval);
         Console.ReadLine();
      }
   }
}

//运行结果
Nullables at Show: , 45,  , 3.14157
A Nullable boolean value:

空合并运算符（??）是用于空值类型和引用类型

如果第一个操作数的值为 null，则该运算符返回第二个操作数的值，否则返回第一个操作数的值

using System;
namespace CalculatorApplication
{
   class NullablesAtShow
   {
      static void Main(string[] args)
      {
         double? num1 = null;
         double? num2 = 3.14157;
         double num3;
         num3 = num1 ?? 5.34;    //??  
         Console.WriteLine(" Value of num3: {0}", num3);
         num3 = num2 ?? 5.34;    //??
         Console.WriteLine(" Value of num3: {0}", num3);
         Console.ReadLine();
      }
   }
}

//运行结果
Value of num3: 5.34
Value of num3: 3.14157

C#数组（我感觉真正做项目的时候用的应该是集合框架）

在内存中是连续的，最低的地址对应于第一元素，最高地址为最后一个元素地址。

声明数组

数据类型[] 数组名称

初始化数组

double[] balance = new double[10];

double[] balance = { 2340.0, 4523.69, 3421.0};

int [] marks = new int[5] { 99, 98, 92, 97, 95};

int [] marks = new int[] { 99, 98, 92, 97, 95};

int[] score = marks;

这样的两个数组指向的地址是一个地方

一个元素由索引数组名访问。这是通过放置在数组名后面的方括号里的元素索引完成的

数组的遍历

你可以使用for while循环，你也可以使用foreach来遍历数组

using System;
namespace ArrayApplication
{
   class MyArray
   {
      static void Main(string[] args)
      {
         int []  n = new int[10]; /* n is an array of 10 integers */

         /* 为数组赋值 100 101 102... */
         for ( int i = 0; i < 10; i++ )
         {
            n[i] = i + 100;
         }

         /* 输出数组元素 */
         foreach (int j in n )
         {
            int i = j-100;
            Console.WriteLine("Element[{0}] = {1}", i, j);
            i++;
         }
         Console.ReadKey();
      }
   }
}

字符串

在 C# 中，可以使用字符串作为字符数组，但更常见的做法是使用 string 关键字来声明一个字符串变量。该 string 关键字是 System.String 类的别名。

在这里字符串中 string的首字符是小写的s

using System;
namespace StringApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         //from string literal and string concatenation
         string fname, lname;
         fname = "Rowan";
         lname = "Atkinson";

         string fullname = fname + lname;
         Console.WriteLine("Full Name: {0}", fullname);

         //by using string constructor
         char[] letters = { 'H', 'e', 'l', 'l','o' };
         string greetings = new string(letters);
         Console.WriteLine("Greetings: {0}", greetings);

         //methods returning string
         string[] sarray = { "Hello", "From", "Tutorials", "Point" };
         //在sarray中用“ ”将元素进行分隔
         string message = String.Join(" ", sarray);
         Console.WriteLine("Message: {0}", message);

         //formatting method to convert a value
         DateTime waiting = new DateTime(2012, 10, 10, 17, 58, 1);
         string chat = String.Format("Message sent at {0:t} on {0:D}", waiting);
         Console.WriteLine("Message: {0}", chat);
      }
   }
}


//Full Name: Rowan Atkinson
//Greetings: Hello
//Message: Hello From Tutorials Point
//Message: Message sent at 5:58 PM on Wednesday, October 10, 2012

string的一些方法

序号	属性名称和描述
1	public static int Compare(string strA,string strB) 比较两个指定的字符串对象，并返回一个整数，指示其在排序顺序相对位置
2	public static int Compare(string strA,string strB,bool ignoreCase) 比较两个指定的字符串对象，并返回一个整数，指示其在排序顺序相对位置。但是，它忽略情况下，如果布尔参数为true
3	public static string Concat(string str0,string str1) 连接两个字符串对象
4	public static string Concat(string str0,string str1,string str2) 拼接三个字符串对象
5	public static string Concat(string str0,string str1,string str2,string str3) 符连接四个字符串对象
6	public bool Contains(string value) 返回一个值，指示指定的字符串对象是否发生此字符串中
7	public static string Copy(string str) 创建具有相同的值作为指定字符串的新String对象
8	public void CopyTo(int sourceIndex,char[] destination,int destinationIndex,int count) 复制从字符串对象到指定位置Unicode字符数组的指定位置指定的字符数
9	public bool EndsWith(string value) 确定字符串对象的末尾是否与指定的字符串匹配
10	public bool Equals(string value) 确定当前字符串对象，并指定字符串对象是否具有相同的值
11	public static bool Equals(string a,string b) 确定两个指定的String对象是否具有相同的值
12	public static string Format(string format,Object arg0) 替换指定的字符串指定对象的字符串表示在一个或多个格式项
13	public int IndexOf(char value) 返回当前字符串指定Unicode字符中第一次出现从零开始的索引
14	public int IndexOf(string value) 返回在这种情况下指定字符串中第一次出现从零开始的索引
15	public int IndexOf(char value,int startIndex) 返回此字符串指定Unicode字符中第一次出现从零开始的索引，搜索开始在指定的字符位置
16	public int IndexOf(string value,int startIndex) 返回在这种情况下指定字符串中第一次出现的从零开始的索引，搜索开始在指定的字符位置
17	public int IndexOfAny(char[] anyOf) 返回Unicode字符指定数组中第一次出现的任何字符的这个实例从零开始的索引
18	public int IndexOfAny(char[] anyOf,int startIndex) 返回Unicode字符指定数组，开始搜索从指定字符位置中第一次出现的任何字符的这个实例从零开始的索引
19	public string Insert(int startIndex,string value) 返回在指定的字符串被插入在当前字符串对象指定索引位置一个新的字符串
20	public static bool IsNullOrEmpty(string value) 指示指定的字符串是否为空或空字符串
21	public static string Join(string separator,params string[] value) 连接字符串数组中的所有元素，使用每个元件之间指定的分隔
22	public static string Join(string separator,string[] value,int startIndex,int count) 连接字符串数组的指定元素，利用每一个元素之间指定分隔符
23	public int LastIndexOf(char value) 返回当前字符串对象中指定的Unicode字符的最后出现从零开始的索引位置
24	public int LastIndexOf(string value) 返回当前字符串对象中的指定字符串最后一次出现的从零开始的索引位置
25	public string Remove(int startIndex) 删除在当前实例中的所有字符，开始在指定的位置，并继续通过最后位置，并返回字符串
26	public string Remove(int startIndex,int count) 删除在当前字符串的字符开始的指定位置的指定数量，并返回字符串
27	public string Replace(char oldChar,char newChar) 替换与指定的Unicode字符当前字符串对象指定的Unicode字符的所有匹配，并返回新的字符串
28	public string Replace(string oldValue,string newValue) 替换用指定的字符串当前字符串对象指定的字符串的所有匹配，并返回新的字符串
29	public string[] Split(params char[] separator) 返回一个字符串数组，其中包含的子字符串在当前字符串对象，由指定的Unicode字符数组的元素分隔
30	public string[] Split(char[] separator,int count) 返回一个字符串数组，其中包含的子字符串在当前字符串对象，由指定的Unicode字符数组的元素分隔。整型参数指定的子串返回最大数量
31	public bool StartsWith(string value) 确定此字符串实例的开头是否与指定的字符串匹配
32	public char[] ToCharArray() 返回一个Unicode字符数组，在当前字符串对象中的所有字符
33	public char[] ToCharArray(int startIndex,int length) 返回一个Unicode字符数组，在当前字符串对象中的所有字符，从指定的索引开始，并到指定的长度
34	public string ToLower() 返回此字符串的一个副本转换为小写
35	public string ToUpper() 返回此字符串的一个副本转换为大写
36	public string Trim() 从当前String对象去除所有开头和结尾的空白字符

C#结构体

（感觉c#好像融合的好多种语言语法形成的功能嗷嗷强大的语言。）

在 C# 中，结构体是一种值数据类型。包含数据成员和方法成员。 struct 关键字是用于创建一个结构体。

结构体是用来代表一个记录。假设你想追踪一个图书馆的书。你可能想追踪每本书的属性如下：

标题
作者
类别
书号

定义一个结构体，你必须要声明这个结构体。结构体声明定义了一种新的数据类型，这个数据类型为你的程序包含了一个以上的成员变量。

struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};

结构体的特征

你已经使用了一个名为 Books 的简单结构体。C# 中的结构体与传统的 C 或者 C++ 有明显的不同。 C# 中的结构体有以下特征：

结构体可以有方法，域，属性，索引器，操作方法和事件。
结构体可以定义构造函数，但是不能构造析构函数。尽管如此，你还是不能定义一个结构体的默认构造函数。默认构造函数是自动定义的，且不能被改变。
与类不同，结构体不能继承其他的结构体或这其他的类。
结构体不能用于作为其他结构或者类的基。
结构体可以实现一个或多个接口。
结构体成员不能被指定为抽象的，虚拟的，或者保护的对象。
使用 New 运算符创建结构体对象时，将创建该结构体对象，并且调用适当的构造函数。与类不同的是，结构体的实例化可以不使用 New 运算符。
如果不使用 New 操作符，那么在初始化所有字段之前，字段将保持未赋值状态，且对象不可用。

类和结构体有以下几个主要的区别：

类是引用类型，结构体是值类型
结构体不支持继承
结构体不能有默认构造函数

c#枚举

枚举是一组命名的整型常量。枚举类型使用enum关键字声明。

C#枚举的值的数据类型。枚举不能继承or被继承。

enum 枚举名称 { ，，}

c#类

using System;
namespace BoxApplication
{
    class Box
    {
       public double length;  // box 的长度
       public double breadth; // box 的宽度
       public double height;  // box 的高度
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();   // 声明 box1 为 box 类型
            Box Box2 = new Box();   // 声明 box2 为 box 类型
            double volume = 0.0;    // 在这里存放 box 的体积

            // box 1 详细数据
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;

            // box 2 详细数据
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;

            // box 1 的体积
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Volume of Box1 : {0}",  volume);

            // box 2 的体积
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Volume of Box2 : {0}", volume);
            Console.ReadKey();
        }
    }

using System;
namespace StringApplication
{
    class Box
    {
        private double length;   // box 的长度
        private double breadth;  // box 的宽度
        private double height;   // box 的高度
        
        
        public void setLength(double len)//在这里面的参数值不能和属性重名len
        {
            this.length = len;
        }

        public void setBreadth(double bre)
        {
            this.breadth = bre;
        }

        public void setHeight(double hei)
        {
            height = hei;
        }
        public double getVolume()
        {
            return length * breadth * height;
        }
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();   // 将 Box1 声明为 Box 类型
            Box Box2 = new Box();
            double volume;

            // 将 Box2 声明为 Box 类型
            // box 1 详细数据
            Box1.setLength(6.0);
            Box1.setBreadth(7.0);
            Box1.setHeight(5.0);

            // box 2 详细数据
            Box2.setLength(12.0);
            Box2.setBreadth(13.0);
            Box2.setHeight(10.0);

            // box 1 的体积
            volume = Box1.getVolume();
            Console.WriteLine("Volume of Box1 : {0}", volume);

            // box 2 的体积
            volume = Box2.getVolume();
            Console.WriteLine("Volume of Box2 : {0}", volume);

            Console.ReadKey();
        }
    }
}

c#的构造函数

默认的构造函数没有任何参数，但是你需要的时候，构造参数时可以有参数的

using System;
namespace LineApplication
{
   class Line
   {
      private double length;   // 线段长度
      public Line()
      {
         Console.WriteLine("Object is being created");
      }

      public void setLength( double len )
      {
         length = len;
      }

      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line();    

         // 设置线段长度
         line.setLength(6.0);
         Console.WriteLine("Length of line : {0}", line.getLength());
         Console.ReadKey();
      }
   }
}

//运行结果
//Object is being created
//Length of line : 6

C#析构函数

析构函数（destructor）是类的一种特殊的成员函数，当类的对象在超出作用域时被执行的一种成员函数。一个析构函数的名称是在其类名称前加上一个前缀字符（~），它既不能返回一个值，也不能带有任何参数。

析构函数对退出程序前释放内存资源时非常有用。析构函数不可以被继承或重载。

  ~Line() //析构函数
      {
         Console.WriteLine("执行析构函数...");
      }

C#类的静态成员

static 修饰关键字 static 意味着一个类的成员只有一个实例存在。静态变量被用于定义常数，因为他们的值可以通过调用不创建实例的类而被检索出来。静态变量可以在成员函数或者类的定义以外的地方初始化。你也可以在类的定义中初始化静态变量。

静态成员变量必须使用类名调用，不能使用对象调用。

C#继承

面向对象程序设计中最重要的一个概念就是继承（inheritance）。继承允许我们在另一个类中定义一个新的类，这使得它更容易创建和维护一个应用程序。这也提供了一个机会来重用代码的功能，加快实现时间。

创建一个类的时候，不是要写全新的数据成员和成员函数，程序员可以指定新的类继承一个已经存在的类的成员。已有的类称为基类（base class）（父类），新的类称为派生类（derived class）（子类）。

继承的思想实现了 IS-A 的关系。例如，哺乳动物是（IS-A）动物，狗是（IS-A）哺乳动物，因此狗是（IS-A）一个动物等。

继承不再使用 extends，而是使用：。

到这里我有个疑问，为什么c#不分多个页面写类呢，而是在一个文件中一写到底。

因为教程就这样写的，可能嫌麻烦，但是实际开发确实一个文件一个类。

using System;
namespace InheritanceApplication
{
   class Shape 
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }

   // 派生类
   class Rectangle: Shape
   {
      public int getArea()
      { 
         return (width * height); 
      }
   }

   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle Rect = new Rectangle();

         Rect.setWidth(5);
         Rect.setHeight(7);

         // 打印对象的面积
         Console.WriteLine("Total area: {0}",  Rect.getArea());
         Console.ReadKey();
      }
   }
}

using System;
namespace InheritanceApplication
{
   class Shape 
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }

   // 派生类
   class Rectangle: Shape
   {
      public int getArea()
      { 
         return (width * height); 
      }
   }

   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle Rect = new Rectangle();

         Rect.setWidth(5);
         Rect.setHeight(7);

         // 打印对象的面积
         Console.WriteLine("Total area: {0}",  Rect.getArea());
         Console.ReadKey();
      }
   }
}

//运行结果：
//Total area: 35

这个：base（参数）就是将基类的构造方法体给继承过来。

c#中的多重继承

嘿嘿，他没有多重继承，当时你可以使用接口来实现多重继承

那么什么叫做多重继承呢，就是他有好几个爹，呃呃！！

a的基类只能有一个，不能有多个，但是他可以有爷爷，有儿子。

using System;
namespace InheritanceApplication
{
   class Shape 
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }

   // 基类 PaintCost
   public interface PaintCost 
   {
      int getCost(int area);

   }

   // 派生类
   class Rectangle : Shape, PaintCost
   {
      public int getArea()
      {
         return (width * height);
      }
      public int getCost(int area)
      {
         return area * 70;
      }
   }
   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle Rect = new Rectangle();
         int area;
         Rect.setWidth(5);
         Rect.setHeight(7);
         area = Rect.getArea();

         //打印对象面积
         Console.WriteLine("Total area: {0}",  Rect.getArea());
         Console.WriteLine("Total paint cost: ${0}" , Rect.getCost(area));
         Console.ReadKey();
      }
   }
}

C#的多态性

一龙生九子，九子各不同！

这里涉及到俩个定义函数的重载

函数的重载意味着方法名称一致，但是参数不同，此处的参数不同体现着参数的也行不同，个数不同，顺序不同。什么是相同呢，一模一样，但是参数的字符可以不一致。

动态多态性

C# 允许你创建一个抽象类，被用于提供部分类的接口实现。执行完成时，派生类继承它。抽象类（Abstract classes） 包含抽象方法，这是由派生类来实现的。派生类具有更具体化，专业化的功能。

以下是关于抽象类的规则：

你不能创建抽象类的实例
你不能在抽象类的外部声明抽象方法
当一个类声明为 密封的（sealed） ，它不能被继承，抽象类被不能声明为密封的。

using System;
namespace PolymorphismApplication
{
   abstract class Shape
   {
      public abstract int area();
   }
   class Rectangle:  Shape
   {
      private int length;
      private int width;
      public Rectangle( int a=0, int b=0)
      {
         length = a;
         width = b;
      }
      public override int area ()
      { 
         Console.WriteLine("Rectangle class area :");
         return (width * length); 
      }
   }

   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle r = new Rectangle(10, 7);
         double a = r.area();
         Console.WriteLine("Area: {0}",a);
         Console.ReadKey();
      }
   }
}

当你在一个类中有定义函数，并且希望它可以在一个被继承的类中实现功能时，你可以使用虚函数（virtual functions） 。虚函数可以在不同的被继承的类中实现，并且将在程序运行时调用此类函数。

动态多样性是通过抽象类和虚函数实现的。

虚函数就是在父类中定义一个函数，在子类中重写的时候可以重写的时候需要加上override

C#运算符的重载

你可以重新定义或重载大部分 C# 可用的内置操作符。因此，程序员也可以使用用户定义类型的操作符。重载操作符是特殊关键字 operator 其后跟被定义的名字的符号。像其他函数一样，重载操作符也有返回类型和参数列表

不懈的努力下终于知道这个东西是干啥的了，这玩意是重载运算符，重新定义功能，正常俩个对象相加会怎么样，会报错，重写定义的属性相加或其他就可以实现对象的相加。

C#接口

接口就是定义方法之后，在实现接口的类中实现方法

public interface ITransactions
{
   // 接口成员
   void showTransaction();
   double getAmount();
}

接口的实现过程：

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System;

namespace InterfaceApplication
{
   public interface ITransactions
   {
      // 接口成员
      void showTransaction();
      double getAmount();
   }

   public class Transaction : ITransactions
   {
      private string tCode;
      private string date;
      private double amount;
      public Transaction()
      {
         tCode = " ";
         date = " ";
         amount = 0.0;
      }

      public Transaction(string c, string d, double a)
      {
         tCode = c;
         date = d;
         amount = a;
      }

      public double getAmount()
      {
         return amount;
      }

      public void showTransaction()
      {
         Console.WriteLine("Transaction: {0}", tCode);
         Console.WriteLine("Date: {0}", date);
         Console.WriteLine("Amount: {0}", getAmount());
      }
   }
   class Tester
   {
      static void Main(string[] args)
      {
         Transaction t1 = new Transaction("001", "8/10/2012", 78900.00);
         Transaction t2 = new Transaction("002", "9/10/2012", 451900.00);
         t1.showTransaction();
         t2.showTransaction();
         Console.ReadKey();
      }
   }
}

实现方法的类中可以再写其他的方法（接口的作用就是规范，只要满足规范我们还可以扩展）

C#命名空间

（这个东西好像防止名字重复的，调用的时候会用到这个东西）

命名空间（namespace） 专为提供一种来保留一套独立名字与其他命名区分开来的方式。一个命名空间中声明的类的名字与在另一个命名空间中声明的相同的类名并不会发生冲突。

using System;
namespace first_space
{
   class namespace_cl
   {
      public void func()
      {
         Console.WriteLine("Inside first_space");
      }
   }
}

namespace second_space
{
   class namespace_cl
   {
      public void func()
      {
         Console.WriteLine("Inside second_space");
      }
   }
}

class TestClass
{
   static void Main(string[] args)
   {
      first_space.namespace_cl fc = new first_space.namespace_cl();
      second_space.namespace_cl sc = new second_space.namespace_cl();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}
//命名空间.类名调用
//Inside first_space
//Inside second_space

关键字 using

指出了该程序的命名空间名称。

using System;
using first_space;
using second_space;

namespace first_space
{
   class abc
   {
      public void func()
      {
         Console.WriteLine("Inside first_space");
      }
   }
}

namespace second_space
{
   class efg
   {
      public void func()
      {
         Console.WriteLine("Inside second_space");
      }
   }
}   

class TestClass
{
   static void Main(string[] args)
   {
      abc fc = new abc();
      efg sc = new efg();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

//Inside first_space
//Inside second_space

如果嵌套命名空间的话，我们就在using一级命名空间上加上.二级命名空间来引用

C#预处理指令

预处理指令	描述
#define	定义了一串字符，称为符号。
#undef	可以取消定义的符号。
#if	测试一个或多个表达式的结果是否为真。
#else	用于创建复合条件指令，和 #if 一起使用。
#elif	用于创建复合条件指令。
#endif	指出条件指令的结尾。
#line	可以修改编译器的行号，选择性修改输出错误和警告的文件名
#error	从代码的特定位置生成误差
#warning	从代码的特定位置生成一级预警
#region	当你使用 Visual Studio 代码编译器时，你可以展开或折叠一部分代码块
#engregion	它标志着 #region 块的结束

这个东西就是一个判断，感觉用的不多。

C#正则表达式

很多种类的字符，运算符，结构体可以定义正则表达式。

转义字符
字符类
集合
分组构造
限定符
回溯引用构造
可替换结构
替换
混合结构

Regex正则表达式类

Sr.No	方法
1	public bool IsMatch(string input) 指出输入的字符串中是否含有特定的正则表达式。
2	public bool IsMatch(string input, int startat) 指出输入的字符串中是否含有特定的正则表达式，该函数的 startat 变量指出了字符串开始查找的位置。
3	public static bool IsMatch(string input, string pattern) 指出特定的表达式是否和输入的字符串匹配。
4	public MatchCollection Matches(string input) 在所有出现的正则表达式中搜索特定的输入字符
5	public string Replace(string input, string replacement) 在一个特定的输入字符中，用特定的字符串替换所有满足某个表达式的字符串。
6	public string[] Split(string input) 将一个输入字符拆分成一组子字符串，从一个由正则表达式指出的位置上开始。

C#异常处理

异常是程序执行过程中产生的问题，c#异常是对程序运行过程中出现的额外情况的一种反馈

C# 异常处理有四个关键词：try，catch，finally，throw。

try：try 块标识代码块的哪些特定的异常将被激活。它的后面是一个或多个 catch 块。
catch：一个用于捕获异常的程序段，将 catch 放在你希望能处理这个异常的地方。“catch”这个关键字标志着异常的捕获。
finally：finally 保证了无论是否有异常抛出，此代码段中的程序都会被执行。例如，如果你打开了一个文件，那么不管是否发生了异常，文件都需要关闭。
throw：当出现问题时，程序会抛出异常。这项工作是通过使用 throw 来实现的。


    try
    {
        // statements causing exception
    }
    catch( ExceptionName e1 )
    {
        // error handling code
    }
    catch( ExceptionName e2 )
    {
        // error handling code
    }
    catch( ExceptionName eN )
    {
        // error handling code
    }
    finally
    {
        // statements to be executed
    }

C# 异常由类表示。

在 C# 中的异常类主要是直接或间接地来源于 System.Exception 类。有些从 System.Exception 类派生的异常类，它们是 System.ApplicationException 和 System.SystemException 类。

System.ApplicationException 类支持由应用程序生成的异常。因此，由程序员定义的异常应该源于这个类。

System.SystemException 类是所有预定义的系统异常的基类。

下表提供了一些从 Sytem.SystemException 类派生的预定义的异常类：

Exception类	描述
System.IO.IOException	处理 I/O 错误
System.IndexOutOfRangeException	处理的方法是指当一个数组索引超出范围的错误产生
System.ArrayTypeMismatchException	处理时，类型不匹配的数组类型产生的错误
System.NullReferenceException	处理从取消引用一个空对象产生的错误
System.DivideByZeroException	处理来自将一个除零而产生的错误
System.InvalidCastException	处理类型转换过程中产生的错误
System.OutOfMemoryException	处理来自可用内存不足产生的错误
System.StackOverflowException	处理从堆栈溢出产生的错误

自定义异常

  using System;
    namespace UserDefinedException
    {
        class TestTemperature
        {
            static void Main(string[] args)
            {
                Temperature temp = new Temperature();
                try
                {
                    temp.showTemp();
                }
                catch(TempIsZeroException e)
                {
                    Console.WriteLine("TempIsZeroException: {0}", e.Message);
                }
                Console.ReadKey();
            }
        }
    }

    public class TempIsZeroException: ApplicationException
    {
        public TempIsZeroException(string message): base(message)
        {
        }
    }

    public class Temperature
    {
        int temperature = 0;
        public void showTemp()
        {
            if(temperature == 0)
            {
                throw (new TempIsZeroException("Zero Temperature found"));
            }
            else
            {
                Console.WriteLine("Temperature: {0}", temperature);
            }
        }
    }
//运行结果：
//TempIsZeroException: Zero Temperature found

文件I/O

山鸟同学

关注

7
点赞
踩
51

收藏

觉得还不错? 一键收藏
打赏
0
评论
C#入门基础知识总结

Public 访问修饰符允许一个类将其成员变和成员函数暴露给其他的函数和对象。任何公有成员可以被外部的类访问。Private 访问修饰符允许一个类将其成员变量和成员函数对其他的函数和对象进行隐藏。只有同一个类中的函数可以访问它的私有成员。即使是类的实例也不能访问它的私有成员。
复制链接

扫一扫