c# 学习记录

最新推荐文章于 2022-08-09 11:58:34 发布
最新推荐文章于 2022-08-09 11:58:34 发布
阅读量369 收藏 4
点赞数 1
分类专栏： c# 菜鸟教程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hejiegoubao/article/details/106639911
版权 
console.Write("Hello world!");
与
console.Writeline("Hello world!");
//区别：前者输出不换行，后者输出换行

console.Readkey();
//这个函数是为了在控制台窗口停留一下，直到敲击键盘为止。
//不然运行时，"Hello World!" 这句话会在控制台窗口一闪而过，没法查看。

输入和输出

console.Write();  //输出不换行
Console.WriteLine();  //输出并换行
Console.ReadLine();  //读取键盘输入的所有字符，返回字符串。按下回车键退出
Console.Read();   //读取键盘输入的第一个字符，返回对应的ASCII值，按下回车键退出
Console.Readkey();  //等待用户按下任意键并执行退出(此函数的作用是为了在控制台窗口停留一下，直到用户敲击键盘为止。不然运行时，"Hello World!" 这句话会在控制台窗口一闪而过，没法查看。)

using System; //using关键字用于在程序中包含System命名空间，一个程序一般有多个using语句
namespace HelloWorldApplication //namespace声明，namespace包含一系列的类，HelloWorldApplication包含类Helloworld
{
	class HelloWorld 
	//class声明。类HelloWorld包含程序使用的数据和方法声明。
	static void Main(string[] args)
	//Main方法，是所有c#程序的入口点。说明当执行时类将做什么动作
	{
		Console.WriteLine("Hello World")
		//指定它的行为，定义在System命名空间中的Console类的一个方法
		Console.ReadKey()
		//针对VS.NET用户，使得程序等待一个按键的动作，防止程序从Visual Studio.NET启动时屏幕会快速运行并关闭
		}

占位符

static void main(string[] args)
{
	Console.WriteLines("A:{0}, a:{1}",65, 97);
	//当WriteLines()函数有多个参数时，输出第一个参数的内容，而第二个参数中的内容替换掉第一个参数中的占位符一起输出
	Console.WriteLines("A:,a:",65, 97)
	//输出  A:,a:
	//如果第一个参数没有留占位符，那么第二个参数内容不输出
	Console.WriteLine("A:{1}，a:{0}",65,97);
	//运行结果 A:97,a:65
	//占位符从零开始计数，且占位符中的数字不能大于第二参数的个数减一（要求占位符必须有可替换的值）占位符数字与第二参数字符一一对应
	Console.ReadLine();
}

运行结果

A：65，a:97

XML注释

///也是一种注释，但是这种注释主要有两种作用：
1.这些注释能够生成一个XML文件，这样，看起来会对程序内容一目了然；
2.以这种方式对你的类，属性，方法等等加上注释之后，当你在其他地方使用以这种方式加上的类，属性，方法等的时候，下方提示框会将你写的注释显示出来，使你更加明白你要使用的内容的作用；

/// <summary>
/// 定义用户姓名属性，该属性为可读可写属性
/// </summary>

数据类型

变量类型：

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

值类型
从类System.ValueType中派生；

类型描述范围默认值
byte8位无符号整数类型0—2550
decimal128位精确的十进制值，28—29有效位数(-7.9 x 1028到 7.9 x 1028) / 10^(0 到 28)^0.0M
sbyte8位有符号整数类型-128~1270
uint32位无符号整数类型0 到 4,294,967,2950
ulong64 位无符号整数类型0 到 18,446,744,073,709,551,6150
ushort16 位无符号整数类型0 到 65,5350

引用类型
包含对变量的引用；指向一个内存位置；
内置的引用类型：object，dynamic和string
对象（object）类型
对象类型是c#通用类型系统（common Type System -CTS）所有数据类型的终极基类；object是System.Object类型的别名。对象（object）类型可以被分配任何其他类型（值类型，引用类型，预定义类型或用户自定义类型）的值。在分配前，一定要进行类型转换；
当一个值类型转化为对象类型，被称为装箱；当一个对象类型转化为值类型，称为拆箱；

object obj;
obj = 100; //装箱

动态（Dynamic）类型
可以存储任何类型的值在动态数据类型变量中，这些变量检查在运行时发生的。
声明动态类型的语法：

dynamic<variable_name> = name;
dynamic d = 20;

对象类型变量的类型检查在编译时发生，而动态类型变量的类型检查在运行时发生；

字符串类型
允许给变量分配任意字符串值。String是System.String类的别名。从Object类型派生，String类型的值分配形式：引号和@引号；

String str = "runoob.com";
@"runoob.com";

字符串前面可加@将转义字符（\）当作普通字符对待：

string str = @"c:\windows";
string str = "c:\\windows";

@字符串中可以任意换行，换行符及缩进空格都计算在字符串长度以内

string str = @"<script type = ""text/javascript"">
	<!--
	-->
</script>";

指针类型
声明指针类型

char* cptr;
int* iptr;

类型转换

隐式类型转换；
显示类型转换；

C#类型转换方法

序号方法&描述
1ToBoolan 将类型转化为bool类型
2ToByte 把类型转化为字节类型
3ToChar 把类型转化为单个Unicode字符类型
4ToDateTime 把类型（整型或字符串）转化为日期-时间结构
5ToDecimal 把浮点型或整型类型转化为十进制型
6ToDouble 把类型转换为双精度浮点型

其他见参考文档

string s1 = "abcd";
string s2 = "1234";
int a, b;
bool bol = int.TryParse(s1, out a);
//把数字内容的字符串转化为int类型，比int.Parse(string s)好，不会出现异常，如果转换成功则输出相应的值，转换失败则输出0
Console.WriteLine(s1 + " " + bol + " " + a);
bool bo2 = int.TryParse(s2, out b);
Console.WriteLine(s2 + " " + bo2 + " " + b);

convert.toint32()偶数值

double a = 1.35;
double b = 1.65;
int a1 = Convert.ToInt32(a);
int a2 = (int)(a);
int b1 = Convert.ToInt32(b);
int b2 = (int)b;

Console.WriteLine("{0}使用convert方法转化的结果为：{1}", a, a1);
Console.WriteLine("{0}使用int方法转化的结果为：{1}", a, a2);
Console.WriteLine("{0}使用convert方法转化的结果为：{1}", b, b1);
//输出2， 四舍五入
Console.WriteLine("{0}使用int方法转化的结果为：{1}", b, b2);

try catch

static void Main(string[] args)
{
    try
    {
        Console.WriteLine("输入数字，计算出加一的答案");
        int a = int.Parse(Console.ReadLine());   //用户输入的东西，以字符串形式呈现
        Console.WriteLine("答案是{0}", ++a);
        Console.ReadKey();
    }
    catch(Exception)
    {
        Console.WriteLine("无法转换");
    }
    Console.ReadKey();
}

变量

值类型

类型举例
整数类型sbyte、byte、short、ushort、int、uint、long、ulong 和 char
浮点型float 和 double
十进制类型decimal
布尔类型true 或 false 值，指定的值
空类型可为空值的数据类型
 num = Convert.ToInt32(Console.ReadLine());  //Console.ReadLine():用于接受用户输入，并把它存储在一个变量中
 //Convert.ToInt32() 把用户输入的数据转换为 int 数据类型，Console.Readline()只接受字符串格式的数据

C#中的Lvalues和Rvalues
表达式：

  1. Lvalue:可以出现在赋值语句的左边或右边；
  2. Rvalues:rvalue表达式可以出现在赋值语句的右边，不能出现在左边；
    变量是lvalue，可以出现在赋值语句的左边；数值是Rvalue,不能被赋值，不能出现在赋值语句的左边；
double a = 42.29;
int b = 4229;
double c = a + b;  // 当一个精度高的数据类型与一个精度低的数据类型进行运算时，定义运算结果必须与精度最高的变量类型相同。这是为了防止在运算过程中造成数据丢失
Console.WriteLine("c = {0}", c);
Console.ReadKey();

常量

整数常量
可以是十进制、八进制或者十六进制的常量；0X表示十六进制，0表示八进制，整数常量也可以有后缀，可以是U和L的组合，后缀可以是大写或者是小写；

0XFeeL  //合法
032UU   //非法不能重复后缀

浮点常量
一个浮点常量是由整数部分、小数点、小数部分和指数部分组成。

314159E-5L   //合法
510E   //非法，不完整指数
210f   //非法，没有小数或指数
.e55   //非法，缺少整数或小数

使用小数形式时，必须包含小数点、指数或者同时包含；使用指数形式时，必须包含整数部分、小数部分或者同时包含；

字符常量
字符串常量

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                //string a = "0.2";
                //string a = null;
                string a = "";
                try
                {
                    double d1 = Double.Parse(a);
                }
                catch (Exception err)
                {
                    Console.WriteLine("d1转换出错：" + err.Message);
                }
                try
                {
                    double d2 = Convert.ToDouble(a);
                }
                catch (Exception err)
                {
                    Console.WriteLine("d2转换出错：" + err.Message);
                }
                try
                {
                    double d3;
                    Double.TryParse(a, out d3);
                }
                catch (Exception err)
                {
                    Console.WriteLine("d3转换出错：" + err.Message);
                }
            }
            finally
            {
                Console.ReadKey();
            }

        }
    }
}

//null 输出：d1转换出错：Value cannot be null. (Parameter 's')
//""  输出： d1转换出错：Input string was not in a correct format.
//          d2转换出错：Input string was not in a correct format.

常量变量命名规则
带有private私有访问修饰符的常量要以骆驼命名法命名。即以下划线开头，第一个单词首字母小写，余下单词首字母大写；

private const string _bookName = "新华字典";

带有public公共修饰符，protected受保护修饰符等的常量要以帕斯卡命名法命名，即每个单词首字母大写；

public const int BookPrice = 10;

运算符

算数运算符
关系运算符
逻辑运算符
位运算符
其他运算符

运算符描述实例
is判断对象是否为某一类型is(Ford is car)
as强制转换，即使转换失败也不会抛出异常Object obj = new StringReader(“Hello”); StringReader r = obj as StringReader;

c#中的运算符优先级
见文档

循环

for each

int[] finary = new int[] { 0, 1, 2, 3, 4, 5 };
foreach(int element in finary)
{
   System.Console.WriteLine(element);
}

int count = 0;
foreach (int c in finary)
{
   count++;
   System.Console.WriteLine("Element #{0}: {1}", count, c);
}
System.Console.WriteLine("Number in array: {0}", count);

封装

访问修饰符

  • public:所有对象都可以访问；
  • private：对象本身在对象内部可以访问；
  • protected：只有该类对象及其子类对象可以访问
  • internal:同一个程序集对象可以访问；
  • protected internal:访问限于当前程序集或派生自包含类的类型；

Internal访问修饰符
允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。换句话说，带有internal访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类和方法访问。

using System;

namespace RectangleApplication
{
    class Rectangle
    {
        //成员变量
        internal double length;
        internal double width;
       
        double GetArea()
        {
            return length * width;
        }
       public void Display()
        {
            Console.WriteLine("长度： {0}", length);
            Console.WriteLine("宽度： {0}", width);
            Console.WriteLine("面积： {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();
        }
    }
}

方法

按引用传递参数
使用关键字ref关键字声明引用参数；

using System;

namespace CaculatorApplication
{
    class NumberManipulator
    {
        public void swap(ref int x, ref int y)
        {
            int temp = x;
            x = y;
            y = temp;
        }

        static void Main(string[] args)
        {
            NumberManipulator n = new NumberManipulator();
            int a = 100, 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.ReadKey();

        }
    }
}

按输出传递参数
使用输出参数来从函数中返回两个值；输出参数会把方法输出数据赋给自己，其他方面与引用相似；

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

      }
   }
}
当上面的代码被编译和执行时，它会产生下列结果：

在交换之前，a 的值：100
在交换之前，b 的值：200
在交换之后，a 的值：200
在交换之后，b 的值：100
结果表明，swap 函数内的值改变了，且这个改变可以在 Main 函数中反映出来。

按输出传递参数
return 语句可用于只从函数中返回一个值。但是，可以使用 输出参数 来从函数中返回两个值。输出参数会把方法输出的数据赋给自己，其他方面与引用参数相似。

下面的实例演示了这点：

实例
using System;

namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValue(out int x )
      {
         int temp = 5;
         x = temp;
      }
   
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* 局部变量定义 */
         int a = 100;
         
         Console.WriteLine("在方法调用之前，a 的值： {0}", a);
         
         /* 调用函数来获取值 */
         n.getValue(out a);

         Console.WriteLine("在方法调用之后，a 的值： {0}", a);
         Console.ReadLine();

      }
   }
}
当上面的代码被编译和执行时，它会产生下列结果：

在方法调用之前，a 的值： 100
在方法调用之后，a 的值： 5
提供给输出参数的变量不需要赋值。当需要从一个参数没有指定初始值的方法中返回值时，输出参数特别有用。请看下面的实例，来理解这一点：

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

//输出：
/*请输入第一个值：
7
请输入第二个值：
8
在方法调用之后，a 的值： 7
在方法调用之后，b 的值： 8
*/

ref型传递变量前，变量必须初始化，否则编译器会报错，而out型不需要初始化；
out型数据在方法中必须要赋值，否则编译器会报错；

class C
{
    //1. in型参数
    public void sum(int a, int b) {
        a += b;
    }
    //2. ref型参数
    public void sum(ref int a, int b)
    {
        a += b;
    }
    //3. out型参数
    public void sum1(out int a, int b)
    {
        a = b+2;
        //改为 a += b;编译器会报错。原因：out型只出不进，在没给a赋值前不能使用
        //改为 b += b + 2;也会报错。原因：out数据在方法中必须被赋值；
    }
    public static void Main(string[] args)
    {
        C c = new C();
        int a = 1, b = 2;
        c.sum(a,b);
        Console.WriteLine("a:{0}", a);
        a = 1; b = 2;
        c.sum(ref a, b);
        Console.WriteLine("ref a:{0}", a);
        a = 1; b = 2;
        c.sum1(out a, b);
        Console.WriteLine("out a:{0}", a);
    }
}

重载方法时若两个方法的区别仅限于一个参数类型为ref 另一个方法中为out，编译器会报错
原因：参数类型区别仅限于 为 ref 与为 out 时，若重载对编译器而言两者的元数据表示完全相同。

扩展方法
扩展方法可以实现不需要修改目标类，也不需要继承目标类的情况下为其添加一个方法。
规则：

  1. 扩展类必须是静态类，扩展方法必须是静态方法；
  2. 扩展方法的第1个参数开头必须适用this关键字然后再填入扩展的目标类；
  3. 如果需要接受参数则从第2个参数开始算起，第1个参数再真正调用方法是隐藏的；
public static class ExtensionString
{
    //向 String 类扩展一个统计单词数量的方法
    public static int CountWord(this String str)
    {
        return str.Split(' ').Length;
    }
}

class MainClass
{
    public static void Main(string[] args)
    {
        Console.WriteLine("单词数量:" + "Hello World".CountWord()); //没有参数
    }
}

可空类型（Nullable）

C#单问号？与双问号？
?：单问号对于int,double,bool等无法直接赋值为null的数据类型进行null的赋值，意思是这个数据类型是NullAble类型的；

int? i = 3
等同于
Nullable<int> i = new Nullable<int>(3);

int i; //默认值为0
int? ii; //默认值为null

??双问号 可用于判断一个变量为null时返回一个指定值；

c#可空类型（Nullable）
可空类型表示其基础类型正常范围内的值，再加上一个null值，Nullable< Int32 >，读作"可空的 Int32"，可以被赋值为 -2,147,483,648 到 2,147,483,647 之间的任意值，也可以被赋值为 null 值。
类似的，Nullable< bool >变量可以被赋值为 true 或 false 或 null。
在处理数据库和其他包含可能未赋值的元素的数据类型时，将 null赋值给数值类型或布尔型的功能特别有用。例如，数据库中的布尔型字段可以存储值 true或 false，或者，该字段也可以未定义。

class NullableAtShow
{
    static void Main(string[] args)
    {
        int? num1 = null;
        int? num2 = 45;
        double? num3 = new double?();
        double? num4 = 3.1415926;

        bool? boolval = new bool?();

        Console.WriteLine("显示可空类型的值：{0}, {1}, {2}, {3}", num1, num2, num3, num4);
        Console.WriteLine("一个可空的布尔值：{0}", boolval);
        Console.ReadKey();

    }
}

//输出：
显示可空类型的值： , 45,  , 3.14157
一个可空的布尔值：

Null合并运算符（？？）
用于定义可空类型和引用类型的默认值。NULL合并运算符为类型转换定义了一个预设值，以防可空类型的值为Null。Null合并运算符把操作数类型隐式转换为另一个可空（或者不可空）的值类型的操作数的类型。
如果第一个操作数的值为 null，则运算符返回第二个操作数的值，否则返回第一个操作数的值。

double? num1 = null;
double? num2 = 3.14157;
double num3;

num3 = num1 ?? 5.34;   //num1如果为空则返回5.34
Console.WriteLine("num3的值： {0}", num3);
num3 = num2 ?? 5.34;
Console.WriteLine("num3的值： {0}", num3);
Console.ReadKey();

数组

声明数组

datatype[]  arrayname;
double[] balance;

初始化数组
数组是一个引用类型

double[] balance = new double[10];

创建并初始化一个数组

int[] marks = new int[5]{99, 98, 92, 97, 1};
//省略数组大小
int[] marks = new int{1, 2, 3, 4, 4};

通过赋值一个数组变量到另一个目标数组变量中。在这种情况下，目标和源会指向相同的内存位置

int[] marks = new int[] {99, 8, 91, 1, 3};
int[] sorces = marks;

当您创建一个数组时，C# 编译器会根据数组类型隐式初始化每个数组元素为一个默认值。例如，int 数组的所有元素都会被初始化为0。

多维数组

声明一个string变量的二维数组

string [,] names;

int三维数组

int[, , ]m;

int[,,] muarr = new int[2, 2, 3]
{
    {{1, 2, 3}, {4, 5, 6} },
    {{7, 8, 9}, {2, 3, 4} }
};

int rank = muarr.Rank;
Console.WriteLine("该多维数组的维度为：{0}", rank);

int length1 = muarr.GetLength(1);
Console.WriteLine("该多维数组的第二维有{0}个元素", length1);

Console.WriteLine("开始遍历多维数组");
Console.WriteLine("----------------------");
int wei = 1;
int index = 1;
for (int i = 0; i < muarr.GetLength(0); i++)
{
    index = 1;
    for (int j = 0; j < muarr.GetLength(1); j++)
    {
        for (int k = 0; k < muarr.GetLength(2); k++)
        {
            Console.WriteLine("第{0}行的第{1}值为{2}", wei, index, muarr[i, j, k]);
        }
        ++index;
    }
    ++wei;
}
交错数组

交错数组是数组的数组；
是一维数组；
声明一个带int交错数组

int[][] scorces;

创建上述数组

int[][] scorces = new int[5][];
for (int i = 0; i < scores.length(); i++)
{
	scores[i] = new int[4];
}

交错数组与二维数组的区别：直观理解交错数组的每一行的长度是可以不一样的。

// 声明一个交错数组 a，a 中有三个元素，分别是 a[0],a[1],a[2] 每个元素都是一个数组
int[][] a = new int[3][]; 
//以下是声明交错数组的每一个元素的，每个数组的长度可以不同
a[0] = new int[] { 1,2,3 };
a[1] = new int[] { 4,5,6,7,8 };
a[2] = new int[] { 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 };
参数数组

不能确定传给函数作为参数的个数；参数数组通常用于传递未知数量的参数给函数；
C# 提供了 params关键字，使调用数组为形参的方法时，既可以传递数组实参，也可以传递一组数组元素。

using System;

namespace ArrayApplication
{
   class ParamArray
   {
      public int AddElements(params int[] arr)
      {
         int sum = 0;
         foreach (int i in arr)
         {
            sum += i;
         }
         return sum;
      }
   }
     
   class TestClass
   {
      static void Main(string[] args)
      {
         ParamArray app = new ParamArray();
         int sum = app.AddElements(512, 720, 250, 567, 889);
         Console.WriteLine("总和是： {0}", sum);
         Console.ReadKey();
      }
   }
}
Array类

类属性

序号属性&描述
1IsFixedSize 获取一个值，该值指示数组是否带有固定大小
2IsReadOnly 获取一个值，该值指示数组是否只读
3Length 获取一个 32 位整数，该值表示所有维度的数组中的元素总数
4LongLength 获取一个 64 位整数，该值表示所有维度的数组中的元素总数
5Rank 获取数组的秩（维度）

Array类的方法

序号方法&描述
1Clear 根据元素的类型，设置数组某个范围的元素为零，为false或者null
2Copy(Array, Array, Int32) 从数组的第一个元素开始复制某个范围的元素到另一个数组的第一个元素位置。长度由一个 32 位整数指定。
3CopyTo(Array, Int32) 从当前的一维数组中复制所有的元素到一个指定的一维数组的指定索引位置。索引由一个 32 位整数指定。
4GetLength 获取一个 32 位整数，该值表示指定维度的数组中的元素总数。

其他详见文档Array类的方法

字符串

见文档字符串函数

结构体

c#中的结构体与传统c或C++中的结构不同，c#中的结构有以下特点：

  • 结构可带有方法、字段、索引、属性、运算符方法和事件。
  • 结构可定义构造函数，但不能定义析构函数。但是，您不能为结构定义无参构造函数。无参构造函数(默认)是自动定义的，且不能被改变。
  • 与类不同，结构不能继承其他的结构或类。
  • 结构不能作为其他结构或类的基础结构。
  • 结构成员不能指定为 abstract、virtual 或 protected。
  • 当您使用 New操作符创建一个结构对象时，会调用适当的构造函数来创建结构。与类不同，结构可以不使用 New 操作符即可被实例化。
  • 如果不使用 New 操作符，只有在所有的字段都被初始化之后，字段才被赋值，对象才被使用。

类VS结构体
不同点：

  • 类是引用类型，结构是值类型。
  • 结构不支持继承。
  • 结构不能声明默认的构造函数。

枚举（Enum）

enum Days {Sum, Mon, Tue, Wed, Thu, Fri, Sat};

类（class）

继承

一个对象可以用父类声明，却用子类实例化
（声明一个基类指针或引用可以动态绑定一个派生类对象）
在子类中用override重写父类中用virtual声明的虚方法时，实例化父类调用该方法，执行的是子类中重写的方法（动态绑定）；
如果子类中用new覆盖父类中用virtual声明的虚方法时，实例化父类调用该方法，执行时调用的是父类中的虚方法(静态绑定)；

using System;

namespace InheritanceApplication
{
    public class ParentClass
    {
        public virtual void ParVirMethod()
        {
            Console.WriteLine("父类的方法……");
        }
    }

    public class ChildClass1: ParentClass
    {
        public override void ParVirMethod()
        {
            Console.WriteLine("子类1的方法……");
        }
    }

    public class ChildClass2: ParentClass
    {
        public new void ParVirMethod()
        {
            Console.WriteLine("子类2的方法……");
        }

        public void Test()
        {
            Console.WriteLine("子类2的其他方法……");
        }
    }

    class Test
    {
        static void Main(string[] args)
        {
            ParentClass par = new ChildClass1();
            par.ParVirMethod();
            par = new ChildClass2();
            par.ParVirMethod();
        }
    }
}
//输出
子类1的方法……
父类的方法……

基类访问（访问隐藏的基类成员）
如果想要使派生类能够完全访问被隐藏的继承成员，可以使用基类访问表达式访问被隐藏的继承成员，基类访问表达式由base后面跟一个点和成员名称组成：

Console.WriteLine("{0}", base.Field1);

多态性

在编译时，函数和对象的连接机制称为早期绑定，也称为静态绑定；

动态多态性

使用abstract创建抽象类，用来提供接口的部分类的实现；
下面是有关抽象类的一些规则：

  • 您不能创建一个抽象类的实例。
  • 您不能在一个抽象类外部声明一个抽象方法。
  • 通过在类定义前面放置一个关键字sealed，可以将类命名成密封类。当一个类被命名为sealed时，他不能被继承，抽象类不能被命名成sealed；

静态绑定的实现技术
函数重载/运算符重载

虚方法的调用：调用时，使用子类构造的对象调用虚方法，就会调用子类的方法；使用父类构造的对象，就会调用父类的方法；（动态绑定）
隐藏方法的调用：调用上，使用子类类型的声明调用隐藏方法，就会调用子类的方法；使用父类类型的声明调用，就会调用父类的方法；

using System;
class Enemy
{
    public void Move()
    {
        Console.WriteLine("调用了enemy的move方法");
    }
    public virtual void Attack()
    {
        Console.WriteLine("enemy attac");
    }
}

class Boss: Enemy
{
    public override void Attack()
    {
        Console.WriteLine("Boss Attac");
    }

    public new void Move()
    {
        Console.WriteLine("Boss move");
    }
}
class app
{
    static void Main(string[] args)
    {
        //用什么类声明，隐藏方法就调用什么类的方法
        Boss oneEnemy = new Boss();
        oneEnemy.Move();

        Enemy twoEnemy = new Boss();
        twoEnemy.Move();

        //虚方法调用，用什么类型构造，在调用时就会使用什么类型的方法
        Enemy threeEnemy = new Enemy();
        threeEnemy.Attack();

        Enemy fourEnemy = new Boss();
        fourEnemy.Attack();

        Console.ReadKey();
    }
}

运算符重载

接口（interface）

定义接口使用interface关键字声明，接口声明默认是public；

文件的输入和输出

当打开文件进行读写时，它就变成了流；
从根本上说，流是通过通信路径传递的字节序列；

IO FileStream读写实例

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.WriteLine(F.ReadByte() + " ");
            }
            F.Close();
            Console.ReadKey();
        }
    }
}

输出：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 -1
文本文件的读写

StreamReader和StreamWriter类
抽象基类Stream

StreamReader
StreamReader 类继承自抽象基类TextReader，表示阅读器读取一系列字符；
实例：

using System;
using System.IO;

namespace FileApplication
{
    class program
    {
        static void Main(string[] args)
        {
            try
            {
            	//创建一个StreamReader的实例来读取文件
            	//using 同时也能关闭StreamReader
            	//某些类型的非托管对象有数量限制或很耗费系统资源，在代码使用完它们后，尽可能快的释放它们时非常重要的。using语句有助于简化该过程并确保这些资源被适当的处置（dispose）。
                using (StreamReader sr = new StreamReader("D:/hejie.txt"))
                {
                    string line;

                    while ((line = sr.ReadLine()) != null)
                    {
                        Console.WriteLine(line);
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("The file could not be read:");
                Console.WriteLine(e.Message);
            }
            Console.ReadKey();
        }
    }
}

异常输出：

The file could not be read:
Could not find file 'D:\heji.txt'.

StreamWriter
抽象基类TextWriter,表示编写器写入一系列字符；
常用方法

using System;
using System.IO;

namespace FileApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] names = new string[] { "hejie", "hebishuai" };
            using (StreamWriter sw = new StreamWriter("D:/hejie.txt"))
            {
                foreach (string s in names)
                {
                    sw.WriteLine(s);
                }
            }


            string line = "";

            using (StreamReader sr = new StreamReader("D:/hejie.txt"))
            {
                while ((line = sr.ReadLine()) != null)
                {
                    Console.WriteLine(line);
                }
            }
            Console.ReadKey();
        }
    }    
}
二进制文件的读写

BinaryReader 和BinaryWriter用于二进制文件的读写

BinaryReader
常用方法

using System;
using System.IO;

namespace BinaryFileApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            BinaryWriter bw;
            BinaryReader br;
            int i = 25;
            double d = 3.14159;
            bool b = true;
            string s = "I am happy";

            try
            {
                bw = new BinaryWriter(new FileStream("D:/mydata.txt", 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 file.");
            }

            bw.Close();
            try
            {
                br = new BinaryReader(new FileStream("D:/mydata.txt", 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();
        }
    }
}
Windows文件系统的操作

使用各种目录和文件相关的类来操作目录和文件，Directoryinfo和FileInfo

Directoryinfo
派生自FileSystemInfo，提供各种用于创建、移动、浏览目录和子目录的方法，该类不能被继承。
常见属性和方法

FileInfo
派生自FileSystemInfo,提供了用于创建、复制、删除、移动、打开文件的属性和方法，且有助于FileStream，该类不能被继承；

高级教程

特性（Attribute）

** 特性（Attribute）**是用于在运行时传递程序中的各个元素（比如类、方法、结构、枚举、组件等）的行为信息的声明型标签；可以通过使用特性向程序添加声明性信息。一个声明性标签是通过放置在它所应用的元素前面的方括号（[ ]）来描述的。
特性（Attribute）用于添加元数据，如编译器指令和注释、描述、方法、类等其他信息。
两种类型的特性：
预定义特性
自定义特性
规定特性（Attribute）
预定义特性（Attribute）
三种预定义特性：

  • AttributeUsage
  • Conditional
  • Obsolete
    AttributeUsage
    描述如何使用一个自定义特性类，规定了特性可应用到项目的类型
    语法：
[AttributeUsage(
   validon,  //规定特性可被放置的语言元素
   AllowMultiple=allowmultiple, //参数 allowmultiple（可选的）为该特性的 AllowMultiple 属性（property）提供一个布尔值
   Inherited=inherited   //参数 inherited（可选的）为该特性的 Inherited 属性（property）提供一个布尔值。如果为 true，则该特性可被派生类继承。默认值是 false（不被继承）。
)]

Conditional
标记了一个条件方法，其执行依赖于指定的预处理标识符

Conditional("DEBUG")

Obsolete
标记了不应被使用的程序实体。可以通知编译器丢弃某个特定的目标元素；
当一个新方法被用在一个类中，但是您仍然想要保持类中的旧方法，您可以通过显示一个应该使用新方法，而不是旧方法的消息，来把它标记为 obsolete（过时的）。
语法

[Obsolete(
   message   // 是一个字符串，描述项目为什么过时以及该替代使用什么
)]
[Obsolete(
   message,
   iserror   // 是一个布尔值。如果该值为 true，编译器应把该项目的使用当作一个错误。默认值是 false（编译器生成一个警告）。
)]

属性（Property）

属性（Property）是类（class）、结构（structure）和接口（interface）的命名（named）成员。类或结构中的成员变量或方法称为 域（Field）。属性（Property）是域（Field）的扩展，且可使用相同的语法来访问。使用访问器（accessors）让私有域的值可被读写或操作。
属性（Property）不会确定存储位置。它们具有可读写或计算它们值得访问器（accessors）；
名为 Student 的类，带有 age、name 和 code 的私有域。我们不能在类的范围以外直接访问这些域，但是我们可以拥有访问这些私有域的属性。

访问器（Accessors）
属性的访问器（accessor）包含有助于获取（读取或计算）或设置（写入）属性的可执行语句。访问器（accessor）声明可包含一个 get 访问器、一个 set 访问器，或者同时包含二者。

委托（Delegate）

委托类似c++中的指针，委托（Delegate）是存有对某个方法的引用的一种引用类型变量。
委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自**System.Delegate **类。

using System;
delegate int NumberChanger(int n);
//委托声明，决定了可由该委托引用的方法，可被用于引用任意一个带有单一int参数的方法，并返回一个int类型的变量；
namespace DelegateApp
{
    class TestDelegate
    {
        static int num = 10;
        public static int AddNum(int p)
        {
            num += p;
            return num;
        }
        public static int MulNum(int p)
        {
            num *= p;
            return num;
        }
        public static int getNum()
        {
            return num;
        }

        static void Main(string[] args)
        {
            NumberChanger nc1 = new NumberChanger(AddNum);
            NumberChanger nc2 = new NumberChanger(MulNum);

            nc1(25);
            Console.WriteLine($"Value of Num:{getNum()}");
            nc2(5);
            Console.WriteLine($"Value of Num:{getNum()}");
            Console.ReadKey();
        }
    }
}

重载参数及返回值相同的函数调用；

委托的多播（Multicasting of a Delegate）
创建一个委托被调用时要调用的方法的调用列表，被称为委托的多播，也称为组播；
委托对象可使用 “+” 运算符进行合并。一个合并委托调用它所合并的两个委托。只有相同类型的委托可被合并。"-" 运算符可用于从合并的委托中移除组件委托。

using System;

delegate int NumberChanger(int n);
namespace DelegateAppl
{
   class TestDelegate
   {
      static int num = 10;
      public static int AddNum(int p)
      {
         num += p;
         return num;
      }

      public static int MultNum(int q)
      {
         num *= q;
         return num;
      }
      public static int getNum()
      {
         return num;
      }

      static void Main(string[] args)
      {
         // 创建委托实例
         NumberChanger nc;
         NumberChanger nc1 = new NumberChanger(AddNum);
         NumberChanger nc2 = new NumberChanger(MultNum);
         nc = nc1;
         nc += nc2;
         // 调用多播
         nc(5);
         Console.WriteLine("Value of Num: {0}", getNum());
         Console.ReadKey();
      }
   }
}

委托（Delegate）的用途
委托 printString 可用于引用带有一个字符串作为输入的方法，并不返回任何东西。

事件（Event）

事件（Event） 基本上说是一个用户操作，如按键、点击、鼠标移动等等，或者是一些提示信息，如系统生成的通知。应用程序需要在事件发生时响应事件。例如，中断。
使用事件机制实现进程间的通信；

通过事件使用委托
事件在类中声明且生成，且通过使用同一个类或其他类中的委托与事件处理程序关联。包含事件的类用于发布事件。这被称为 发布器（publisher） 类。
接受该事件的类称为订阅器（subscriber）。事件使用 **发布-订阅（publisher-subscriber）**模型。
**发布器（publisher） **是一个包含事件和委托定义的对象。事件和委托之间的联系也定义在这个对象中。发布器（publisher）类的对象调用这个事件，并通知其他的对象。
订阅器（subscriber） 是一个接受事件并提供事件处理程序的对象。在发布器（publisher）类中的委托调用订阅器（subscriber）类中的方法（事件处理程序）。
声明事件（Event）
首先必须声明该事件的委托类型

public delegate void BoilerLogHandler(string status);

然后，声明事件本身，使用event关键字

//基于上面的委托定义事件
public event BoilerLogHandler BoilerEventLog;

集合（Collection）

集合类是专门用来数据存储和检索的类；
位于命名空间System.Collection命名空间的类

动态数组（ArrayList）

属性和方法

泛型（Generic）

允许延迟编写类或方法中的编程元素的数据类型的规范，直到实际在程序中使用它的时候。

泛型委托
delegate T NumberChanger<T> (T n);

匿名方法（Anonymous methods）

一种传递代码块作为委托参数的技术。
匿名方法没有名称只有主体的方法，不需要指定返回类型，是从方法主体的return语句推断的。
编写匿名方法的语法

delegate void NumberChanger(int n);
……
NumberChanger nc = delegate(int x);
{
	Console.WriteLine($"Anonymous Method:{x}");   //匿名方法主体
};

委托可以通过匿名方法调用，也可以通过命名方法调用，即，通过向委托对象传递方法参数；

nc(10);

不安全代码

当一个代码块使用unsafe修饰符标记时，c#允许再函数中使用指针变量。不安全代码或非托管代码是指使用指针变量的代码块；

多线程

c#中System.Threading.Thread类用作线程的工作，允许创建并访问多线程应用的单个线程。使用Thread类的CurrentThread访问线程；

hejiegoubao
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#学习笔记
05-04
C#学习笔记C#学习笔记C#学习笔记C#学习笔记C#学习笔记C#学习笔记C#学习笔记C#学习笔记
变量
weixin_45058941的博客
10-15 226
C# 变量 一个变量只不过是一个供程序操作的存储区的名字。在 C# 中，每个变量都有一个特定的类型，类型决定了变量的内存大小和布局。范围内的值可以存储在内存中，可以对变量进行一系列操作。 我们已经讨论了各种数据类型。C# 中提供的基本的值类型大致可以分为以下几类： 整数类型 sbyte、byte、short、ushort、int、uint、long、ulong 和 char 浮点型 float ...
C#学习（第三篇）
生产队的刘同学
08-09 384
在上篇文章中我们学习了C#基本语法、C#关键字以及C#数据类型，这次我将带着大家学习C#变量、C#数据类型转换以及C#运算符。
C#知识点二
weixin_49982989的博客
05-07 82
C#中的变量初始化 ·变量通过在等号后跟一个常量表达式进行初始化（赋值）； 初始化的一般形式为：variable_name = value; .0333如：<data_type> <variable_name> = value; ·实例： C#中的Lvalues和Rvalues ·C#中的两种表达式： 1、lvalue：表达式可以出现在赋值语句的左边或右边 2、rvalue：表达式可以出现在赋值语句的右边，不能出现在赋值语句的左边 ·变量是 lvalue 的，所以可以出现在赋值语句的
V3/A8错误提示Value cannot be null Parameter name:key
01-15 2132
升级到9.4后做其它收入单，选择收入项目名称时，错误提示: “Value cannot be null Parameter name:key” 通过新建一个空白账套对比发现: 在数据库表Ac_Items发现nTypeId和nParId两个字段内有一两条记录值为空， 值为空的这两条记录错位到TypeId和ParId两个字段 然后把错位的两条记录字段值更正到正确字段，问题解决 ...
理解lvalue和rvalue
rogerhe的专栏
05-11 7313
分析了lvalue和rvalue的特征，深度理解他们的使用限制。
Learning hard C# 学习笔记
04-01
Learning hard C# PDF版+源码，想了解的朋友可以看看电子版的再考入手，我看过后觉得很不错就买了书，很适合初学者。
c#学习笔记
01-27
这是我在学习c#课程过程中自己积累的一点心得，都是关于unity3d中c#的学习笔记，比较入门的那种，很适合小白使用。
LearningHard C#学习笔记
03-04
LearningHard C#学习笔记，学习C#的经典入门教材。 非常适合初学者，希望大家一起努力。
ASP.NET Core解决Value cannot be null. (Parameter ‘configure‘)错误
CoffeMilk的博客
10-03 1万+
一、问题描述 运行配置了权限内容的ASP.NET Core3.1 WebApi项目提示错误信息：Value cannot be null. (Parameter 'configure') 二、问题分析 根据错误信息提示，我们可以知道当前错误时由于'configure'参数的值为空引起的，又由于我们配置了权限内容，且我们的项目是.NET Core3.1项目，所以我们需要检查我们使用的权限包是否为.NET Core3.1的权限包。 三、解决办法 检查项目中权限用到的的nuget包【Mi...
C 中的左值（Lvalues）和右值（Rvalues）
weixin_30814329的博客
04-19 469
C 中的左值（Lvalues）和右值（Rvalues） C 中有两种类型的表达式： 左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。 右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。 变量是左值...
Value cannot be null. Parameter name: con
热门推荐
木槿昔年
06-28 2万+
使用OracleSugar 进行查询的时候，出现了这个问题：Value cannot be null. Parameter name: con这个是个很傻的操作导致的，具体如下： db.SqlQuery&lt;Task&gt;(sql2, new { UserID = userid }).ToList();就是这个引起的，这个model写错了就会导致这样的异常。。。。...
Lvalues and Rvalues in C#
独来独往天马行空
12-18 695
There are two kinds of expressions in C#: lvalue: An expression that is an lvalue may appear as either the left-hand or right-hand side of an assignment. rvalue: An expression that is an rvalu
理解lvalues和rvalues在c/c++
AAAtang
02-23 263
在看 Eli Bendersky的文章的时候，记录一下。 引言 左值和右值在编程中不是常遇见，但出现时候，不能很快理解，所以这次做一个总结。 int foo() {return 2; } int main() { foo()=2; return 0; } gcc编译这段代码 cpp error: lvalue required as left operand of assignment f...
Lvalues & Rvalues——理解左值与右值
lmjq的专栏
02-08 2984
Lvalues and RvaluesC and C++ enforce subtle differences on the expressions to the left and right of the assignment operator  If youve been programming in either
Lvalues and Rvalues(转载)
SeeSeaBee的专栏
09-08 1485
 C and C++ enforce subtle differences on the expressions to the left and right of the assignment operator  If youve been programming in either C or C++ for a while, its likely that youve heard
C#数组求和，求最大数，最小数，平均值
chinaherolts2008的博客
02-14 5607
以上是c#教程代码 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApplication3 { class Program { static void Main(string[] args) { int[] arr =
lvalues and rvalues
JhonsonLai's Blog
08-02 273
参考链接：https://msdn.microsoft.com/en-us/library/f90831hc.aspx C++的任何表达式都是lvalue或者rvalue。lvalue指的是 在表达式之外依然一致的object，可以认为拥有名字的object都是lvalue，所以所有的变量都是lvalue。rvalue指的是 临时的值，在表达式之外使用就无法保证一致。// lvalues_and_r
learning hard c#学习笔记 pdf
最新发布
11-14
学习对于个人的成长和发展非常重要。努力学习可以让我们获取更多的知识和技能，提高我们的竞争力。学习也可以让我们更加深入地了解世界，拓宽我们的视野。学习需要付出很大的努力和时间，但是这些努力都是值得的。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值