C#自学笔记

C#自学笔

/**
    基本格式
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace name {
    class program {
        static void Main(String[] args) {

        }
    }
}

c#类型
值类型：
简单类型：
符号整型 ：sbyte short int long
无符号类型 ：byte ushort uint ulong
unicode字符: char
浮点型 : float double
精度小数 ：decimal
布尔型 ：bool
枚举类型：
枚举定义 ：enum name {}
结构类型：
结构定义 ：struct name {}
引用类型：
类类型：
最终基类 ：object
字符串 : string
定义类型 ：class name
接口类型：
接口定义 ：interface
数组类型:
数组定义 ：int[]
委托类型:
委托定义 ：delegate name

各种类型的取值范围：
sbyte : -128 ~ 127 整数
byte : 0 ~ 255 整数
short ：-32768 ~ 32767 整数
ushort ：0 ~ 65535 整数
int : -2147483648 ~ 2147483647 整数
uint ：0 ~ 4294967295 整数
long : 很大
ulong ：很大
float : 32位浮点数，精度是7位
double : 64位浮点数，精度是15~16位
bool ：布尔型有两个取值范围，分别是 true 和 false
string ：可以取unicode中所有字符 而不是 ascll
decimal : 一种高精度的、128位的数据类型，常用于金融和货币计算项目，28~29位有效数字，取值范围 10 ~ 70 或 -10 ~ -70
string : 用来表示字符串，常用于文本字符的代替，是字符char 的集合 例如 string name = “张瑀楠”；string 变量可以使用 + 连接
例如 string mm = “hello “; string nn = “world”; mm = mm + nn; 则 mm 的值为 hello world

各种类型的声明和赋值（这个应该都会吧）
int age = 100;
string name = “张瑀楠“；
char ch = ‘a’;
在输出变量时 变量必须已经被赋值

常量
通常将只固定不变的变量成为常量
常量的类型 sbyte byte ushort short int uint long char double float decimal bool string or enum
常量在定义的时候 使用 const 并且常量在定义的时候必须初始化
正确用法：
const int a = 78;
const string nn = “value”;
错误写法：
const int a ;
a = 78;

/*
这是我学习 c# 2天时做的总结昨天刚看了一本书的前100页 我打算现在开始学
time 2014/12/6
*/
进制的转换
Convert.ToInt32(“转换的数”,基数);
demo:
二进制转为十进制
Convert.ToInt32(“110011”,2);
八进制转为十进制
Convert.ToInt32(“567”,8);
Convert.ToString(数字,基数);
demo:
十进制转为二进制
Convert.ToString(89,2);

类型转换：
隐式转换：
在c#中bool和string是没有隐式转换的
其他隐式转换遵循取值范围的从小到大

显示转换：
一种强制的转换方式
    例子：
        double var1 = 45.45;
        int var2 = (int)var1;
    对显示转换进行检查
        int n = 8226589;
        short s = checked(short(n));
        当出现溢出时，会报出异常

字符串和数字之间的转换
    demo
    string str = "3.14";
    double pi = Convert.ToDouble(str);

基本的.NET框架
Console类
Console类能够为控制台应用程序提供字符的读写支持，其常用方法有：
WriteLine(); //the mathons same as printf(“…….\n”,….);
具体用法：
Console.WriteLine(“adcd”); //这个等同于 printf(“abcd\n”);
int a = 16;
Console.WriteLine(“a = {0}”,a); //这个相当于 printf(“a = %d\n”,a);
//在c#中输出时不需要去为定义的变量加输入格式 当然 为了特殊需要 我们也可以加上格式输出
Write(); //the mathons same as printf(“….”,…..);
//也就是这里输出时没有换行，其他和WriteLine相同

        Read();      从输入的时候读入一个字符
            用法：
                char Key = Console.Read();
                即使 我要输入 ab 结果key只是a 

        ReadLine();  从输入的时候读入一整行数据
            用法：
                string str = Console.ReadLine();
                如果输入ab 此时 str就是ab
    现在只是说了字符的输入 等下再写 关于数值的输入方法


Convert类
    能够将一种基本类型转换成另一种基本类型
        ToByte()  转换为byte型
        ToInt16() ...short
        ToInt32() ...int
        ToInt64() ...long
        ToSByte() ...sbyte
        ToUInt16()...ushort
        ToUint32()...uint
        ToUInt64()...ulong
        ToSingle()...float
        ToDouble()...double
        ToDecimal()...decimal
        ToChar()  ...char
        ToString()...string
        ToBoolean()...bool
        这些转换自动进行溢出检查，不需要使用checked

        例子：

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

            namespace ConsoleApplication1
            {
                class Program
                {
                    static void Main(string[] args)
                    {
                        Console.Write("请输入一个数字字符串");
                        string mm = Console.ReadLine();
                        decimal nn = Convert.ToDecimal(mm);
                        double zz = Convert.ToDouble(nn);
                        int i = Convert.ToInt32(zz);
                        char ch = Convert.ToChar(97);
                        Console.WriteLine("输入的是{0}", mm);
                        Console.WriteLine("decimal形式是{0}", nn);
                        Console.Write("double 形式是{0}",zz);
                        Console.Write("int 形式是{0}",i);
                        Console.Write("ch 形式为{0}" ch);
                        Console.ReadKey();
                    }
                }
            }

        result:

        请输入一个数字字符串1234
        输入的是1234
        decimal形式是1234
        double 形式是1234int 形式是1234
        ch 形式为 a

        通过例子可以看出Console and Convert 的 用法 通时也提供了一种 数值输入的方法
        关于数值的输入，可以使用上面中的类型转换的方法
            int a = Convert.ToInt32(Console.Read());

        demo:
            static void Main(String[] args)
            {
                double r , s;
                Console.Write("r = ");
                r = Convert.ToInt32(Console.ReadLine());
                s = 3.14 * 3.14 * r;
                Console.WriteLine("s = " + s);
            }


Math类
    一些简单的表达式
        Math.Sqrt(value); 求平方根
        Math.Pow(a,b);    求 a 的 b 次幂

变量的格式化输出
    控制宽度{,宽度:c小数位数}  //c为货币符号
        {,#.00} 显示两位小数

基姆拉尔森公式：
    根据日期求这天是周几
    int y = 2008;
    int m = 8;
    int d = 8;
    int week = (d + 2 * m + 3 * (m + 1 )/5 + y + y / 4 - y / 100 + y / 400 + 1) % 7;

表达式和运算符
表达式学过编程语言的应该都明白，现在开始说说运算符

. 运算符
    通过 . 运算符可以对项目内不同的成员进行访问，包括命名空间的访问类、类访问方法和数值

() 运算符
    定义方法和委托

[] 运算符
    能够存储项目预防问的元素 例如数组的读取

++  --  运算符

new 运算符
    可以创建项目中引用类型的实例，即创建类、数组和委托的实例

sizeof 运算符
    返回指定类型的所占的字节数

typeof 运算符

数学运算符
    运算符     类别      处理表达式           result
    +           二元      mm = nn + zz;       plus
    -           二元      mm = nn - zz;       sub
    *           二元      mm = nn * zz;       积
    /           二元      mm = nn / zz;       商
    %           二元      mm = nn % zz;       模
    +           一元      mm = +nn;           乘以 +1
    -           一元      mm = -nn;           乘以 -1
    +=          二元      mm += nn;           mm = mm + nn;
    -=          二元      mm -= nn;           mm = mm - nn;
    *=          二元      mm 8= nn;           mm = mm * nn; 
    /=          二元      mm /= nn;           mm = mm / nn; 
    %=          二元      mm %= nn;           mm = mm % nn;

比较运算符(与其他语言一样)
    ==
    <
    >
    <=
    >=
    !=

逻辑运算符
    ！
    &   
    |
    ~      mm = nn ~ zz;   if nn and zz only is true ，mm = true。
    ||
    &&

移位运算符
    <<
    >>

运算符的优先级

流程控制语句
if…else…

switch //需要理解和其他语言中的switch的不同

while() {...} and  do {...} while()

for( ; ; )

break

continue

goto

return 

复杂的数据类型
枚举
枚举类型用关键字enum定义,中间用逗号隔开(默认从零开始计数，即Sunday 为0，Monday为 10)：
enum WeekDays{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday}
demo：
namespace Demo
{
enum WeekDays{Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday}
class Program
{
static void Main(String[] args)
{
WeekDays today = Wednesday.Sunday;
if(today == Wednesday.Saturday || today == Wednesday.Sunday)
{
Console.WriteLine(“I love the weekends”);
}
else
{
Console.WriteLine(“Back to work”);
}

                    WeekDays temp;
                    temp = (WeekDays) 3;
                    Console.WriteLine(temp);

                    temp = WeekDays.Friday;
                    Console.WriteLine((int)temp);

                    //枚举型进行计算
                    temp = temp + 1;
                    Console.WriteLine(temp);
                }
            }
        }

        enum WeekDays
        {
            Sunday = -5,
            Monday,   //-4
            Tuesday,  //-3
            Wednesday = 100,
            Thursday, //101
            Friday,   //102
            Saturday  //103
        }

结构
    结构体有struct定义
        struct Student
        {
            public int number;
            public string name;
            public string sex;
            public string birthday;
        }

    demo
        static void Main(String[] args)
        {
            Student zyn;
            zyn.number = 2013040510;
            zyn.name = "zyn";
            zyn.sex = "man";
            zyn.birthday = "1994.01.09";
            Console.Write("学号：" + zyn.number);
            Console.Write("姓名: " + zyn.name);
            Console.Write("性别: " + zyn.sex);
            Console.Write("生日: " + zyn.birthday);
        }

数组
    这里的数组的定义方法异于c和c++
    数组在定义的时候 
        int[] aa = {...};
    rather than
        int a[];
    demo
    static void Main(String[] args) 
    {
        int[] scores = { 120 ,149 ,112 ,133 ,127};
        for(int i = 0 ; i < scores.Length ; ++i)
        {
            Console.Write(scores[i]);
        }

        string[] friendNames = new string[3];
        friendNames[0] = "hl";
        friendNames[1] = "hh";
        friendNames[2] = "hs";

        foreach(string name in friendNames) 
        {
            Console.WriteLine(name);
        }
    }


    多维数组的使用
    static void Main(string[] args)
    {
        //定长数组
        int[,] Matrix = { {1 , 2 , 3} ,{4 , 5 , 6} , { 7 , 8 , 9}};
        int sum = 0;
        for(int i = 0 ; i < 3 ; ++i)
        {
            for(int j = 0 ; j < 3 ; ++j)
            {
                sum += Matrix[i][j];
            }
        }

        Console.WriteLine("the sum of Matrix is " + sum);

        //不定长数组
        int[][] ja = new int[2][];
        ja[0] = new int[3];
        ja[1] = new int[4];
        ja[2] = new int[5];
    }

函数
function
参数传递
值传递
地址传递
复杂类型的参数传递
引用型参数传递(ref)
demo（swap value a and b)
void Swap(ref int x,ref int y)
{
int temp = x;
x = y;
y = temp;
}
输出型参数传递(out)
out型参数传入函数前不需赋值，即使赋值也会被忽略
demo(已知半径就面积)
double CalculateCircle(double r , out double c)
{
c = 2 * Math.PI * r ;
double s = Math.PI * r * r;
return s;
}

递归函数
    斐波那契
    demo
    static int Fibonacci(int n)
    {
        if( n == 1 || n == 2) 
        {
            return 1;
        }
        else
        {
            return Fibonacci(n - 1) + Fibonacci(n - 2);
        }
    }

面向对象编程技术
类
class Person
{
public string name;
public int age;
public string sex;
private int miceCount = 0;

        private void Hello()
        {
            Console.Write("haha zyn");
        }

        public void Neow() 
        {
            Hello();
            Console.WriteLine("miaomiao");
        }
    }
    构造函数
    析构函数

非托管程序（不是在.NET程序下运行的程序）
System.Gc.Collect() 强制调用垃圾回收机制

readonly 常量

方法的重载

运算符的重载
    重载运算符由关键字 operator 声明，必须定义为静态
        demo
        class Complex
        {
            public double a;
            public double b;

            public static Complex operator + (Complex p1 , Complex p2)
            {
                return new Complex(p1.a + p2.a , p1.b + p2.b);
            }

            public Complex(double real , double imagi)
            {
                a = real;
                b = imagi;
            }

        }

核心技术篇
方法