C# 从入门到入土（自学笔记）--Day1

using System;  //相当于Java里的import导包

namespace TestCollection  //命名空间
{
    class Program   //类
    {
        static void Main(string[] args)  //main方法
        {
            Console.WriteLine("Hello World!"); //语句
        }
    }
}

//结果："Hello World!"  //这是注释


//随便创建一个person类
class Person{     //类
  public string name;  //属性
  public int age;
}

public ActionResult Error(){   //方法
  //方法体
  Console.WriteLine("error"); //语句
}

按F5启动调试，基本上本地都要用Debug模式运（我才不会承认我连这个都不会）。Debug | MSDN

常用的快捷键：

（写的不详细，因为其他没用过，这个文章写的详细，记录一下：VS快捷键大全）

Ctrl+Shift+N: 新建项目
 
Ctrl+Shift+O: 打开项目

Ctrl+Shift+S: 全部保存 

Ctrl+Shift+A: 新建项

Shift+Alt+C: 新建类

Ctrl+F: 查找

Ctrl+E,D（ctrl+k,d）：格式化全部代码

Ctrl+Alt+L：打开Solution Explorer

调试快捷键：

F5: 启动调试（或者在debug过程中跳过后面的断点直接运行）

Ctrl+F5: 开始执行(不调试)

Shift+F5: 停止调试

Ctrl+Shift+F5: 重启调试

F9: 启用/关闭断点

Ctrl+F9: 停止断点

Ctrl+Shift+F9: 删除全部断点

F10: 逐过程 

Ctrl+F10: 运行到光标处 

F11: 逐语句

F12：点击方法名，可跳转它的定义。

C#关键字（C#关键字 | MSDN）：

常用保留关键字：
abstract
public
private
protected
return
switch
if
else
case
for
foreach
do
while
in
break
continue
try
catch
true
false
byte
float
long
int
string
char
short
void
using
interface
enum
new
namespace
out
ref
null
params

上下文关键字：
add
from
into
join
let
select
set
get
dynamic

C#数据类型：

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

值类型：

值类型变量可以直接分配给一个值，sizeof()方法可以查看存储尺寸。

类型名(关键字)	中文意思	程序中的描述与用途	值的规定范围	默认值
bool	布尔	布尔值	True 或 False	False
byte	字节	8 位无符号整数	0 到 255	0
char	字符	16 位 Unicode 字符，如：一个英文字母	U +0000 到 U +ffff	'\0'
decimal	十进位的;小数的	128 位精确的十进制值，28-29 有效位数	(-7.9 x 1028 到 7.9 x 1028) / 100 到 28	0.0M
double	两倍的;加倍的;	64 位双精度浮点型，如：1.3D	(+/-)5.0 x 10-324 到 (+/-)1.7 x 10308	0.0D
float	浮动;小数在C#中需要用浮点型表示	32 位单精度浮点型，如：1.3F	-3.4 x 1038 到 + 3.4 x 1038	0.0F
int	不含分数或小数的数(integer的缩写)	32 位有符号整数类型	-2,147,483,648 到 2,147,483,647	0
long	(长度或距离)长的	64 位有符号整数类型	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807	0L

引用类型：

直接指向内存地址。内置的引用类型有：object、dynamic 和 string。

声明引用类型：

内置引用类型：

object对象：所有数据类型的终极基类。当一个值类型转换为对象类型时，则被称为装箱；另一方面，当一个对象类型转换为值类型时，则被称为拆箱。

Tips：要在运行时成功取消装箱值类型，被取消装箱的项必须是对一个对象的引用，该对象是先前通过装箱该值类型的实例创建的。尝试取消装箱 null 会导致 NullReferenceException。尝试取消装箱对不兼容值类型的引用会导致 InvalidCastException。

int i = 123;      // a value type
object o = i;     // 装箱
int j = (int)o;   // 拆箱

dynamic动态：存储任何类型的值在动态数据类型变量中。对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的。

string字符串：引号和 @引号

string str = "test";  //记得初始化,暂时没有值可以写，只双引号也可以
string str2 = @"test";
Console.WriteLine(str2);

指针类型：

指针类型变量存储另一种类型的内存地址

char* cptr;
int* iptr;

C#类型转换：

隐式类型转换：这些转换是 C# 默认的以安全方式进行的转换, 不会导致数据丢失。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
显式类型转换：显式类型转换，即强制类型转换。显式转换需要强制转换运算符，而且强制转换会造成数据丢失。大转小。

案例：

double d = 5673.74;
int i;

i = (int)d;  //强转
Console.WriteLine(i);

内置转换方法：随便找个Convert()方法F12一下就能看到全部内置转换方法了。或者输入convert后直接一个“.”，VS会自动生成好多方法的。


    // 概要:
    //     Converts a base data type to another base data type.
    
public static class Convert
    {

        // 概要:
        //     Converts the value of the specified 32-bit signed integer to its equivalent 
        //     string representation.
        //
        // パラメーター(参数):
        //   value:
        //     The 32-bit signed integer to convert.
        //
        // 戻り値(返回值):
        //     The string representation of value.

public static string ToString(int value);

     }

案例：

//转换为字符串类型
int m = 75;
float f = 53.005f;
double n = 2345.7654;
bool b = true;
Console.WriteLine(b.ToString());
Console.WriteLine(n.ToString()); 
Console.WriteLine(f.ToString());
Console.WriteLine(m.ToString());
Console.ReadKey();

C#变量：

类型	举例
整数类型	sbyte、byte、short、ushort、int、uint、long、ulong 和 char
浮点型	float 和 double
十进制类型	decimal
布尔类型	true 或 false 值，指定的值
空类型	可为空值的数据类型

<data_type> <variable_name> = value;

string str;  //定义
int i = 75;  //变量初始化

两种表达式：

lvalue：可以出现在赋值语句的左边或右边。rvalue：可以出现在赋值语句的右边，不能出现在赋值语句的左边。

控制台：

//常用方法：
public static class Console
    {
public static void WriteLine();   //输出
public static ConsoleKeyInfo ReadKey();
public static void Clear();
public static string ReadLine();  //输入
    }


//调用方法：
Console.WriteLine()

案例：

//接收来自用户的输入，并把它存储到num变量中
int num;
num = Convert.ToInt32(Console.ReadLine());

C#命名规范：

Pascal 命名法是指每个单词的首字母大写；Camel 命名法是指第一个单词小写，从第二个单词开始每个单词的首字母大写。
变量的命名规则遵循 Camel 命名法，并尽量使用能描述变量作用的英文单词。例如存放学生姓名的变量可以定义成 name 或者 studentName 等。另外，变量名字也不建议过长，最好是 1 个单词，最多不超过 3 个单词。

C#常量：

定义常量:
const <data_type> <constant_name> = value;

//案例：
using System;

public class ConstTest
{
    class SampleClass
    {
        public int x;     //定义变量
        public int y;
        public const int c1 = 5;  //定义常量
        public const int c2 = c1 + 5;

        public SampleClass(int p1, int p2)  //方法
        {
            x = p1;
            y = p2;
        }
    }

    static void Main()
    {
        SampleClass mC = new SampleClass(11, 22);  //创建对象
        Console.WriteLine("x = {0}, y = {1}", mC.x, mC.y);  //调用方法
        Console.WriteLine("c1 = {0}, c2 = {1}",
                          SampleClass.c1, SampleClass.c2);
    }
}
//x = 11, y = 22
//c1 = 5, c2 = 10



整数常量:
85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* int */
30u        /* 无符号 int */
30l        /* long */
30ul       /* 无符号 long */

浮点常量:
3.14159       /* 合法 */
314159E-5L    /* 合法 */
510E          /* 非法：不完全指数 */
210f          /* 非法：没有小数或指数 */
.e55          /* 非法：缺少整数或小数 */

字符常量:
class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello\tWorld\n\n");
            Console.ReadLine();
        }
    }
//Hello   World


字符串常量:
string a = "hello, world";                // hello, world
string b = @"hello, world";               // hello, world

整数常量：整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，没有前缀则表示十进制。整数常量也可以有后缀，可以是 U 和 L 的组合，其中，U 和 L 分别表示 unsigned 和 long。后缀可以是大写或者小写，多个后缀以任意顺序进行组合（但是不可以重复后缀）。

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

字符常量：一个普通字符（例如 'x'）、一个转义序列（例如 '\t'）或者一个通用字符（例如 '\u02C0'）。

转义序列（不全）	含义
\\	\ 字符
\'	' 字符
\"	" 字符
\?	? 字符
\b	退格键（Backspace）
\f	换页符（Form feed）
\n	换行符（Newline）
\r	回车
\t	水平制表符 tab

字符串常量：括在双引号 "" 里，或者是括在 @"" 里。普通字符、转义序列和通用字符

C#运算符：

算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
其他运算符

算术运算符：

int a = 21;
int b = 20;
int c1,c2,c3,c4,c5,c6,c7,c8,c9;

c1 = a + b;
c2 = a - b;
c3 = a * b;
c4 = a / b;
c5 = a % b;
c6 = ++a;   //先赋值再运算
c7 = a++;   //先运算再赋值
c8 = b--;
c9 = --b;
Console.WriteLine("c的值是 {0},{1},{2}，{3}，{4}，{5}，{6}，{7}，{8}", c1, c2, c3, c4, c5, c6, c7, c8, c9);
//c的值是 41,1,420，1，1，22，22，20，18

关系运算符：

//返回bool类型
==  !=  <  >  <=  >==

逻辑运算符：

//返回bool类型
&& 与  ||或  ！非

位运算符：C#运算符 | 菜鸟教程

//实际上是二进制的运算         
int a = 60;  //60 = 00111100
int b = 13;  //13 = 00001101
int c = 0; 

c = a & b;   //同时存在
Console.WriteLine("Line 1 - c 的值是 {0}", c);
c = a | b;   //任意存在
Console.WriteLine("Line 2 - c 的值是 {0}", c);
c = a ^ b;   //异或运算
Console.WriteLine("Line 3 - c 的值是 {0}", c);
c = ~a;      //取反，0变1
Console.WriteLine("Line 4 - c 的值是 {0}", c);
c = a << 2;  //左操作数的值向左移动右操作数指定的位数
Console.WriteLine("Line 5 - c 的值是 {0}", c);
c = a >> 2;  //左操作数的值向右移动右操作数指定的位数
Console.WriteLine("Line 6 - c 的值是 {0}", c);
Console.ReadLine();
                       
            

/*Line 1 - c 的值是 12 = 00001100
Line 2 - c 的值是 61 = 00111101
Line 3 - c 的值是 49 = 00110001
Line 4 - c 的值是 -61 = 11000011
Line 5 - c 的值是 240 = 11110000
Line 6 - c 的值是 15 = 00001111 */

赋值运算符：

=  +=  -=  *=  /=  %=  <<=  >>= &=  ^=  |=
C+=A → C=C+A

其他运算符：


sizeof()返回数据类型大小

typeof()返回class的类型 

&返回变量的实际地址

*变量的指针 

?:三元运算符 

is判断对象是否为某一类型 

as强制转换,失败不报异常


//三元运算符案例
int a, b;
a = 10;
b = (a == 1) ? 20 : 30;  //a是否等于10？等于赋值20给b,不等于30

运算符优先级：后缀＞一元>乘除>加减>移位>关系>相等>AND>位或>逻辑>条件>赋值>逗号

C#判断：

//if
//if else案例
public string ResultSelect(string choose)
        {
            string result="";
            if ("cola".Equals(choose))
            {
                result = "顾客选择的是可乐";
            }
            else if ("French_fries".Equals(choose))
            {
                result = "顾客选择的是薯条";
            }
            else if ("Chicken_nuggets".Equals(choose))
            {
                result = "顾客选择的是鸡块";
            }
            else if ("hamburger".Equals(choose))
            {
                result = "顾客选择的是汉堡";
            }
            else if ("popcorn_chicken".Equals(choose))
            {
                result = "顾客选择的是鸡米花";
            }
            else
            {
                result = "不存在";
            }
            return result;
        }

//if嵌套案例
public string ResultCheck(string choose)
        {
            string result ="";        
            string menu ="可乐,薯条,鸡块,汉堡,鸡米花";
            string[] chooses = choose.Split(',');
            //判断字符串在不在其中
            //判断是否为空，不为空再下一步，否则报错
            if (string.IsNullOrWhiteSpace(choose))
            {
                result = "顾客什么都没选择";
            }
            else
            {
                foreach (var item in chooses)
                {
                    //问题：前面的值变了，但是结果会覆盖。解决：用+=先存到字符串中
                    if (menu.Contains(item) != true)
                    {
                        result = "您选择商品不存在！";
                        break;  //到这一步直接跳出循环不继续验证下一个了
                    }
                    else
                    {
                        result = result+ "顾客选择的是" + item+";";

                    }
                    
                }

            }
            return result;
        }


//switch案例：
public string ResultSwitch(string choose)
        {
            string result;
            switch (choose)
            {
                case "1":
                    result = "顾客选择的是可乐";
                    break;

                case "2":
                    result = "顾客选择的是薯条";
                    break;

                case "3":
                    result = "顾客选择的是鸡块";
                    break;

                case "4":
                    result = "顾客选择的是汉堡";
                    break;

                case "5":
                    result = "顾客选择的是鸡米花";
                    break;

                default:
                    result = "不存在";
                    break;
            }
            return result;
        }

//嵌套switch案例
 
    class Program
    {
        static void Main(string[] args)
        {
            int a = 100;
            int b = 200;

            switch (a)
            {
                case 100:
                    Console.WriteLine("这是外部 switch 的一部分");
                    switch (b)
                    {
                        case 200:
                        Console.WriteLine("这是内部 switch 的一部分");
                        break;
                    }
                    break;
            }
            Console.WriteLine("a 的准确值是 {0}", a);
            Console.WriteLine("b 的准确值是 {0}", b);
            Console.ReadLine();
        }
}



//三元运算符
Exp1 ? Exp2 : Exp3;

C#循环：

while、for、foreach、do while、嵌套循环（随便怎么嵌套）

//while循环：while语句中只要条件为真就一直循环。循环可能一次都不会执行。当条件被测试且结果为假时，会跳过循环主体，直接执行紧接着 while 循环的下一条语句。
int a = 10;
while (a < 20)
{
  Console.WriteLine(a);
  a++;
}
Console.ReadLine();


//for循环和foreach循环(菜鸟教程里别人的代码，写的没问题）
using System;
class ForEachTest
{
    static void Main(string[] args)
    {
        int[] fibarray = new int[] { 0, 1, 1, 2, 3, 5, 8, 13 };
        foreach (int element in fibarray)//依次迭代数组内的整型，迭代一次执行一次循环语句
        {
            Console.WriteLine(element);//每次循环需要执行的内容
        }
        Console.WriteLine();


        // 类似 foreach 循环
        for (int i = 0; i < fibarray.Length; i++)//init：循环前首先执行; condition：条件; increment：循环一次后会进入这里，进行其他操作，没有也可以，有分号就行
        {
            Console.WriteLine(fibarray[i]);//输出数组中第i个值
        }
        Console.WriteLine();


        // 设置集合中元素的计算器
        int count = 0;
        foreach (int element in fibarray)  //遍历在fibarray里的所有int元素
        {
            count += 1;
            Console.WriteLine("Element #{0}: {1}", count, element);//count值反映了循环主体的执行次数，从1开始代表了数组中第一个整型，依次往后
        }
        Console.WriteLine("Number of elements in the array: {0}", count);
    }
}

//do while循环：do里面的语句至少会执行一次
class Program
    {
        static void Main(string[] args)
        {
            /* 局部变量定义 */
            int a = 10;

            /* do 循环执行 */
            do
            {
               Console.WriteLine("a 的值： {0}", a);
                a = a + 1;
            } while (a < 20);

            Console.ReadLine();
        }
    }

案例：查找2到100内的质数。

//for循环嵌套:查找2到100内的质数:一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数
            int i ;
            int j ;
            for (i = 2; i < 100; i++)
            {
                for (j = 2; j <= (i / j); j++) //i=2时，要把j从2到100都遍历一遍才会进入i=3，以此类推直到把i到100全遍历完全
                {
                    if ((i % j) == 0)
                    {
                        break;
                    }
                }
                if (j > (i / j))
                {
                    Console.WriteLine(i);
                }
            }
            Console.ReadLine();

无限循环：

//建议不要随便用无限循环说不定电脑会卡死
 for (; ; )
            {
                Console.WriteLine("Hey! I am Trapped");
            }

循环控制语句：（经常会问到这三个语句的区别！）

break：

跳出当前所有循环语句，继续执行紧接着循环的下一条语句。
用于终止 switch 语句中的一个 case。（必须有）

continue：中止本次循环，接着开始下一次循环

return：return后跳出函数，后面的语句也不再执行。

Day1结束

碎碎叨叨一些：

虽然说这是不管学什么语言都会有的一些基础知识，看似简单，实则用起来有非常多的注意点。最近被骂的有点多，不仅是因为没有学好Java等，还有代码量太少，遇到情况不知道该如何解决，自己也知道哪哪都是问题。在过去几周的实习中我才慢慢开始理解面向对象，组件封装等等一系列思维，才慢慢理解代码的意义，出现问题我该如何解决。知道这条路还有很长要走，不能肯定几年后我还在敲代码（说不定实习单位把我送走以后就不干IT了），只是目前赶鸭子上架，我也想尽可能别拖后腿。