C#学习笔记

最新推荐文章于 2023-06-20 14:56:45 发布

GameNose

最新推荐文章于 2023-06-20 14:56:45 发布

阅读量168

点赞数

分类专栏： C#

本文链接：https://blog.csdn.net/hitliuchao/article/details/108555074

版权

C# 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

区块引用

数据类型

分为：值类型；引用类型；指针类型；
计算类型或变量的尺寸用**sizeof（）**方法;

    using System;
    namespace DataTypeApplication
    {
        class Program
        {
            static void Main(string[] args)
            {
                Console.WriteLine("Size of int:{0}", sizeof(int))

    Console.ReadLine();
}
        }
    }

Consloe.ReadLine()

Console.Read()、Console.ReadLine() 相同点： 1.两者都是用于输入的函数。不同点： 1. Read只能读取一个字符，ReadLine可以读取一个字符串如 Read读取A和AASDGU的返回值都是一样的都为A的ASCII值，对于后续的ASDGU不理会。而ReadLine则为A和AASDGU原样输出。 2.Read输出的结果为字符串的ASCII码值，而ReadLine输出字符串。 3. Read只接受任意键盘输入,ReadLine接受回车。 Read键盘任意键往下执行，ReadLine 接受回车往下执行。Console.readKey(): 在键盘敲击任意键后退出。一般在Console.Write()或Console,WriteLine()后加入这个函数，使窗口停留直至输入任意键关闭窗口。

占位符


        static void Main(string[] args)
        {
            Console.WriteLine("占位符{0}",sizeof(int));
           
        }
    }
}

值类型

引用类型：

引用类型包含对变量的引用；其指的是一个内存位置，使用多个变量时，引用的类型可以指向一个内存位置，如果内存位置数据是由一个变量改变的，其他变量会反应其变化。

1对象类型：

当一个值类型转换为对象类型称为装箱；对象类型转为值类型拆箱；
object obj;
obj = 100; // 这是装箱

2动态类型(dynamic)

dynamic 变量名字 = value；
```
### 3字符串类型
字符串的值分配：

String str =“11111”
@“111111”

加@（逐字字符串）将转义字符（\）当普通字符：


## 类型转换
1,隐式类型转换： 是安全方式， 不会导致数据丢失，**从小的整数类型转换为大的整数类型，从派生类转换为基类。**
2，显式类型转换：即强制类型转换，强制转换运算符；

````c#
using System;
namespace _9._11
{
    class Zhuanhuan
    {
        static void Main(string[] args)
        {
            double d =5673.74;
            int i;
            //强制转换
            i = (int)d;
            Console.WriteLine(i);
            Console.ReadKey();
        }
    }
}

类型转换方法：

1ToBoolean
如果可能的话，把类型转换为布尔型。2ToByte
把类型转换为字节类型。3ToChar
如果可能的话，把类型转换为单个 Unicode 字符类型。4ToDateTime
把类型（整数或字符串类型）转换为日期-时间结构。5ToDecimal
把浮点型或整数类型转换为十进制类型。6ToDouble
把类型转换为双精度浮点型。7ToInt16
把类型转换为 16 位整数类型。8ToInt32
把类型转换为 32 位整数类型。9ToInt64
把类型转换为 64 位整数类型。10ToSbyte
把类型转换为有符号字节类型。11ToSingle
把类型转换为小浮点数类型。12ToString
把类型转换为字符串类型。13ToType
把类型转换为指定类型。14ToUInt16
把类型转换为 16 位无符号整数类型。15ToUInt32
把类型转换为 32 位无符号整数类型。16ToUInt64
把类型转换为 64 位无符号整数类型。

int 的说明

Int16 意思是16位整数(16bit integer)，相当于short 占2个字节 -32768 ~ 32767Int32 意思是32位整数(32bit integer), 相当于 int 占4个字节 -2147483648 ~ 2147483647Int64 意思是64位整数(64bit interger), 相当于 long long 占8个字节 -9223372036854775808 ~ 9223372036854775807Byte 相当于byte(unsigned char) 0 ~ 255WORD 等于 unsigned short 0 ~ 65535

        Console.WriteLine(d.ToString()); 
        Console.ReadKey();

（d.Tostring())

输入：Consloe.ReadLine()

int保存输入：int num= Convert.ToInt32(Console.ReadLine());

常量

字符常量：

一个字符常量可以是一个普通字符（例如 ‘x’）、一个转义序列（例如 ‘\t’）或者一个通用字符（例如 ‘\u02C0’）。

转义符

\
’ ’

\a Alert 或 bell
\b 退格键

\t是换行；\n是空格
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ulj37gcV-1599915945399)(en-resource://database/638:1)]

定义常量

常量是使用 const 关键字来定义的。定义一个常量的语法如下：
**const 类型常量名 = value；

const <data_type> <constant_name> = value;

判断语句：

exp1 ? exp2 : exp3;

? 表达式的值是由 Exp1 决定的。如果 Exp1 为真，则计算 Exp2 的值，如果 Exp1 为假，则计算 Exp3 的值

char grade = ‘B’; char 只能用单引号

switch

C# 中 switch 语句的语法：switch(expression){
case constant-expression  :
   statement(s);
   break; 
case constant-expression  :
   statement(s);
   break; 

/* 您可以有任意数量的 case 语句 */
default : /* 可选的 */
   statement(s);
   break; 
   }

循环

1.while

while(condition)
{
statement();
}

2.for 和 foreach

for（ int a=10; a<100 ; a=a+1)

无限循环： for（；；）

foreach循环数组里所有的数：

using System;
namespace Program{
class Program{
static void Main(string[] args)
{
int[] arry = new int[]{1,2,3};
foreach (int ys in arry)
{
System.Console.WriteLine(ys);
}
}
}
}

先执行再判断的 do while

do{
statement(s);

}while( condition );

c#封装

封装定义为把一个或多个项目封闭在一个物理的或者逻辑的包中，封装是为了防止对实现细节的访问

c#支持的访问修饰符：

public：所有对象都可以访问；
private：对象本身在对象内部可以访问；
在上面的实例中，成员变量 length 和 width 被声明为 private，所以它们不能被函数 Main() 访问。成员函数 AcceptDetails() 和 Display() 可以访问这些变量。由于成员函数 AcceptDetails() 和 Display() 被声明为 public，所以它们可以被 Main() 使用 Rectangle 类的实例 r 访问。
protected：只有该类对象及其子类对象可以访问
internal(内部)：Internal 访问说明符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。换句话说，带有 internal 访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类或方法访问。；
protected internal：访问限于当前程序集或派生自包含类的类型。

C#方法：

1.访问修饰符 2.返回类型 3.方法名（4.参数)
{
}

public int function (int x，int y){
}


//2在不同的类中对公有方法进行调用：
// using System;
// class Program{
//     public int Max (int num1, int num2)
//     {
//         int result;
//          return num1 > num2 ? result = num1 : result = num2 ;  
//     }
//     static void Main(string[] args)
//     {
//         int a = Convert.ToInt32(Console.ReadLine());
//         int b = 300;
//         int ret;
//         Program n = new Program();
//         ret = n.Max(a,b);
//         System.Console.WriteLine("a是"+a+"最大是"+ret);
        
//     }
// }
// class Test{
//     static void Main(string[] args)
//     {
//               int a = Convert.ToInt32(Console.ReadLine());
//         int b = 400;
//         int ret;
//         Program n = new Program();
//         ret = n.Max(a,b); //调用
//         System.Console.WriteLine("a是"+a+"最大是"+ret);
          
//     }
// }
// 3.//自我调用 即递归方法调用：
// using System;
// namespace Digui{
//     class Digui //递归
//     {
//         public int factorial (int num)
//         {
//             int result;
//             if (num == 1)
//             {
//                 return 1;
//             }
//             else
//             {
//                return result = num*factorial(num-1);
                
//             }
            
//         }
//         static void Main(string[] args)
//         {
//             Digui sum = new Digui(); //这里 new 要小写
//             System.Console.WriteLine("输入");
//             int a = sum.factorial(Convert.ToInt16(Console.ReadLine()));
            
//             System.Console.WriteLine(a);
//         }
//     }
// }
// using System;
// namespace CalculatorApplication
// {
//     class NumberManipulator
//     {
//         public int factorial(int num)
//         {
//             /* 局部变量定义 */
//             int result;
//             if (num == 1)
//             {
//                 return 1;
//             }
//             else
//             {
//                 result = factorial(num - 1) * num;
//                 return result;
//             }
//         }
   
//         static void Main(string[] args)
//         {
//             NumberManipulator n = new NumberManipulator();
//             //调用 factorial 方法
//             Console.WriteLine("6 的阶乘是： {0}", n.factorial(6));
//             Console.WriteLine("7 的阶乘是： {0}", n.factorial(7));
//             Console.WriteLine("8 的阶乘是： {0}", n.factorial(8));
//             Console.ReadLine();
//         }
//     }
// }

（重点）参数传递

1.按值传递参数（普通传参法）
实际参数的值会复制给形参，实参和形参使用的是两个不同内存中的值。所以，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全

2.按引用传递参数

引用参数是一个对变量的内存位置的引用。当按引用传递参数时，与值参数不同的是，它不会为这些参数创建一个新的存储位置。引用参数表示与提供给方法的实际参数具有相同的内存位置。
与按值传参数不同。

**用法：**在形参的数据类型前加 ref 调用时候也加 ref。

ref型参数该种类型的参数传递变量地址给方法（引用传递），传递前变量必须初始化。
该类型与out型的区别在与：
1）.ref 型传递变量前，变量必须初始化，否则编译器会报错, 而 out 型则不需要初始化
2）.ref 型传递变量，数值可以传入方法中，而 out 型无法将数据传入方法中。换而言之，ref 型有进有出，out 型只出不进。out 型参数与 ref 型类似，仅用于传回结果。
注意：1). out型数据在方法中必须要赋值，否则编译器会报错。
eg:如下图若将代码中的sum1方法的方法体改为 a+=b; 则编译器会报错。原因：out 型只出不进，在没给 a 赋值前是不能使用的改为 b+=b+2; 编译器也会报错。

原因：out 型数据在方法中必须要赋值。
2). 重载方法时若两个方法的区别仅限于一个参数类型为ref 另一个方法中为out，编译器会报错eg：若将下面的代码中将方法名 vsum1 改为 sum（或者将方法名 sum 改为 sum1），编译器会报错。

c#的可空类型（nullable）

C＃单问号？与双问号??

int ? i =3

?单问号用于对 int。。。等无法直接赋值为null的数据类型进行null 的赋值即让其为 Nullable 数据类型。

例如，Nullable< Int32 >，读作"可空的 Int32"，可以被赋值为 -2,147,483,648 到 2,147,483,647 之间的任意值，也可以被赋值为 null 值。类似的，Nullable< bool > 变量可以被赋值为 true 或 false 或 null。

在处理数据库和其他包含可能未赋值的元素的数据类型时会用到 null 可空类型；

< data_type> ? <variable_name> = null;

    int? num1 = null ;//输出 num1 为 空
    int ？ num2 = new int?() //为空

Null合并运算符（？？）

null合并定义运算符用于定义可空类型和引用类型的默认值， null合并运算为类型转换定义了一个预设值，防止可空类型的值为null ，

Null 合并运算符把操作数类型隐式转换为另一个可空（或不可空）的值类型的操作数的类型。
如果第一个操作数的值为 null，则运算符返回第二个操作数的值，否则返回第一个操作数的值


using System;
namespace Test
{
    class Test8
    {
        static void Main(string[] args)
        {
            double ? num1 = null;
            double ? num2 = 3.11;
            double   num3;
            num3 = num1 ?? 222; // 如果num1 是空 返回 222
            System.Console.WriteLine("num3"+num3);
            num3 = num2 ?? 888 ;
            System.Console.WriteLine("num3转换的是num2"+num3);
        }
    }
}

数组：

1.声明： int[大小] 数组名；声明数组不会在内存中初始化数组

2.初始化数组实例化： 数组是一个引用类型；
int[] 数组实例化名 = new 数组名[维度]

3.赋值 arrayName[0 ]=100

您可以在声明数组的同时给数组赋值
double[ ] balance = { 2340.0, 4523.69, 3421.0};c花括号

创建并初始化：
int[] name = new int[] {1111,1,112}

在上述情况下，你也可以省略数组的大小，比如：int [] marks = new int[] { 99, 98, 92, 97, 95};

您也可以赋值一个数组变量到另一个目标数组变量中。在这种情况下，目标和源会指向相同的内存位置：
int [] marks = new int[] { 99, 98, 92, 97, 95};int[] score = marks;

字符串：

C# string.Format格式化日期

DateTime dt = new DateTime(2017,4,1,13,16,32,108);
string.Format("{0:y yy yyy yyyy}",dt); //17 17 2017 2017
string.Format("{0:M MM MMM MMMM}", dt);//4  04 四月 四月
string.Format("{0:d dd ddd dddd}", dt);//1  01 周六 星期六
string.Format("{0:t tt}", dt);//下 下午
string.Format("{0:H HH}", dt);//13 13
string.Format("{0:h hh}", dt);//1  01
string.Format("{0:m mm}", dt);//16 16
string.Format("{0:s ss}", dt);//32 32
string.Format("{0:F FF FFF FFFF FFFFF FFFFFF FFFFFFF}", dt);//1 1  108 108  108   108    108
string.Format("{0:f ff fff ffff fffff ffffff fffffff}", dt);//1 10 108 1080 10800 108000 1080000
string.Format("{0:z zz zzz}", dt);//+8 +08 +08:00

string.Format("{0:yyyy/MM/dd HH:mm:ss.fff}",dt);　　//2017/04/01 13:16:32.108
string.Format("{0:yyyy/MM/dd dddd}", dt);　　　　　　//2017/04/01 星期六
string.Format("{0:yyyy/MM/dd dddd tt hh:mm}", dt); //2017/04/01 星期六 下午 01:16
string.Format("{0:yyyyMMdd}", dt);　　　　　　　　　//20170401
string.Format("{0:yyyy-MM-dd HH:mm:ss.fff}", dt);　//2017-04-01 13:16:32.108
除去string.Format()可以对日期进行格式化之外，*.ToString()也可以实现相同的效果：

DateTime dt = new DateTime(2017,4,1,13,16,32,108);
dt.ToString("y yy yyy yyyy");//17 17 2017 2017
dt.ToString("M MM MMM MMMM");//4  04 四月 四月
dt.ToString("d dd ddd dddd");//1  01 周六 星期六
dt.ToString("t tt");//下 下午
dt.ToString("H HH");//13 13
dt.ToString("h hh");//1  01
dt.ToString("m mm");//16 16
dt.ToString("s ss");//32 32
dt.ToString("F FF FFF FFFF FFFFF FFFFFF FFFFFFF");//1 1  108 108  108   108    108
dt.ToString("f ff fff ffff fffff ffffff fffffff");//1 10 108 1080 10800 108000 1080000
dt.ToString("z zz zzz");//+8 +08 +08:00

dt.ToString("yyyy/MM/dd HH:mm:ss.fff");　//2017/04/01 13:16:32.108
dt.ToString("yyyy/MM/dd dddd");　　　　　　//2017/04/01 星期六
dt.ToString("yyyy/MM/dd dddd tt hh:mm"); //2017/04/01 星期六 下午 01:16
dt.ToString("yyyyMMdd");　　　　　　　　　//20170401
dt.ToString("yyyy-MM-dd HH:mm:ss.fff");　//2017-04-01 13:16:32.108

c#结构体：

struct关键字创建结构体：

title
Auther
Subject
Book ID


//##12 结构体
using System;
namespace  Test
{
    struct Books
    {
        public string title;
        public string author;
        public string subject;
        public int book_id;
    }

    class BookClass{
        public string name;
    }

    public class testStructure
    {
        public static void Main(string[] args)
        {
            Books book1; //声明 book1 类型为books
            Books book2; 
            //属性添加
        book1.title = "1";
        book2.author= "dwwd";
        book1.book_id=2;
        System.Console.WriteLine(book1.title);


        //class

        BookClass book3 = new BookClass();
       
        System.Console.WriteLine(book3.name = "类的");

        }
    }
}

c#结构的特点：

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

类和结构有以下几个基本的不同点：

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

枚举（Enum）：

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

c#的枚举是值类型；

GameNose

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C#学习笔记

文章目录数据类型Consloe.ReadLine()占位符值类型引用类型：1对象类型：2动态类型(dynamic)类型转换方法：int 的说明int保存输入：int num= Convert.ToInt32(Console.ReadLine());常量字符常量：转义符定义常量判断语句：char grade = 'B'; char 只能用单引号switch循环1.while2.for 和 foreach先执行再判断的 do whilec#封装C#方法：（重点）参数传
复制链接

扫一扫