C#进阶教程

C#进阶教程(一)
C#进阶教程(二)
C#进阶教程(三)
C#进阶教程(四)
C#进阶教程(五)
C#进阶教程(六)
C#进阶教程(七)
C#进阶教程(八)
C#进阶教程(九)
C#进阶教程(十)
C#进阶教程(十一)

C#进阶教程(一)

转载自：中国ASP联盟人气：10599

在表面上,C#和JAVA非常地像,以致一个懂JAVA的人能够很快的掌握C#的结构.致于其内部的实现机理,那我也不太清楚,只能与大家在学习中共同进步了,还希望大家多多捧场呀!

好,为了给大家一个更清晰的感觉,我首先给大家一个例子,自然是HelloWorld(老土!).

// HelloWorld\Hello1.cs
public class Hello1
{
    public static void Main()
    {
        System.Console.WriteLine("Hello, World!");
    }
}

它的输出结果是:

Hello, World!

有的朋友已经发现了,就是JAVA!只不过把System.out.prinln()改成了System.Console.WriteLine()罢了!

下面我们来分析一下这个程序，整个程序由一个public类(class)组成,里面必然有一个public static void Main()这个方法,执行代码就在里面.System.Console.WriteLine("Hello, World!")这个语句的作用就是向控制台(Console)打印一行Hello,World!.很简单吧!

下面再来一个:

// HelloWorld\Hello2.cs
using System;
public class Hello2
{
    public static void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

这个程序用了一个using,其实它就等于JAVA里的import,就是引用一个包的意思.当引用了这个包之后,在这个包中的Console类就不要指出全称了,只要Console.WriteLine()就可以了,不必用System.Console.WriteLine()这么长了,省略了System了.

例三,如下显示了如何显示命令行的参数

// HelloWorld\Hello3.cs
using System;
public class Hello3
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Hello, World!");
        Console.WriteLine("You entered the following {0} command line arguments:", args.Length);
        for (int i = 0; i < args.Length; i++)
        {
            Console.WriteLine("{0}", args[i]);
        }
    }
}

可以看到,字符串数组args指的就是输入的参数.因为它是String类,所以都有Length方法,所以可以有args.length来访问它的长度.然后用一个for循环来把它们显示出来.至于循环这些东西,大都沿用了C的语法.

例四,如果要一个返回值,那么可以像下面这样写,用return:

// HelloWorld\Hello4.cs
using System;
public class Hello4
{
    public static int Main(string[] args)
    {
        Console.WriteLine("Hello, World!");
        return 0;
    }
}

很简单吧!呵呵!对懂C或JAVA的人来说,比较好看懂,如果是VB或VBS的使用者,就有一些困难了.!

C#进阶教程(二)

下面的代码显示了我们如何打印多个参数:

// CommandLine\cmdline1.cs
using System;
public class CommandLine
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Number of command line parameters = {0}", args.Length);
        for (int i = 0; i < args.Length; i++)
        {
            Console.WriteLine("Arg[{0}] = [{1}]", i, args[i]);
        }
    }
}

如果你的输入为:

cmdline1 A B C

那么它的输出为:

Number of command line parameters = 3
Arg[0] = [A]
Arg[1] = [B]
Arg[2] = [C]

哈哈,看出了其中的秘密了吧!是的{0}是一个标记,它告诉系统,这里留下了给第0个参数用,在程序中,这第0个参数就是i.因此,打印出来的就是Arg[0],面不是Arg[{0}]了,哈哈! 例二向大家展示了foreach这个语句的用法,其实在ASP中,这个经常用到:

// CommandLine\cmdline2.cs 
using System;
public class CommandLine2
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Number of command line parameters = {0}", args.Length);
        foreach (string s in args)
        {
            Console.WriteLine(s);
        }
    }
}

很显然,args是一个数组,而且是字符型的.foreach的意思就是把其中的所有元素都循环完.

运行得出:

>cmdline2 John Paul Mary 

Number of command line parameters = 3 
John
Paul
Mary

C#进阶教程(三)

今天我要向大家讲的是C#的数组(Arrays).C#中的数组和其它一些优秀的语言一样,也是从0开始计的,这从我们以前的例子里可以看出来,也就是说,一个数组的第一个元素是a[0],而不是像VB的a(1).虽然是这样,但是你还是要注意一些区别.

在声明一个数组的时候,方括号必须跟在类型后面,而不能跟在变量名后面,如:

int[] table; //不能写成int table[]

这一点显然与JAVA是不同的,在JAVA中这样是可以的.

还有就是在C#中你可以不指定数组的大小,这与C语言是不一样的.这使得你可以指定任意长度的数组,如下:

int[] numbers; // 它的长度是任意的

当然,你也可以指定它的大小:

int[10] numbers;//指定了一个长度为10的数组.

在C#中,支持的数组包括:单维数组,多维数组和多重数组.它们的声明方法如下:

单维数组:　int[] numbers;
多维数组:　string[,] names;
多重数组:　byte[][] scores;

声明一个数组并不代表已经建立了它.在C#中,所有的数组元素都是对象(倒!怎么跟JAVA说得一样&*%$#@),所以在建立它之前,首先要将它实例化:

单维数组:　int[] numbers = new int[5];
多维数组:　string[,] names = new string[5,4];
多重数组:　byte[][] scores = new byte[5][];

for (int x = 0; x < scores.Length; x++) {
    scores[x] = new byte[4];
}

呵呵,这有点奇怪吧,先不用理它,以后再说.

我们同样可以建立更大的数组,比如一个三维数组:

int[,,] buttons = new int[4,5,3];

我们甚至可以混合多维数组和多重数组,下面的例子说明了这些:

int[][,,][,] numbers;

下面的例子展示了以上所有构建数组的方法:

// Arrays\arrays.cs
using System;
class DeclareArraysSample
{
    public static void Main()
    {
        // Single-dimensional array
        int[] numbers = new int[5];
        // Multidimensional array
        string[,] names = new string[5, 4];
        // Array-of-arrays (jagged array)
        byte[][] scores = new byte[5][];
        // Create the jagged array
        for (int i = 0; i < scores.Length; i++)
        {
            scores[i] = new byte[i + 3];
        }
        // Print length of each row
        for (int i = 0; i < scores.Length; i++)
        {
            Console.WriteLine("Length of row {0} is {1}", i, scores[i].Length);
        }
    }
}

它的输出是:

Length of row 0 is 3
Length of row 1 is 4
Length of row 2 is 5
Length of row 3 is 6
Length of row 4 is 7

在C#中数组的初始化可以在建立时就初始化,和JAVA和C一样,用的是{}.当然,很明显,你的初始化值必须与你声明的数组类型一样,比如你定义了一个int类型的,你就不能给它一个String,唉,JAVA看多了,在C#中,String应写为string,要不然,又要出错了.SUNWEN可能在后面的课程中出现这样的错误,还望大家指正.呵呵!

下面的例子说明了数组的初始化:

int[] numbers = new int[5] {1, 2, 3, 4, 5};
string[] names = new string[3] {"Matt", "Joanne", "Robert"};

你也可以省略数组的大小,如:

int[] numbers = new int[] {1, 2, 3, 4, 5};
string[] names = new string[] {"Matt", "Joanne", "Robert"};

你甚至可以省略new语名,如果你给了值:

int[] numbers = {1, 2, 3, 4, 5};
string[] names = {"Matt", "Joanne", "Robert"};

在C#中,数组的访问和C/C++/JAVA是一样的,下面的语句建立了一个数组,并将它的第五个元素赋值为5:

int[] numbers = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
numbers[4] = 5;

如果你没有C/JAVA/C++的编程经验,那么SUNWEN在此提醒,numbers[4]表示的是这个数组的第五个元素,因为我在前面已经说过了,数组是从0开始计的,所以0,1,2,3,4正好是第五个,所以....(台下:笨蛋,你以为我们不知道呀,快继续说!)

下面的例子是关于多维数组的:

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

再次注意,C#中的所有数组都是对象(faint,D版),所以,你可以用访问对象的方法,来访问数组.而System.Array就是数组的抽象.你可以参看文档来看Array类支持的方法.举个例子来说吧,你可以用length属性来访问数组的长度.如下例:

int[] numbers = {1, 2, 3, 4, 5};
int LengthOfNumbers = numbers.Length;

C#进阶教程(四)

C#中的属性

这次我要向大家讲的是C#中的属性.属性是什么呢,比如说我是男的,男就是我的一人属性.我是一个大一的学生,大一也是我的一个属性.属性就是一个对象的性质.很简单吧,呵呵!下面,我给出两个例子,第一个例子出明了如何声明一个可以修改的属性,另一个例了建立了一个抽象的属性(Abstract),并且说明了如何在子类中丢弃它.好,下面让我们开始吧.

例子一:

// Properties\person.cs
using System;
class Person
{
    private string myName = "N/A";
    private int myAge = 0;

    // 声明一个字符型的属性Name
    public string Name
    {
        get
        {
            return myName;
        }
        set
        {
            myName = value;
        }
    }

    // 声明一个int型的Age属性
    public int Age
    {
        get
        {
            return myAge;
        }
        set
        {
            myAge = value;
        }
    }

    public override string ToString()
    {
        return "Name = " + Name + ", Age = " + Age;
    }

    public static void Main()
    {
        Console.WriteLine("Simple Properties");
        // 建立一个Person的实例
        Person person = new Person();
        //打印出它的属性
        Console.WriteLine("Person details - {0}", person);
        // 对属性进行一些设置
        person.Name = "Joe";
        person.Age = 99;
        Console.WriteLine("Person details - {0}", person);
        // 增加年龄
        person.Age += 1;
        Console.WriteLine("Person details - {0}", person);
    }
}

这个例子的输出是：

Simple Properties
Person details - Name = N/A, Age = 0
Person details - Name = Joe, Age = 99
Person details - Name = Joe, Age = 100

好了，又起床了，昨天写到这，就跑到床上睡了，呵呵.现在是五一的第二天,看看我今天能写几篇,昨天写了二篇.从上面的程序我们可以看出,一个类的属性的设置,借用了VB的概念,和JAVA中不尽相同了.(这就是M$,TMD!)有的朋友可能很奇怪,为什么我们可以用Console.WriteLine()来打印一个对象person呢.其实道理很简单,和在JAVA中的一样,当调节器用一个打印方法时,这个对象自动调用它的ToString()(在JAVA中是toString,TMD,又差点犯错!)方法.在33行,我们可以看到有这个方法的影子,override这个关键字大概就是覆盖父类的方法吧,这是不是有点多余?我们可以看到,一个对象的属性的设置是通过一个get()和set()组合来完成的,当然,还有一个value这个东东.补充一下,你还可以控制一个属性的读/写权限,只是把get()和set()简单地去掉就可以了,比如你不要写的属性,就不要set()就可以了,如果你不要读,就不要get()吧.总得感觉,C#在这点上没有JAVA来的灵活(完了,又要被盖痴打了!).

第二个例子:

这个例子说明了如何建立抽象的属性(Abstract),什么是抽象的属性呢,所谓的抽象的属性呢,就是....(唉,每次废话都这么多!FT)

一个抽象类并不提供执行属性存取程序,并且,他可以在子类中被忽略.下面的例子有三个文件,你要分别编译它们才能得到结果,它们是:

abstractshape.cs: Shape类,包含一个Area抽象属性
shapes.cs: Shape的子类
shapetest.cs: 显示程序.

要编译这些程序,运行:csc abstractshape.cs shapes.cs shapetest.cs就可以了.运行完之后,它会产生shapetest.exe这个可执行程序.

// Properties\abstractshape.cs
using System;
public abstract class Shape
{
    private string myId;

    public Shape(string s)
    {
        Id = s; // 这句调用了Id属性的set构建器
    }

    public string Id
    {
        get
        {
            return myId;
        }

        set
        {
            myId = value;
        }
    }

    public abstract double Area
    {
        get;
    }

    public override string ToString()
    {
        return Id + " Area = " + double.Format(Area, "F");
    }
}

看这个程序, 实际上非常地简单,当这个类对的对象被建立时,初始化部分为007-010,它把建立对象的参数s给了Id这个属性.然后进行了上一个例子的操作.实际上,我们可以把抽象属性与JAVA中的接口(Interface)相比,它们只提拱一个方法的名称,而不提供这个方法的内容.就像Area这个抽象属性,有一个get,但是它并没有指定get方法(也许它不能称之为方法)里的内容,即要get做什么事情.

这个事情,由它的子类来做.

第二个文件:在这个文件中,一个类覆盖了(override)了Area属性.

// Properties\shapes.cs
public class Square : Shape
{
    private int mySide;
    public Square(int side, string id) : base(id)
    {
        mySide = side;
    }
    public override double Area
    {
        get
        {
            return mySide * mySide;
        }
    }
}
public class Circle : Shape
{
    private int myRadius;
    public Circle(int radius, string id) : base(id)
    {
        myRadius = radius;
    }
    public override double Area
    {
        get
        {
            return myRadius * myRadius * System.Math.PI;
        }
    }
}
public class Rectangle : Shape
{
    private int myWidth;
    private int myHeight;
    public Rectangle(int width, int height, string id) : base(id)
    {
        myWidth = width;
        myHeight = height;
    }
    public override double Area
    {
        get
        {
            return myWidth * myHeight;
        }
    }
}

这个例子就有些让我们一头雾水了,:是干什么的,好象是继承,相当于JAVA中的extends吧.我想是的.我们先看一看吧.

下面的第三个文件就是一个测试文件了,很简单,大家看一看.

// Properties\shapetest.cs
public class TestClass
{
    public static void Main()
    {
        Shape[] shapes =
        {
            new Square(5, "Square #1"),
            new Circle(3, "Circle #1"),
            new Rectangle( 4, 5, "Rectangle #1")
        };
        System.Console.WriteLine("Shapes Collection");
        foreach (Shape s in shapes)
        {
            System.Console.WriteLine(s);
        }
    }
}

从这个例子上看,:这个符号的确是extends的意思,就是继承.继承是什么意思,说白了,就是生孩子的意思.比如下面一句a extends ab,这名就是说a这个类继承了ab类的所有东西,同时可以添加和删除ab中的一些东西.就这么简单,但是这是现代软件发展的一项重要技术,因为它可以使软件的重用性大大提高.唉,这些就只有大三大四的人说了,我就没资格了.呵呵.

这个程序的输出是:

Shapes Collection
Square #1 Area = 25.00
Circle #1 Area = 28.27
Rectangle #1 Area = 20.00

完了,这一节又完了.要理解这一节,有一定的难度, 特别对那些没有JAVA或C++编程经验的朋友.不过不要害怕,鼓起勇气学下去,一定会有所收获的.

C#进阶教程(五)

C#中的库(libraries)

言归正传,我现在要说的是库(libraries),和大家一起学习如何用C#建立一个DLL文件.说起DLL,肯定是无人不知,无人不晓,这个WINDOWS的典型代表,同时也经常是大家功击的对象.呵呵,不管怎么样,学还是要学的.我们下面就开始,如何用命令行方式将一个C#程序编译成DLL,和如何在客户端使用他.

这个例子包括两个文件,一个是Factorial.cs,作用是计算一个数字的阶乘.还有一个是DigitCounter.cs,作用是计算传过来的字符串参数中的数字的数目.

我们可以这样来建立库,在命令行方式下这样做:

csc /target:library /out:Functions.dll Factorial.cs DigitCounter.cs

下面讲一下各个参数的用法:

/target:library:向系统指出输出的是一个DLL库,而不是一个EXE的可执行文件.
/out:Functions.dll:指定输出的DLL的文件名,即Functions.dll,一般地,如果你省略了第一个参数,那么默认的文件名将是第一个文件的文件名,即Factorial.dll.

下面我们再来建立一个文件,即使用这个库的文件,叫客户端文件,FunctionClient.cs.建立好后,用下面的语名编译:

csc /out:FunctionTest.exe /R:Functions.DLL FunctionClient.cs

下面说一下这个编译语句的用法:

/out:FunctionTest.exe:指出输出的文件名是FunctionTest.exe
/R:Functions.DLL:指出要引用的库,如果不是在当前目录下,必须要指出其的完整路径.

下面我就把这几个文件的代码写在下面:

// Libraries\Factorial.cs
using System;
namespace Functions
{
    public class Factorial
    {
        public static int Calc(int i)
        {
            return ((i <= 1) ? 1 : (i * Calc(i - 1)));
        }
    }
}

这是Factorial.cs这个文件的代码.在003行中,namespace的意思是名字空间,据M$的介绍,库必须根据它的名字空间打包,以使.NET能够正确地载入你的类.

下面是DigitCounter.cs这个文件的内容:

// Libraries\DigitCounter.cs
using System;
namespace Functions
{
    public class DigitCount
    {
        public static int NumberOfDigits(string theString)
        {
            int count = 0;
            for (int i = 0; i < theString.Length; i++)
            {
                if (Char.IsDigit(theString[i]))
                {
                    count++;
                }
            }
            return count;
        }
    }
}

注意,这个例子中的namespace应与第一个的一致,因为它们是同一个库中的.NumberOfDigits方法计算了参数中的数字的个数.

第三个文件是FunctionClient.cs

我们知道,一个库一旦建立,就可以被别的类利用(废话,要不然怎么叫库呢?).下面的C#程序就利用了我们刚才建立的库中的类.

// Libraries\FunctionClient.cs
using System;
using Functions;
class FunctionClient
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Function Client");

        if (args.Length == 0)
        {
            Console.WriteLine("Usage: FunctionTest ... ");
            return;
        }

        for (int i = 0; i < args.Length; i++)
        {
            int num = Int32.Parse(args[i]);
            Console.WriteLine(
            "The Digit Count for String [{0}] is [{1}]",
            args[i],
            DigitCount.NumberOfDigits(args[i]));
            Console.WriteLine(
            "The Factorial for [{0}] is [{1}]",
            num,
            Factorial.Calc(num));
        }
    }
}

在002行中,一个using Functions指明了引用Functions.DLL这个类.

如果我们在命令行中键入如下命令,就可以看到输出:

FunctionTest 3 5 10

输出:

Function Client
The Digit Count for String [3] is [1]
The Factorial for [3] is [6]
The Digit Count for String [5] is [1]
The Factorial for [5] is [120]
The Digit Count for String [10] is [2]
The Factorial for [10] is [3628800]

注意:当你运行这个.EXE文件时,它引用的DLL文件可以是在当前目录,子目录,或是CORPATH这个环境变量.CORPATH这个环境变量是在.NET环境中的类路径,用来指引系统寻找类.说白了,就是JAVA中的CLASSPATH,明白了吧,呵呵.

C#进阶教程(六)

C#中的版本处理

现在我要说的是C#中的版本处理.其实这是任何一个软件必须要考虑的问题.每个软件都不只一个版本(除了我写的以外),因此版本处理显得非常地重要.JAVA很好地处理了这个问题,而我个人认为C#借鉴了JAVA的处理方法,所以,也做得很好.

在C#中,如果你在声明一个方法的时候用了virtual这个关键字,那么,在派生类中,你就可以使用override或者new关键字来弃用它或是忽略它.如果你在父类中用了virtual这个关键字,而在其派生类中又没有用override或new关键字,而直接引用一个同名方法的话,编译器将会报错,并将以new方式,即忽略派生类中的方法的方式来运行.下面的例子可以帮助你来理解:

// Versioning\versioning.cs
public class MyBase
{
    public virtual string Meth1()
    {
        return "MyBase-Meth1";
    }
    public virtual string Meth2()
    {
        return "MyBase-Meth2";
    }
    public virtual string Meth3()
    {
        return "MyBase-Meth3";
    }
}

class MyDerived : MyBase
{
    public override string Meth1()
    {
        return "MyDerived-Meth1";
    }
    public new string Meth2()
    {
        return "MyDerived-Meth2";
    }
    public string Meth3() // 系统在这里将会有一个警告,并且将会隐藏方法Meth3() 
    {
        return "MyDerived-Meth3";
    }

    public static void Main()
    {
        MyDerived mD = new MyDerived();
        MyBase mB = (MyBase)mD;

        System.Console.WriteLine(mB.Meth1());
        System.Console.WriteLine(mB.Meth2());
        System.Console.WriteLine(mB.Meth3());
    }
}

输出:

MyDerived-Meth1
MyBase-Meth2
MyBase-Meth3

可以很明显地看出来,后两个new关键字的输出是父类中的方法的输出,所以可以看出,new这个关键字的作用是如果在以前的版本中有这个方法,就沿用以前的方法,而不用我现在方法内容.而virtual的方法的作用正好相反,它的作用是如果在父类中有这样一个方法,则用我现在写的方法内容,让以前的滚蛋!不过,这里用new好象不太好,让人误解(糟了,盖痴又要打我了!&*%$#@).

如果你把第037行去掉,把039-041中的mB全部改为mD，输出又变为:

MyDerived-Meth1
MyDerived-Meth2
MyDerived-Meth3

这又说明了什么呢,说明了派生类的对象只有在被父类重塑的时候,override和new关键字才会生效.呵呵,这样说的确有点难以理解,大家只有自己动手,才能搞清楚这其中的机关,所谓"实践是检验C#的唯一标准",哈哈!

在C#中,你可以自由地为在派生类中为加入一个方法,或者覆盖父类的方法,如下所示,非常地简单:

class Base {}
class Derived: Base
{
    public void F() {}
}

和:

class Base 
{
    public void F() {}
}
class Derived: Base
{
    public void F() {}
}

C#进阶教程(七)

C#中的结构(struct)

我要说的是C#中的,注意,我在这里说的结构不是指的C#的语言结构.这里所说的是一种与类(class)相对的东西,下面我就与类相对比,来说一说这个struct.

下面的这个例子讲述了如何建立一个具有属性,方法和一个字段的结构.并讲述如何使用他.

// Structs\struct1.cs
using System;
struct SimpleStruct
{
    private int xval;
    public int X
    {
        get
        {
            return xval;
        }
        set
        {
            if (value < 100)
                xval = value;
        }
    }
    public void DisplayX()
    {
        Console.WriteLine("The stored value is: {0}", xval);
    }
}

class TestClass
{
    public static void Main()
    {
        SimpleStruct ss = new SimpleStruct();
        ss.X = 5;
        ss.DisplayX();
    }
}

这个例子的输出是:

The stored value is: 5

从上面的例子中我们可以看到结构和类似乎是一样的.的确,如果你用类去重亲写这个程序,结果是一样的.但是,很明显,两个一样的东西是不可能一起出现的.

结构(struct)是值(value)型的,而类是参考型的.这样,你就可以用结构建立像内建类型那样的对象了.

还有就是如果你用一个new关键字建立一个类的实例的时候,它是以堆(heap)来分配的,而用new来建立一个结构的的实例的时候,它是以栈(stack)来分配.这会给我们提高很多性能(M$说的).好了,让我们再来看下面的例子吧:

// Structs\struct2.cs
using System;

class TheClass
{
    public int x;
}

struct TheStruct
{
    public int x;
}

class TestClass
{
    public static void structtaker(TheStruct s)
    {
        s.x = 5;
    }
    public static void classtaker(TheClass c)
    {
        c.x = 5;
    }
    public static void Main()
    {
        TheStruct a = new TheStruct();
        TheClass b = new TheClass();
        a.x = 1;
        b.x = 1;
        structtaker(a);
        classtaker(b);
        Console.WriteLine("a.x = {0}", a.x);
        Console.WriteLine("b.x = {0}", b.x);
    }
}

这个例子的输出是:

a.x = 1
b.x = 5

从这个例子例子可以看出,当一个结构被传递到一个方法时,被传递的只不过是一个副本,而一个类被传递时,被传递的是一个参考.所以a.x=输出的是1,不变,而b.x却变了.

还有的区别就是结构可以不用new来实例化,而类却要.如果你不用new来实例化一个结构,那么所有的字段将仍然处于未分配状态,直到所有的字段被初始化.和类一样,结构可以执行接口.更重要的是,结构没有继承性,一个结构不能从别的类继承,也不能是别的类的基类.

例三:

interface IImage
{
    void Paint();
}

struct Picture : IImage
{
    public void Paint()
    {
        // painting code goes here
    }
    private int x, y, z; // other struct members
}

C#进阶教程(八)

C#中的ADO数据库访问

这一节我要讲的是大家非常关心的,肯定也是非常感兴趣的部分.嘿嘿,也是我写教程最拿手的部分----ADO数据库访问.想到这,我就想起我在去年写的"访问数据库"系列文章,嘿嘿!所以呢,如果你觉得对记录集之类的东西比较难理解的话,我推荐你先看一看我的那几篇文章.好了,让我们开始吧!

什么是ADO(ActiveX Data Objects译作ActiveX数据对象),ADO是一个非常简单的思想,一种让你仅用一种方式去访问数据的思想.ADO不算一个新的思想,仅是采用现有的数据访问技术,将其融合起来.如果你不理解ADO,想一想ODBC吧!其实我们在搞ASP的时候,就用到了ADO,还记得吗,那个曾经被我们用过无数次的set conn=Server.CreateObject("ADODB.Connection")吗?是的,就是它.至于ADO的一些概念性的东西,请大家自行查阅资料,不过,其实不了解也没有关系,只把它想象成一个M$给我们的访问数据的工具吧!

OK,下面的例子是以一个M$ ACCESS 2000的数据库为基础的,它的结构如下,表名是Categories,文件名是BugTypes.mdb ,赶快建一个吧:

Category ID	Category Name
1	Bugbash stuff
2	Appweek Bugs
3	.NET Reports
4	Internal support

好的,我先把所有的程序都写出来,然后我们来一句一句的品尝:

// ADO\adosample.cs
using System;
using System.Data;
using System.Data.ADO;

public class MainClass
{
    public static void Main()
    {
        // 设定好连接字符串和选择命令字符串
        string strAccessConn = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=BugTypes.MDB";
        string strAccessSelect = "SELECT * FROM Categories";

        //建立记录集,并把Categories这个表填进去 
        DataSet myDataSet = new DataSet();
        myDataSet.Tables.Add("Categories");

        //建立ADO实例
        ADOConnection myAccessConn = new ADOConnection(strAccessConn);
        ADODataSetCommand myAccessDataSetCmd = new ADODataSetCommand();
        myAccessDataSetCmd.SelectCommand = new ADOCommand(strAccessSelect, myAccessConn);

        myAccessConn.Open();
        try
        {
            myAccessDataSetCmd.FillDataSet(myDataSet, "Categories");
        }
        finally
        {
            myAccessConn.Close();
        }

        try
        {
            // 一个记录集可以包含多个表,我们把它们放到一个数组中
            DataTable[] dta = myDataSet.Tables.All;
            foreach (DataTable dt in dta)
            {
                Console.WriteLine("Found data table {0}", dt.TableName);
            }

            //下面的两行程序展示了两种从一个记录集中得到这个数据集中的表格数的方法 
            Console.WriteLine("{0} tables in data set", myDataSet.Tables.Count);
            Console.WriteLine("{0} tables in data set", dta.Length);
            //下面的几行程序说明了如何从一个记录集中依靠表格的名称来取得信息 
            Console.WriteLine("{0} rows in Categories table", myDataSet.Tables["Categories"].Rows.Count);
            //列的信息是自动从数据库中得到的,所以我们可以用以下的代码
            Console.WriteLine("{0} columns in Categories table", myDataSet.Tables["Categories"].Columns.Count);
            DataColumn[] drc = myDataSet.Tables["Categories"].Columns.All;
            int i = 0;
            foreach (DataColumn dc in drc)
            {
                //打印出列的下标和列的名称和数据类型
                Console.WriteLine("Column name[{0}] is {1}, of type {2}", i++, dc.ColumnName, dc.DataType);
            }
            DataRow[] dra = myDataSet.Tables["Categories"].Rows.All;
            foreach (DataRow dr in dra)
            {
                //打印出CategoryID和CategoryName
                Console.WriteLine("CategoryName[{0}] is {1}", dr[0], dr[1]);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine("Oooops. Caught an exception:\n{0}", e.Message);
        }
    }
}

看起来,这个例子是有一些复杂的,只怪我例子选的不好,呵呵.不过,细细分析一下,还是可以理解的.我现在说一下这个例子中几个特别的东东.第一就是不象在ASP中,一个命令字符串被须被当作一个命令对象.

020做的正是这个事情.注意,在015行有一个myDataSet.Tables.Add("Categories")语句,这并不是把数据库中的Categories这个表填进去,只不过是建一个空表,而025才是真的填充数据.

这个例子的输出是:

Found data table Categories
1 tables in data set
1 tables in data set
4 rows in Categories table
2 columns in Categories table
Column name[0] is CategoryID, of type Int32
Column name[1] is CategoryName, of type System.String

CategoryName[1] is Bugbash stuff
CategoryName[2] is Appweek Bugs
CategoryName[3] is .NET Reports
CategoryName[4] is Internal support

好了,就说到这吧,SUNWEN真是想睡了,什么音乐都不管用了,呵呵.这个例子还真要花大力气才能完全理解.O.K.886!

C#进阶教程(九)

C#中的用户自定义转换(User-Defined Conversions)

现在我要说的是C#中的用户自定义转换(User-Defined Conversions),其中用到了前面说的struct的知识,就是结构呀,忘了吗?好,没忘就好.从我们以下的课程我们可以看到结构的用处(刚才我还在想它有什么用,呵呵).用class声明的是一个类,而用struct声明的可以看作是一个类型,对,就是像C#自带的int,short,long那样的类型了.

C#中可以允许我们对结构(struct)和类(class)进行转换,所以我们可以在其中定义一些转换.但是,C#规定,所有的转换声明都必须在显示(explicit)和隐示(implicit)中选择一个.比方说,我们用这个语句的时候

int a=10;
System.Console.println(a):

就用到了int的隐示的转换toString.如果是(String)a,就叫做显示.所以,显/隐之差就在于是否表现出来.大家现在肯定还是一头雾水,等到明天我把例子写出来再分析一下就清楚了,要熄灯了,我先走一步了!

喔~~~~~终于起来了，五月五日8:45.下面给出例子,在这个例子中,一个名为RomanNumeral的类型被声明,然后对他实施了好几种转换.

// UserConversions\conversion.cs
using System;
struct RomanNumeral
{
    public RomanNumeral(int value)
    {
        this.value = value;
    }
    static public implicit operator RomanNumeral(int value)
    {
        return new RomanNumeral(value);
    }
    static public explicit operator int(RomanNumeral roman)
    {
        return roman.value;
    }
    static public implicit operator string(RomanNumeral roman)
    {
        return ("Conversion not yet implemented");
    }
    private int value;
}

class Test
{
    static public void Main()
    {
        RomanNumeral numeral;
        numeral = 10;
        // 显式地从numeral到int的转换
        Console.WriteLine((int)numeral);
        // 隐示地转换到string
        Console.WriteLine(numeral);
        // 显示地转换到int,然后显示地转换到short
        short s = (short)numeral;
        Console.WriteLine(s);
    }
}

这个例子子的输出是:

10
Conversion not yet implemented
10

注意009和013的operator操作符,它是一个转换操作符.

static public explicit operator int(RomanNumeral roman),记住这样的形式,它就代表了一个转换.再看第033行,因为在前面int这个转换被声明成了explicit,即显示地,所以,在使用这个转换时,必须用括号.

下面再给出一个例子,这个例子声明了两个结构,RomanNumeral和BinaryNumeral,然后在它们之间进行转换.

// UserConversions\structconversion.cs
using System;

struct RomanNumeral
{
    public RomanNumeral(int value) { this.value = value; }
    static public implicit operator RomanNumeral(int value)
    { return new RomanNumeral(value); }
    static public implicit operator
    RomanNumeral(BinaryNumeral binary)
    { return new RomanNumeral((int)binary); }
    static public explicit operator int(RomanNumeral roman)
    { return roman.value; }
    static public implicit operator string(RomanNumeral roman)
    { return ("Conversion not yet implemented"); }
    private int value;
}

struct BinaryNumeral
{
    public BinaryNumeral(int value) { this.value = value; }

    static public implicit operator BinaryNumeral(int value)
    { return new BinaryNumeral(value); }
    static public implicit operator string(BinaryNumeral binary)
    { return ("Conversion not yet implemented"); }
    static public explicit operator int(BinaryNumeral binary)
    { return (binary.value); }

    private int value;
}

class Test
{
    static public void Main()
    {
        RomanNumeral roman;
        roman = 10;
        BinaryNumeral binary;
        binary = (BinaryNumeral)(int)roman;
        roman = binary;
        Console.WriteLine((int)binary);
        Console.WriteLine(binary);
    }
}

这个例子的输出是:

10
Conversion not yet implemented

注意,第039行并没有直接由RomanNumeral转化成BinaryNumeral,因为没有直接的转换提供.所以先把RomanNumeral转换成int,再转成BinaryNumeral.其余的东西跟上面的例子是一样的(至少我这么认为),如果上面的例子理解了,下面的就好了.

C#进阶教程(十)

C#中的容器

现在我想说的是C#中的容器.这是一个非常重要的话题,因为不管你写什么样的程序,你都不能不与容器打交道.什么是容器呢(倒!).容器就是可以容纳东西的东西(再倒!),在C#和JAVA这种面向对象的编程语言中,容器就被称为可以容纳对象的东东,不是说"一切都是对象吗?"以前,我一个搞C++的程序员朋友告诉我,JAVA中的容器太好用了,比C++好用多了.而作为JAVA的后来者的C#毫无疑问,它的容器功能肯定也是很强大的.

foreach语句是遍历容器的元素的最简单的方法.我们可以用System.Collections.IEnumerator类和System.Collections.IEnumerable接口来使用C#中的容器,下面有一个例子,功能是字符串分割器.

// CollectionClasses\tokens.cs
using System;
using System.Collections;
public class Tokens : IEnumerable
{
    private string[] elements;
    Tokens(string source, char[] delimiters)
    {
        elements = source.Split(delimiters);
    }
    //引用IEnumerable接口
    public IEnumerator GetEnumerator()
    {
        return new TokenEnumerator(this);
    }
    private class TokenEnumerator : IEnumerator
    {
        private int position = -1;
        private Tokens t;

        public TokenEnumerator(Tokens t)
        {
            this.t = t;
        }
        public bool MoveNext()
        {
            if (position < t.elements.Length - 1)
            {
                position++;
                return true;
            }
            else
            {
                return false;
            }
        }
        public void Reset()
        {
            position = -1;
        }
        public object Current
        {
            get
            {
                return t.elements[position];
            }
        }
    }

    // 测试
    static void Main()
    {
        Tokens f = new Tokens("This is a well-done program.", new char[] { ' ', '-' });
        foreach (string item in f)
        {
            Console.WriteLine(item);
        }
    }
}

这个例子的输出是:

This
is
a
well
done
program.

好了,这一节就说到这了

C#进阶教程(十一)

C#中与JAVA实例比较

来看一看C#这个被称为JAVA#的新一代编程语言到底与JAVA有多大的区别.

首先我们建立一个C#的程序文件cs1.cs,然后再建立一个JAVA的源程序文件cs1.java.它们的内容分别是:

// cs1.cs:
using System;
public class cs1
{
    public static void Main()
    {
        Console.WriteLine("i am boby!");
        boby fre = new boby();
        Console.WriteLine(fre.name);
    }
}
class boby
{
    public String name = "good!";
}

// cs1.java:
import System.*;

public class cs1 {
    public static void main(String args[]) {
        System.out.println("i am boby,how are you!");
        boby fre = new boby();
        System.out.println(fre.name);
    }
}

class boby {
    String name="good!";
}

OK,让我们来运行一下这两个程序.在编译过程中我们发现,C#的速度的确比JAVA要快好多.(不是说M$的好话)其实,两个程序的输出是一样的,都是:

i am boby!
good!

有一个重要的区别就是看有一行是publc String name="boby!",而在JAVA中却是String name="boby!".

如果我们在cs1.cs中把这个public去掉,就会产生错误,因为在C#中,不用任何范围修饰符时,默认的是protect,因而不能在类外被访问.这是一个重要的区别之一.

还有就是:如果我们把cs1.cs这个C#程序中的一句public class cs1改为public class cs2,存盘,再编译,可以看到,程序正常运行.而在JAVA中,这显然不行,因为JAVA规定,在一个文件中只能有一个public类,而且这个类的名称必须与文件名一模一样.这又是一个区别,在C#中,它是以Main方法来定位入口的.如果一个程序中没有一个名为Main的方法,就会出"找不到入口的错误".不要把Main写成main哟,嘻嘻,我经常犯这样的错误.

# C#进阶教程

# C#中的属性

# C#中的库(libraries)

# C#中的版本处理

# C#中的结构(struct)

# C#中的ADO数据库访问

# C#中的用户自定义转换(User-Defined Conversions)

# C#中的容器

# C#中与JAVA实例比较

C#进阶教程

C#中的属性

C#中的库(libraries)

C#中的版本处理

C#中的结构(struct)

C#中的ADO数据库访问

C#中的用户自定义转换(User-Defined Conversions)

C#中的容器

C#中与JAVA实例比较