C#系列基础教程

首先讲解一下c#,这里只是粗略的讲解，详细内容请购买相关书籍，或参阅相关文档。c#已经取消了c++中的指针，并且在c++中大量被使用的操作符 (:: ->)已经不在出现，c#中指支持一个"."。c#具有面向对象编程语言的所有特性，如封装、继承、多态等。而且比java更面向对象，每种类型都可以看作一个对象。但c#指允许单继承，即一个类不会有多个基类。另外，c#没有了全局函数，没有了全局变量，也没有了全局常量。一切都必须封装在一个类中。
　　下面举一个控制台应用程序的小例子：

using System;
class MikeCat
{
    public static void Main()
    {
        Console.WriteLine("迈克老猫c# asp.net入门系列教程－－欢迎访问老猫的理想");
    }
}        
        在c#中程序总是从Main()方法开始，Main()方法必须且只能包含在一个类中，Main()方法返回的类型可以是void(无返回值)或int(返回代表应用程序错误级别的整数)。
        上面的using System;用于导入名字空间(Namespace)用来表明类的层次关系。如果不用using导入名字空间，则每次用某一个类时就得在类名前面加上名字空间。
        c#程序的输入输出通过Console来实现。Console是System名字空间下的一个类。在屏幕上输出一个字符串用Console.WriteLine()，接受输入设备的输入用Console.ReadLine()方法。
 程序代码：
class MikeCat
{
    public static void Main()
    {
        System.Console.WriteLine("迈克老猫c# asp.net入门系列教程－－欢迎访问老猫的理想\n");
         System.Console.WriteLine("请输入用户名：");
         string user=System.Console.ReadLine();
         System.Console.WriteLine("欢迎你：{0}的光临!",user);
     }
}

 WriteLine()方法的参数表中紧随串后的第一个参数将替换{0}。

如果执行程序时要传递命令行参数给应用程序，则Main()方法的格式应为：
 using System;
public class MikeCat
{
    public static void Main(string[] args)
    {
          Console.WriteLine("共有{0}个命令行参数",args.Length);
          for(int i=0;i<args.Length;i++)
          {
                Console.WriteLine("Arg[{0}]=[{1}]",i,args[i]);
          }
     }
}

     c#中的单行注释用//，多行注释用/*...*/

     c#中使用常量：

using System
class MikeCat
{
    public const double PI=3.14;
    public static void Main()
    {
         Console.WriteLine("圆周率PI的值为{0}",PI);
    }
}

        结构体类型(struct)是一种复合数据类型，用于将某些相关的数据组织到一个新的数据类型中。

using System;
struct MikeCat
{
    public string Mike;//user
    public uint Age;//age
    public string Email;//email
}

class mf
{
    public static void Main()
    {
         MikeCat zl;//声明结构体类型变量zl
         zl.Name="迈克老猫";
         zl.Age=24;
         zl.Email="mike@hebut.com";
         Console.WriteLine("姓名：{0},年龄：{1}，邮箱{2}",zl.Name,zl.Age,zl.Email);
    }
}

   c#中枚举类型(enum)是一组逻辑上密不可分的整数值：
 using System;
enum WeekDay
{
    Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday
};//注意这里的分号
class MikeCat
{
    static void Main()
    {
         WeekDay day;//声明枚举型变量day
         day=WeekDay.Tuesday;
         Console.WriteLine("day的值是{0}",day);
     }
}      

　　c#中枚举类型中的每个元素类型均为int byte long short型，且第一个元素值为0，其后面的按1递增。在枚举中也可以直接给元素赋值，后面的递增。
enum WeekDay:byte
{
    Sunday=1,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday
};

继续上回，数组是我们经常用到的，我来介绍一下：数组是具有相同类型的一组数据。当访问数组中的数据时，可以通过下标来指明。c#中数组元素可以为任何数据类型，数组下标从0开始，即第一个元素对应的下标为0，以后逐个递增。数组可以一维也可多维。
   //包含6个元素的一维整数数组;
    int[] mf1=new int[6]; //注意初始化数组的范围,或者指定初值;
   //包含6个元素的一维整数数组，初值1，2，3，4，5，6
    int[] mf2=new int[6]{1,2,3,4,5,6};
    //一维字符串数组,如果提供了初始值设定项，则还可以省略 new 运算符
    string[] mf3={"c","c++","c#"};
    //一维对象数组
    Object[] mf4 = new Object[5] { 26, 27, 28, 29, 30 };
    //二维整数数组，初值mf5[0,0]=1,mf5[0,1]=2,mf5[1,0]=3,mf5[1,1]=4
    int[,] mf5=new int[,]{{1,2},{3,4}};
    //6*6的二维整型数组
    int[,] mf6=new mf[6,6];
   
    下面来看一个一维字符串数组的遍历
    using System;
    public class MikeCat
    {
    static void PrintArray(string[] arr)
    {
    //打印数组元素，arr.Length 表示数组元素的个数
    for(int i=0;i<arr.Length;i++)
    {
    Console.WriteLine("arr[{0}]={1}",i,arr[i]);
    }
    }
    public static void Main()
    {
    string[] arr={"c","c++","c#"};
    //将数组作为一个参数传递
    PrintArray(arr);
    }
    }
程序结果：arr[0]=c arr[1]=c++ arr[2]=c#
   
    下面来看一个4行2列(4*2)的整型数组的遍历：
    using System;
    public class MikeCat
    {
    static void PrintArray(int[,] arr)
    {
    //通过两次FOR循环遍历二维数组
    for(int i=0;i<4;i++)//初始化i作为循环变量,i++实现该变量的自增运算。
    //for循环满足条件后执行完循环体一次后执行i++，然后进入下次循环。简单的c语法，这里做简单介绍照顾初学者。(详细可参阅谭浩强先生的c语言程序设计一书)
    {
    for(int j=0;j<2;j++)
    {
    Console.WriteLine("arr[{0},{1}]={2}",i,j,arr[i,j]);//打印每个二维数组元素
    }
    }
    }
    public static void Main()
    {
    //主函数
    //将数组作为一个参数传递
    PrintArray(new int[,]{{1,2},{3,4},{5,6},{7,8}};
    }
    }
 

运行结果：arr[0,0]=1 arr[0,1]=2 arr[1,0]=3 arr[1,1]=4 arr[2,0]=5 arr[2,1]=6 arr[3,0]=7 arr[3,1]=8
   
   
    类是面向对象程序设计的基本构造块，详细我们在后面介绍。这里我们介绍两个特殊的类，即object类和string类
    1.object类
    object类是预定义类System.Object的别名，它是所有其他类型的基类。c#中所有类型都直接或间接从object类中继承。因此，一个object类的变量可以赋予任何类型的值。
   int i=30;
object obj1;
obj1=i;
object obj2='a';
    2.string类
    string类专门用于对字符串的操作，他是预定义类System.String的别名
    string str1="mikecat";
    可以用"+"号连接两个字符串。
    string str2="username:"+"mikecat";
    如果访问单个字符，则要用下标。
    char c=str1[0];
    比较两个字符串是否相等，可用比较操作符"=="//有别于basic语法
    bool b=(str1==str2);

    c# 中，取消了c和c++中使用最灵活，也是最难掌握的指针。那么在c#中如何提供c/c++中的函数指针的功能？c#提供了委托(delegate),委托是继承自System.Delegate类的引用类型。它相当于函数指针原型。与函数指针不同的是，委托在c#中是类型安全的，委托特别适合于匿名调用。要使用委托需经过三个步骤，即声明、实例化、调用。
    using System;
    //声明一个名为mfDelegate的委托，该委托有一个string类型的参数
    //c#编译器编译时会产生一个新类，该类继承自System.Delegate，类
    //名为mfDelegate
    public delegate void mfDelegate(string name);
   
    public class MikeCat
    {
    //定义与mfDelegate有相同参数类型的方法Hello()
    public static void Hello(string name)
    {
    Console.WriteLine("您好，{0}！",name);
    }
    //定义与mfDelegate有相同参数类型的方法GoodBye()
    public static void GoodBye(string name)
    {
    Console.WriteLine("再见，{0}!",name);
    }
    public static void Main()
    {
    //创建一个mfDelegate实例 mf1
    mfDelegate mf1=new mfDelegate(Hello);
    //调用mf1
    mf1("mikecat");
    mfDelegate mf2=new mfDelegate(GoodBye);
    mf2("mikecat");
    //将mf1 mf2组合成一个新的委托mf3
    mfDelegate mf3=mf1+mf2;
    //调用mf3
    mf3("迈克老猫");
    //从组合的委托mf3中删除mf1
    mfDelegate mf4=mf3-mf1;
    mf4("mikecat");
    }
    }
 

 程序结果：您好，mikecat!//mf1; 再见，mikecat!//mf2
   您好，迈克老猫! 再见，迈克老猫!//mf3
   再见，mikecat!//mf4



这次我们首先讲解一下类型转换，我们在写程序时经常用到类型转换，而且特别多的规则。我在这里粗略的讲解一下。
　　隐式转换是系统默认的、不需要加以声明即可进行的转换。
　　1.隐式数值转换
　　隐式数值转换实际上就是从低精度的数值类型转换到高精度的数值类型的转换。byte x=255;ushort y=x;y=65535;float z=y;//均从低精度到高精度，反之会产生溢出

　　隐式数值转换的类型太多,我就不多介绍，记住上面的原则就可以了。详细规则可查看msdn
　　2.隐式枚举转换
　　隐式枚举转换用于把十进制整数0转换成任何枚举类型，对应的其他整数则不存在这种转换。

using System;
enum Color
{
    Red,Green,Blue
};
class MikeCat
{
     static void Main()
     {
          Color c;//声明Color的变量c;
          c=0;//将0转换为Red;
          Console.WriteLine("c的值是{0}",c);//结果：c的值是Red;如果将c=0改成c=1，则编译器会给出错误。
      }
}

　　3.隐式引用转换
　　　　从任何引用类型到object的转换。
　　　　从类类型A到类类型B的转换，其中类A从类B派生得到。
　　　　从类类型A到接口类型B的转换，其中类A实现了接口B。
　　　　从接口类型A到接口类型B的转换，其中接口A是从接口B派生。
　　　　从任何数组类型到System.Array的转换。
　　　　从任何委托类型到System.Delegate的转换。
　　　　从任何数组类型或委托类型到System.ICloneable的转换。
　　　　从空类型（null）到任何引用类型的转换。
　　显示转换也称为强制转换，它需要用户明确地指定转换的类型。

char c=(char)65;//A
int i=(int)