C# 编程（基础）
环境 | 程序结构 | 基本语法
一、C# 和 .NET
- .NET 是微软推出的一个应用软件的开发平台，支持用 C# 语言进行编程
二、基本语法
using System;
namespace RectangleApplication
{
class Rectangle
{
// 成员变量
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();
}
}
}
1、基本语法总结
- using 关键字用来包含命名空间可以有多个；
- 类及其实例化、成员变量、成员函数都和java里的感觉差不多，注释也一样；
- 标识符的规则基本一样就是多了个 @ 符号，数字依旧是不能作为开头；
2、需要注意的几点
- C# 是大小写敏感的。
- 所有的语句和表达式必须以分号（;）结尾。
- 程序的执行从 Main 方法开始。
- 与 Java 不同的是，文件名可以不同于类的名称。
数据类型 | 变量 | 运算符
一、数据类型
1、值类型
- 记住这几个，其他的和java差不多：decimal、sbyte、ushort、uint、ulong（分有符号和无符号的）
- 可以用 sizeof 方法判断数据类型的大小（获得的是字节数）
2、引用类型
- 引用类型的概念基本和 java 是一样的，内置的 引用类型有：object、dynamic 和 string
object
- 是所有数据类型的终极基类，可以赋值为任何的数据类型
- 也存在拆箱和装箱的概念，而且和 java 好像也差不多的概念
dynamic
dynamic d = 20;可以存储任何类型的值在动态数据类型变量中- 对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的
string
- 两种表示方法：
string str = @"C:\Windows"; string str = "C:\\Windows"; - 使用 @ 符号的好处在于转义字符会失去意义变成普通的，还可以随意换行，不过换行符及缩进空格都计算在字符串长度之内
3、指针类型
char* cptr;- 指针类型变量存储另一种类型的内存地址，C# 中的指针与 C 或 C++ 中的指针有相同的功能
4、类型转换
- 隐式类型转换 ：从小的整数类型转换为大的整数类型，从派生类转换为基类，默认转换是安全的
- 显式类型转换 ：需要强制转换运算符，而且强制转换会造成数据丢失，强转和 java 的语法是一样的
- 转换方法：toByte、toChar、toDouble等方法也可以完成类型的转换，这些方法都是属于 Convert 类的
二、变量
- 和 java 一样是强类型，类型决定了变量的内存大小和布局
- C# 允许定义其他值类型的变量，比如 enum，也允许定义引用类型变量，比如 class
1、变量定义和初始化
- 和 java 没啥区别嘛
- 接受来自用户的值：就是命令行 `Console.ReadLine();
- C# 中的 Lvalues 和 Rvalues：和 c 中的概念差不多（变量是 Lvalues，出现在等号的左右都可以，但是值只能是 Rvalues的）
2、常量
- 概念和 java 一样，就是运行过程中不能改变的特殊变量；
- char 用单引号，string 用双引号，这和 java 又是一样的；
- 定义常量：
const int h=1;
三、运算符
1、算术运算符
- 也有 ++ 和 - - ：使用的细节都和 java 是一毛一样的像
2、关系、逻辑、位、赋值运算符：无话可说
3、其他运算符
- sizeof 和 typeof
- & 返回变量地址；* 变量的指针；
- 支持三目运算符
- is 和 as：is 用于判断对象类型，as 用于强制转换，失败也不抛异常
- 运算符优先级有万能的括号
语句 | 方法 | 封装
一、语句
1、判断
if–else
- 和 java 一样
switch
- 使用和基本的特性和 java 也差不多是一样的
- 比较的类型可以是整形或枚举，或者可以转换为二者之一的 class
2、循环
- while/do–while
- for/foreach
- break/continue
int[] fibarray = new int[] { 0, 1, 1, 2, 3, 5, 8, 13 };
foreach (int element in fibarray)
{
System.Console.WriteLine(element);
}
二、封装
- 一个访问修饰符定义了一个类成员的范围和可见性:
- public：所有对象都可以访问；
- private：对象本身在对象内部可以访问，类成员默认的修饰符；
- protected：只有该类对象及其子类对象可以访问
- internal：同一个程序集的对象可以访问；
- protected internal：访问限于当前程序集或派生自包含类的类型，就是两个修饰符的并集
三、方法
1、方法参数传递
- 方法的定义和调用和 java 没啥不同，方法参数传递存在一些差异
按值传递
按引用传递
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void swap(ref int x, ref int y)
{
int temp;
temp = x; /* 保存 x 的值 */
x = y; /* 把 y 赋值给 x */
y = temp; /* 把 temp 赋值给 y */
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 局部变量定义 */
int a = 100;
int b = 200;
Console.WriteLine("在交换之前，a 的值： {0}", a);
Console.WriteLine("在交换之前，b 的值： {0}", b);
/* 调用函数来交换值 */
n.swap(ref a, ref b);
Console.WriteLine("在交换之后，a 的值： {0}", a);
Console.WriteLine("在交换之后，b 的值： {0}", b);
Console.ReadLine();
}
}
}
按输出传递
- 提供给输出变量的参数不需要赋值；
- return 只能返回一个值，输出参数可以返回多个值；
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void getValues(out int x, out int y )
{
Console.WriteLine("请输入第一个值： ");
x = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("请输入第二个值： ");
y = Convert.ToInt32(Console.ReadLine());
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 局部变量定义 */
int a , b;
/* 调用函数来获取值 */
n.getValues(out a, out b);
Console.WriteLine("在方法调用之后，a 的值： {0}", a);
Console.WriteLine("在方法调用之后，b 的值： {0}", b);
Console.ReadLine();
}
}
}
数据类型（扩展）
一、可空类型
1、可空类型的两种定义方法
int? num1 = null;
int? num2 = 45;
double? num3 = new double?();
double? num4 = 3.14157; // 可空类型的默认值为 null
2、null合并运算符（？？）
double? num1 = null;
double num3;
num3 = num1 ?? 5.34; // num1 如果为空值则返回 5.34
二、数组
- C#中数组的定义、初始化、赋值、防问和遍历都和 java 是差不多的
- 多维数组
string [,] names = { { "a","b"},{"b","c" } };; //二维数组
int [ , , ] m; //三维数组
int val = a[2,3]; //数组访问
- 交错数组
int[][] scores = new int[2][]{new int[]{92,93,94},new int[]{85,66,87,88}};
交错数组和多维数组的比较：
- 多维数组必须指定每一维的长度，而交错数组至少指定第一维的长度；
- 多维数组的length属性指的是总元素的个数，而交错数组指的是内部的数组个数；
- 多维数组必须保证行列的一致，而交错数组里面的数组大小可以不一致，更加灵活；
- 参数数组：通过这个可以实现类似 java 中的可变参
public int AddElements(params int[] arr)
int sum = app.AddElements(512, 720, 250, 567, 889);
- Array 类：重要的属性和方法 length、reverse（）、sort（）
三、字符串
- 和 java 中的字符串的用法基本相同，也支持加号的连接
- 重要属性和方法：length、chars、Compare（）、Contains（）、Substring（）、Join（）
四、结构体
struct Books
{
public string title;
public string author;
public string subject;
public int book_id;
};
1、基本的特点
- 结构可带有方法、字段、索引、属性、运算符方法和事件。
- 结构可实现一个或多个接口。
- 结构成员不能指定为 abstract、virtual 或 protected。
2、和类的比较
- 类是引用类型，结构是值类型。
- 结构不支持继承。
- 结构可以定义构造函数，但是不能声明默认的构造函数。
- 与类不同，结构可以不使用 New 操作符即可被实例化，不使用 New 操作符，只有在所有的字段都赋值，对象才能使用
Book book = new Book();
Console.WriteLine(book.ToString());
Book book2;
book2.book_id = 100;
book2.book_name = "bible";
book2.author = "jesus";
Console.WriteLine(book2.author);
struct Book
{
public int book_id;
public string book_name;
public string author;
}
五、枚举
- 枚举属于值类型，枚举列表中的每个符号代表一个整数值，一个比它前面的符号大的整数值。默认情况下，第一个枚举符号的值是 0
using System;
public class EnumTest
{
enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat };
static void Main()
{
int x = (int)Day.Sun;
int y = (int)Day.Fri;
Console.WriteLine("Sun = {0}", x);
Console.WriteLine("Fri = {0}", y);
}
}
面向对象
一、c# 中的类
1、类定义
- 类的默认访问标识符是 internal，成员的默认访问标识符是 private
2、成员函数和封装
- 和 java 基本一致，属性私有，对外提供调用方法
3、构造函数
- 和 java 也基本一样，默认的是一个无参的构造函数，也可以定义有参的构造函数
4、析构函数
- 析构函数用于在结束程序（比如关闭文件、释放内存等）之前释放资源，析构函数不能继承或重载，没有参数和返回值
class Line
{
private double length; // 线条的长度
public Line() // 构造函数
{
Console.WriteLine("对象已创建");
}
~Line() //析构函数
{
Console.WriteLine("对象已删除");
}
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("线条的长度： {0}", line.getLength());
}
}
5、静态成员
- 静态成员的概念基本和java的也是一样的，类的所有对象共享一份
- 静态函数只能访问静态变量
二、继承
- c# 不支持多重继承，一个类只能继承一个类，但是可以实现多个接口来间接实现多继承
1、继承的语法
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);
}
}
2、基类初始化
- 基本和 java 中在子类构造函数中用 super（）调用父类的构造器
class Rectangle
{
// 成员变量
protected double length;
protected double width;
public Rectangle(double l, double w)
{
length = l;
width = w;
}
public double GetArea()
{
return length * width;
}
public void Display()
{
Console.WriteLine("长度： {0}", length);
Console.WriteLine("宽度： {0}", width);
Console.WriteLine("面积： {0}", GetArea());
}
}//end class Rectangle
class Tabletop : Rectangle
{
private double cost;
public Tabletop(double l, double w) : base(l, w)
{ }
public double GetCost()
{
double cost;
cost = GetArea() * 70;
return cost;
}
public void Display()
{
base.Display();
Console.WriteLine("成本： {0}", GetCost());
}
}
三、多态
- 对多态的一个基本的理解就是：同一个事件发生在不同的对象上会产生不同的结果
1、静态多态
- 在编译时，函数和对象的连接机制被称为早期绑定，也被称为静态绑定，C# 提供了函数重载和运算符重载来实现静态多态性
函数重载
- 基本还是和 java 差不多的概念，方法的重载和返回值无关，只和参数列表有关
运算符重载
- 重载运算符是具有特殊名称的函数，是通过关键字 operator 后跟运算符的符号来定义的
- 与其他函数一样，重载运算符有返回类型和参数列表
- 运算符重载实现
using System;
namespace OperatorOvlApplication
{
class Box
{
private double length; // 长度
private double breadth; // 宽度
private double height; // 高度
public double getVolume()
{
return length * breadth * height;
}
public void setLength( double len )
{
length = len;
}
public void setBreadth( double bre )
{
breadth = bre;
}
public void setHeight( double hei )
{
height = hei;
}
// 重载 + 运算符来把两个 Box 对象相加
public static Box operator+ (Box b, Box c)
{
Box box = new Box();
box.length = b.length + c.length;
box.breadth = b.breadth + c.breadth;
box.height = b.height + c.height;
return box;
}
}
class Tester
{
static void Main(string[] args)
{
Box Box1 = new Box(); // 声明 Box1，类型为 Box
Box Box2 = new Box(); // 声明 Box2，类型为 Box
Box Box3 = new Box(); // 声明 Box3，类型为 Box
double volume = 0.0; // 体积
// Box1 详述
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// Box2 详述
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// Box1 的体积
volume = Box1.getVolume();
Console.WriteLine("Box1 的体积： {0}", volume);
// Box2 的体积
volume = Box2.getVolume();
Console.WriteLine("Box2 的体积： {0}", volume);
// 把两个对象相加
Box3 = Box1 + Box2;
// Box3 的体积
volume = Box3.getVolume();
Console.WriteLine("Box3 的体积： {0}", volume);
Console.ReadKey();
}
}
}
- 不可重载的运算符
| 运算符 | 描述 |
|---|---|
&&, || |
这些条件逻辑运算符不能被直接重载。 |
+=, -=, *=, /=, %= |
这些赋值运算符不能被重载。 |
=, ., ?:, ->, new, is, sizeof, typeof |
这些运算符不能被重载。 |
2、动态多态
- 动态多态性是通过 抽象类 和 虚方法|抽象方法 实现的
抽象类
- 不能创建一个抽象类的实例
- 不能在一个抽象类外部声明一个抽象方法
- sealed 修饰的类为密封类，不能被继承，抽象类不能被声明为 sealed
abstract class Shape
{
abstract public 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 类的面积：");
return (width * length);
}
}
虚方法和抽象方法
- 虚方法有方法体，抽象方法没有方法体
- 抽象方法只能在抽象类中声明，虚方法不是
- 派生类必须重写抽象类中的抽象方法，虚方法则不必要
- 下面的例子中需要注意属性和 get set 方法的写法和 java 有所不同
public class Shape
{
public int X { get; private set; }
public int Y { get; private set; }
public int Height { get; set; }
public int Width { get; set; }
// 虚方法
public virtual void Draw()
{
Console.WriteLine("执行基类的画图任务");
}
}
class Circle : Shape
{
public override void Draw()
{
Console.WriteLine("画一个圆形");
base.Draw();
}
}
四、接口
- 接口定义了所有类继承接口时应遵循的语法合同，接口定义了语法合同 “是什么” 部分，派生类定义了语法合同 “怎么做” 部分，接口之间可以有继承关系
- 接口中的方法虽然没有方法体，但是应该不叫抽象方法；实现接口方法的时候不能用 override 修饰
using System;
interface IMyInterface
{
// 接口成员
void MethodToImplement();
}
class InterfaceImplementer : IMyInterface
{
static void Main()
{
InterfaceImplementer iImp = new InterfaceImplementer();
iImp.MethodToImplement();
}
public void MethodToImplement()
{
Console.WriteLine("MethodToImplement() called.");
}
}
命名空间 | 预处理指令
一、命名空间
- 和 java 中的包的概念很类似，起一个隔离类的作用，两个不同命名空间的类可以同名
- using 的概念基本和 java 中的 import差不多，命名空间是可以嵌套的，命名空间的成员用 . 符号进行访问
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();
}
}
二、预处理指令
1、预处理指令概述
- 预处理器指令指导编译器在实际编译开始之前对信息进行预处理
- C# 编译器没有一个单独的预处理器，但指令被处理时就像是有一个单独的预处理器一样
- 在 C# 中，预处理器指令用于在 条件编译 中起作用
- 与 C 和 C++ 不同的是，它们不是用来创建宏
#define DEBUG
#define VC_V10
using System;
public class TestClass
{
public static void Main()
{
#if (DEBUG && !VC_V10)
Console.WriteLine("DEBUG is defined");
#elif (!DEBUG && VC_V10)
Console.WriteLine("VC_V10 is defined");
#elif (DEBUG && VC_V10)
Console.WriteLine("DEBUG and VC_V10 are defined");
#else
Console.WriteLine("DEBUG and VC_V10 are not defined");
#endif
Console.ReadKey();
}
}
2、对预处理命令的进一步理解
- 预处理命令和 if–else 语句具有类似的功能，但不同的是预处理命令是在编译前对代码进行处理，未执行部分是不需要编译的，而 if–else 是在运行的时候起作用
正则表达式 | 异常处理 | 文件输入输出
一、正则表达式
- 正则表达式基本是独立于语言的，所以这里就稍作补充即可
1、正则补充
字符转义
字符类
定位点
分组构造
限定符
反向引用构造
备用构造
替换
杂项构造
2、Regex 类
- 就是一个表示正则表达式的类
- 相关的类还有 MatchCollection 和 Match，分别表示匹配集合和单个的匹配
//输出匹配集合
MatchCollection mc = Regex.Matches(text, expr);
foreach (Match m in mc)
{
Console.WriteLine(m);
}
//替换匹配内容
string input = "Hello World ";
string pattern = "\\s+";
string replacement = " ";
Regex rgx = new Regex(pattern);
string result = rgx.Replace(input, replacement);
二、异常处理
1、重要的异常类
- System.Exception 类：所有异常类的基类，System.ApplicationException 和System.SystemException 类是派生于 System.Exception 类的异常类
- System.ApplicationException 类支持由应用程序生成的异常，自定义的异常都应派生自该类
- System.SystemException 类是所有预定义的系统异常的基类
2、示例代码
- 异常的处理还是：try-catch-finally，抛出还是用 throw
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);
}
}
}
三、文件输入输出
1、FileStream 类
FileStream F = new FileStream("sample.txt", FileMode.Open, FileAccess.Read, FileShare.Read);- FileMode 枚举定义了各种打开文件的方法，FileMode 枚举的成员有：
- Append：内容追加到文件末尾，不存在则创建
- Create：创建一个新的文件，存在旧的话，旧的会被删除
- CreateNew：创建一个新的文件，已存在，则抛出异常
- Open：打开一个已有的文件。如果文件不存在，则抛出异常。
- OpenOrCreate：有就打开没有就创建
- Truncate：打开一个已有的文件，向文件写入全新的数据，不存在则抛出异常
- FileAccess 枚举的成员有：Read、ReadWrite 和 Write。
- FileShare 枚举的成员有：Inheritable、None、Read、ReadWrite、Write、Delete
using System;
using System.IO;
namespace FileIOApplication
{
class Program
{
static void Main(string[] args)
{
FileStream F = new FileStream("test.dat",
FileMode.OpenOrCreate, FileAccess.ReadWrite);
for (int i = 1; i <= 20; i++)
{
F.WriteByte((byte)i);
}
F.Position = 0;
for (int i = 0; i <= 20; i++)
{
Console.Write(F.ReadByte() + " ");
}
F.Close();
Console.ReadKey();
}
}
}
2、文本文件的读写
- StreamReader 和 StreamWriter 类用于文本文件的数据读写
- 这些类从抽象基类 Stream 继承，Stream 支持文件流的字节读写
using System;
using System.IO;
namespace FileApplication
{
class Program
{
static void Main(string[] args)
{
string[] names = new string[] { "Zara Ali", "Nuha Ali" };
//USING 语句会自动关闭相应的流，不用手动 close
using (StreamWriter sw = new StreamWriter("names.txt"))
{
foreach (string s in names)
{
sw.WriteLine(s);
}
}
// 从文件中读取并显示每行
string line = "";
using (StreamReader sr = new StreamReader("names.txt"))
{
while ((line = sr.ReadLine()) != null)
{
Console.WriteLine(line);
}
}
Console.ReadKey();
}
}
}
3、二进制文件的读写
- BinaryReader 和 BinaryWriter 类用于二进制文件的读写
using System;
using System.IO;
namespace BinaryFileApplication
{
class Program
{
static void Main(string[] args)
{
BinaryWriter bw;
BinaryReader br;
int i = 25;
double d = 3.14157;
bool b = true;
string s = "I am happy";
// 创建文件
try
{
bw = new BinaryWriter(new FileStream("mydata",
FileMode.Create));
}
catch (IOException e)
{
Console.WriteLine(e.Message + "\n Cannot create file.");
return;
}
// 写入文件
try
{
bw.Write(i);
bw.Write(d);
bw.Write(b);
bw.Write(s);
}
catch (IOException e)
{
Console.WriteLine(e.Message + "\n Cannot write to file.");
return;
}
bw.Close();
// 读取文件
try
{
br = new BinaryReader(new FileStream("mydata",
FileMode.Open));
}
catch (IOException e)
{
Console.WriteLine(e.Message + "\n Cannot open file.");
return;
}
try
{
i = br.ReadInt32();
Console.WriteLine("Integer data: {0}", i);
d = br.ReadDouble();
Console.WriteLine("Double data: {0}", d);
b = br.ReadBoolean();
Console.WriteLine("Boolean data: {0}", b);
s = br.ReadString();
Console.WriteLine("String data: {0}", s);
}
catch (IOException e)
{
Console.WriteLine(e.Message + "\n Cannot read from file.");
return;
}
br.Close();
Console.ReadKey();
}
}
}
4、Windows 文件系统的操作
- DirectoryInfo 类派生自 FileSystemInfo 类。它提供了各种用于创建、移动、浏览目录和子目录的方法。该类不能被继承。
- FileInfo 类派生自 FileSystemInfo 类。它提供了用于创建、复制、删除、移动、打开文件的属性和方法，且有助于 FileStream 对象的创建。该类不能被继承。
using System;
using System.IO;
namespace WindowsFileApplication
{
class Program
{
static void Main(string[] args)
{
// 创建一个 DirectoryInfo 对象
DirectoryInfo mydir = new DirectoryInfo(@"c:\Windows");
// 获取目录中的文件以及它们的名称和大小
FileInfo [] f = mydir.GetFiles();
foreach (FileInfo file in f)
{
Console.WriteLine("File Name: {0} Size: {1}",
file.Name, file.Length);
}
Console.ReadKey();
}
}
}
参考：菜鸟教程