Steven Blogs

C#重点知识详解系列

C#重点知识详解1

作者： 发表时间： 2003-7-13 10:15:04

在微软的.NET推出后，关于C#的有关文章也相继出现，作为微软的重要的与JAVA抗衡的语言，C#具有很多优点。本文将选一些C#语言中的重要知识详细介绍，

第一章：参数

1。1 IN 参数

c#种的四种参数形式：

  • 一般参数
  • in参数
  • out参数
  • 参数数列

本章将介绍后三种的使用。

在C语言你可以通传递地址（即实参）或是DELPHI语言中通过VAR指示符传递地址参数来进行数据排序等操作，在C#语言中，是如何做的呢？"in"关键字可以帮助你。这个关键字可以通过参数传递你想返回的值。

namespace TestRefP
{
    using System;
    public class myClass
    {
        public static void RefTest(ref int iVal1)
        {
            iVal1 += 2;
        }
        public static void Main()
        {
            int i = 3; //变量需要初始化

            RefTest(ref i);
            Console.WriteLine(i);
        }
    }
}

必须注意的是变量要须先初始化。

结果：5

1。2 OUT 参数

你是否想一次返回多个值?在C++语言中这项任务基本上是不可能完成的任务。在c#中"out"关键字可以帮助你轻松完成。这个关键字可以通过参数一次返回多个值。

using System;
public class mathClass
{
    public static int TestOut(out int iVal1, out int iVal2)
    {
        iVal1 = 10;
        iVal2 = 20;
        return 0;
    }

    public static void Main()
    {
        int i, j; // 变量不需要初始化。 
        Console.WriteLine(TestOut(out i, out j));
        Console.WriteLine(i);
        Console.WriteLine(j);
    }
}

结果：

0
10
20

1。3 参数数列

参数数列能够使多个相关的参数被单个数列代表，换就话说，参数数列就是变量的长度。

using System;
class Test
{
    static void F(params int[] args)
    {
        Console.WriteLine("# 参数: {0}", args.Length);
        for (int i = 0; i < args.Length; i++)
            Console.WriteLine("\targs[{0}] = {1}", i, args[i]);
    }

    static void Main()
    {
        F();
        F(1);
        F(1, 2);
        F(1, 2, 3);
        F(new int[] { 1, 2, 3, 4 });
    }
}

以下为输出结果：

# 参数: 0 
# 参数: 1 
args[0] = 1 
# 参数: 2 
args[0] = 1 
args[1] = 2 
# 参数: 3 
args[0] = 1 
args[1] = 2 
args[2] = 3 
# 参数: 4
args[0] = 1
args[1] = 2
args[2] = 3
args[3]

C#重点知识详解2

作者： 发表时间： 2003-7-13 10:16:00

第二章 内存管理

c#内存管理提供了与java一样的自动内存管理功能,让程序员从繁重的内存管理中摆脱出来，内存管理提高了代码的质量和提高了开发效率。

c#限制了着指针的使用，免除了程序员对内存泄漏的烦恼，但是不是意味着向java程序员一样c#程序员在也不能使用指针代来的好处。微软在设计C#语言时考虑到这个问题，在一方面抛弃指针的同时，另一方面采用折衷的办法，通过一个标志来时程序引入指针。

首先我们来了解自动内存管理

public class Stack
{
    private Node first = null;
    public bool Empty
    {
        get
        {
            return (first == null);
        }
    }
    public object Pop()
    {
        if (first == null)
            throw new Exception("Can't Pop from an empty Stack.");
        else
        {
            object temp = first.Value;
            first = first.Next;
            return temp;
        }
    }
    public void Push(object o)
    {
        first = new Node(o, first);
    }
    class Node
    {
        public Node Next;
        public object Value;
        public Node(object value) : this(value, null) { }
        public Node(object value, Node next)
        {
            Next = next;
            Value = value;
        }
    }
}

程序创建了一个stack类来实现一个链，使用一个push方法创建Node节点实例和一个当不再需要Node节点时的收集器。一个节点实例不能被任何代码访问时，就被收集。例如当一个点元素被移出栈，相关的Node就被收集。

// The example
class Test
{
    static void Main()
    {
        Stack s = new Stack();
        for (int i = 0; i < 10; i++)
            s.Push(i);
        s = null;
    }
}

关于指针的引用，c#中使用unsafe 标志来代表队指针的引用。以下程序演示了指针的用法，不过由于使用指针，内存管理就不得不手工完成。

using System;
class Test
{
    unsafe static void Locations(byte[] ar)
    {
        fixed (byte* p = ar)
        {
            byte* p_elem = p;
            for (int i = 0; i < ar.Length; i++)
            {
                byte value = *p_elem;
                string addr = int.Format((int)p_elem, "X");
                Console.WriteLine("arr[{0}] at 0x{1} is {2}", i, addr, value);
                p_elem++;
            }
        }
    }

    static void Main()
    {
        byte[] arr = new byte[] { 1, 2, 3, 4, 5 };
        WriteLocations(ar);
    }
}

C#重点知识详解3

作者： 发表时间： 2003-7-13 10:16:30

第三章： 类属性

使用过RAD开发工具的一定inspector很熟悉，程序员通过它可以操作对象的属性，DELPHI中引入了PUBLISH关键字来公布对象属性受到程序员的普遍欢迎.通过存取标志来访问private成员，在c#中有两种途径揭示类的命名属性——通过域成员或者通过属性。前者是作为具有公共访问性的成员变量而被实现的；后者并不直接回应存储位置，只是通过存取标志(accessors)被访问。当你想读出或写入属性的值时，存取标志限定了被实现的语句。用于读出属性的值的存取标志记为关键字get，而要修改属性的值的读写符标志记为set。

类属性

  • 只能读 get
  • 只能写 set
  • 可读可写 set/get

请看例子：

using System;
public class Test
{
    private int m_nWrite;
    private readonly int m_nRead = 100; 
    private int m_nWriteRead;

    public int WRITEREAD
    {
        get { return m_nWriteRead; }
        set { m_nWriteRead = value; }
    }
    public int WRITE
    {
        set { m_nWrite = value; }
    }
    public int READ
    {
        get { return m_nRead; }
    }
}

class TestApp
{
    public static void Main()
    {
        Test MyTest = new Test();
        int i = MyTest.READ; //get 
        MyTest.WRITE = 250; //set 
        MyTest.WRITEREAD += 10000000; //set and get 

        Console.WriteLine("get:{0} set:{1} set/get:{2}", i, MyTest.WRITE, MyTest.WRITEREAD); 
        // 温馨提示：不能访问 MyTest.WRITE；没有get
    }
}

C#重点知识详解4加框与解框

www.chinacs.net 2001-5-21 23:36:00 中文C#技术站

导 读：C# 运行时中有两种类型：引用类型(reference)(在 C# 中用类声明)和值类型(value)（在 C# 中用结构声明）。引用和值类型在几个重要方面有所不同。值类型“感觉上”象一个数据。它包括预定义数值类型（如int、bool）以及用户定义的类型（circle、Point等）。

第四章：C# 中的加框与去框

C# 运行时中有两种类型：引用类型(reference)(在 C# 中用类声明)和值类型(value)（在 C# 中用结构声明）。引用和值类型在几个重要方面有所不同。值类型“感觉上”象一个数据。它包括预定义数值类型（如int、bool）以及用户定义的类型（circle、Point等）。如上文所述，值类型的变量是实际的值，所以在您使用变量时，通常处理的是实际的值。

1>:首先，让我们来看一看值类型(value)（在 C# 中用结构声明）。

对于任何类型的非框机构都又如下的形。

// - 
struct T_Point
{
    T x, y;
    T_Point(T x, T y)
    {
        this.x = x;
        this.y = y;
    }
}
// - 

//sample: 

class test
{
    struct Point
    {
        public int x, y;
        public Point(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }

    public static void Main()
    {
        Point p = new Point(10, 10);
        object f = p;
        p.x = 20;
        Console.Write(((Point)f).x);
        Console.Write(p.x);
    }
}

让我么来看一看最后的结果是什么？结果是10,20.在第二次指定变量后，两个独立的变量包含相同的值。
修改 p 的值不会改变 f 的值.

2>:引用类型用于所有不能用作值类型的对象。引用类型的变量指向堆中对象的实例。这意味着在将一个变量指定给另一个变量时，只是指定了引用，而不是值。

对于任何类型的框类都又如下的形。

// -- 
class T_Point
{
    T x, y;
    T_Point(T x,T y)
    {
        this.x = x;
        this.y = y;
    }
}
// 
class test
{
    class Point
    {
        public int x, y;
        public Point(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }

    public static void Main()
    {
        Point p = new Point(10, 10);
        object f = p;
        p.x = 20;
        Console.Write(((Point)f).x);
        Console.Write(p.x);
    }
}

让我么来看一看最后的结果是什么？很奇怪吗，结果是20,20.在第二次指定变量后，p 和 f 指向同一对象。这意味着修改 p 的名称也将改变 f 的名称，因为它们引用同一实例。修改类值的成员称为“变更者”，而不具有任何变更者的类称为不可变类。不可变类的存在可以使类的行为类似于值类，但不能写入为值类。

在c#语言中同时使用引用和值两种类型是很重要的。值类型轻便高效，而引用类型适用于面向对象的开发。但是，尽管我们有两了种类型，但有时我们需要的是更为简单的模型，使用单一的、能够囊括所有可能值的类型。这样一个通用基类能够调用任何值的虚函数。写入能够存储任何值的集合类。为实现这一目的，c#语言运行时采用一种方法让值类型在需要时转化为引用类型，即通过称为加框的进程。被加框的类型是通用基类，可以被各种类型的对象引用。

解框

int i = 123;
object k = i;// 将 int i 加框到对象 k 中
int j=(int)k; // 解框 k 到 value2

当赋值给 k 时，作为赋值的一部分，C# 编译器将创建足够容纳堆中 int 的引用类型包装，将值复制到该加框，然后将加框标记为实际类型，以便运行时了解加框的类型。要从加框中取值，必须使用强制类型装换来指定加框的类型（对象能够保留任何类型）。在执行过程中，运行时将检查对象变量引用的类型是否为强制类型转换中指定的类型。如果类型正确，值将从加框中复制回值类型变量。如果类型不正确，将导致异常。请注意解除加框过程中不会进行其他转换；类型必须完全匹配。

请注意以下代码：

long i = 123;
object k = i;// 将 long i 加框到对象 k 中
ulong j=(ulong)k;

#error

由于加框类型于解框类型的不同将出错。如果认为像c++语言一样下面的操作将正确那也是不对的。

long i = 123;
object k = i;
int j=(int)k;

#error

最后总结一下加框和解框。加框和解框使编写和使用具有通用对象参数的函数变得简单而直接。

C#重点知识详解5代理：一）

www.chinacs.net 2001-5-22 10:51:00 中文C#技术站 作者： wkrain www.ASPCool.com

导 读：代理实现的是象c++等语言的指针功能，不同于函数指针，代理是一种面向对象、安全类型的。

第五章：代理

代理实现的是象c++等语言的指针功能，不同于函数指针，代理是一种面向对象、安全类型的。代理事派生于公共基类（system）的一种参考类型，方法被压入一个代理中，对于实例方法被称为实例的组成实体或关于实例的方法，而静态方法，被称为类的组成实体或类方法。代理的强大功能是它可以自动的匹配方法，而不管其类型。

写一个代理包括三个步骤：写代理、实例化、调用。

代理的声明使用以下语法：

delegate void SimpleDelegate();

实例化一个代理

class Test 
{ 
    static void F() { 
        System.Console.WriteLine("hello world"); 
    } 
    static void Main() { 
        SimpleDelegate d = new SimpleDelegate(F);//将方法压入 
        d();//通过代理； 
        F();//不通过代理； 
    }
}

最后让我们调用她

void MultiCall(SimpleDelegate d, int count) { 
    for (int i = 0; i < count; i++) {
        d(); 
    } 
}

我们可以看到对于方法的调用是通过代理来完成的，调用时并不需要知道被调用她的类型。代理在我看来好比是对象要一件事她不直接地调用这个方法，而是通过一个中间人去调用她。

下面就代理的强大功能进行详细介绍：首先然我们实现一个这样的功能，考虑一下该如何用指向基类的对象调用子类的成员函数。在这里程序员是不是点怀恋指针了，不过在c#中这样的功能完全也可实现的，使用一个单独的代理我们可以完成这项功能。以下代码来自Timothy A. Vanover文章。

namespace DelegatesCS
{
    using System;
    public class Wisdom //包含代理的类 
    {
        public delegate string GiveAdvice();
        public string OfferAdvice(GiveAdvice Words)
        {
            return Words();
        }
    }
    public class Parent //基类 
    {
        public virtual string Advice()
        {
            return ("Listen to reason");
        }
        ~Parent() { }
    }
    public class Dad : Parent //子类 
    {
        public Dad() { }
        public override string Advice()
        {
            return ("Listen to your Mom");
        }
        ~Dad() { }
    }
    public class Mom : Parent //子类 
    {
        public Mom() { }
        public override string Advice()
        {
            return ("Listen to your Dad");
        }
        ~Mom() { }
    }
    public class Daughter //不继承与基类的类 
    {
        public Daughter() { }
        public string Advice()
        {
            return ("I know all there is to life");
        }
        ~Daughter() { }
    }

    public class Test
    {
        public static string CallAdvice(Parent p)//使用基类 
        {
            Wisdom parents = new Wisdom();
            Wisdom.GiveAdvice TeenageGirls = new Wisdom.GiveAdvice(p.Advice);//将Advice方法委托给TeenageGirls委托对象 
            return (parents.OfferAdvice(TeenageGirls));
        }
        public static void Main()
        {
            Dad d = new Dad();
            Mom m = new Mom();
            Daughter g = new Daughter();
            //以下两个为衍于基类的类 
            Console.WriteLine(CallAdvice(d));
            Console.WriteLine(CallAdvice(m));
            //以下为未衍于基类的类，如果调用将出错。 
            //Console.WriteLine(CallAdvice(g)); 
        }
    }
}

C#重点知识详解5代理：二 ）

www.chinacs.net 2001-5-22 10:52:00 中文C#技术站 作者： wkrain www.ASPCool.com

导 读：处理事件在c#中对比c++和vb来说更聪明，你可以写代理然后写事件处理者，事件处理者是一种定义在控件和窗体类中的重载的公共事件。

代理 二

心情好坏!!!!!!!!!!!!!!!!!!!!!
我的准女友跟我说拜拜!!!!!!!!!!!!!!!!!!!!!
再也不想搞计算机了兄弟们撤退吧!!!!!!!!!!!!!!!!!!!!
c#我没心情写了。以后再说吧!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

1〉事件

上一章讲解了有关代理的基本应用，本章将继续讲解深入代理的使用。这里我们讲解使用代理来处理事件。关于事件在另一章进行详细讲解。处理事件在c#中对比c++和vb来说更聪明，你可以写代理然后写事件处理者，事件处理者是一种定义在控件和窗体类中的重载的公共事件。我们在以下的例子中将看到代理在事件中的应用。

  1. 写代理

    我想处理鼠标单击事件和在鼠标单击左键或右键处理一些代码。写下面的代码在你的初始控件函数中。

    this.MouseDown += new System.WinForms.MouseEventHandler(this.Form_MouseDown);

  2. 写事件

    现在你可以写事件处理，你的事件的输出参数将返回窗体的鼠标事件参数的详细内容。以下时鼠标事件参数成员

    MouseEventArgs members

    Button 指示哪一个键被压，分为左、右、中、无 。
    Clicks 指示鼠标压下次数及释放状态。
    Delta 指示鼠标转动数量计数
    X 鼠标点击x坐标点
    Y 鼠标点击y坐标点

    Event Handler

    private void Form_MouseDown(object sender, System.WinForms.MouseEventArgs e)
{
    switch (e.Button)
    {
        case MouseButtons.Left:
            MessageBox.Show(this, "Left Button Click");
            break;
        case MouseButtons.Right:
            MessageBox.Show(this, "Right Button Click");
            break;
        case MouseButtons.Middle:
            break;
        default:
            break;
    }
}

在你的WinForm中测试你的程序，你会看到通过代理事件被关联了。

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

class I
{
    public I() { }
    ~I() { }
    public void IDoLoveYou()
    { System.Console.WriteLine("I do love You"); }
    public void why() { System.Console.WriteLine("why?"); }
}

class HER
{
    public HER() { }
    ~HER() { }
    public void IDo()
    { System.Console.WriteLine("..............."); }
    public void slient() { System.Console.WriteLine("........."); }
}

class TELEPHONE
{
    public delegate void heartchat();
    public TELEPHONE() { }
    ~TELEPHONE() { }
    public void hello() { System.Console.WriteLine("yesterday night,i telephone to my girlfriend"); }
}

class chat
{
    static void Main()
    {
        I i = new I();
        HER her = new HER();
        TELEPHONE telephone = new TELEPHONE();
        telephone.hello();

        TELEPHONE.heartchat tell = new TELEPHONE.heartchat(i.IDoLoveYou);
        tell();

        TELEPHONE.heartchat answer = new TELEPHONE.heartchat(her.IDo);
        answer();

        TELEPHONE.heartchat ask = new TELEPHONE.heartchat(i.why);
        ask();

        TELEPHONE.heartchat noanswer = new TELEPHONE.heartchat(her.slient);
        noanswer();
    }
}
Contributors: FHL