C#中的数组，克隆，委托，事件等

数组

namespace 数组
{
    /*不允许在数组类型区域中放数组纬度长度
     long[3,2,6]SecondArray为编译错误类型
     int[,,]=new int[3,2,6];的数组长度是3*2*6=36；*/
    class Program
    {
        static void Main(string[] args)
        {
            int[] intArr = new int[] { 10, 20, 30, 40 };//初始化数组
            int[, ,] intArray = new int[4, 3, 2] //初始化数组
            {
            {{8,6},{5,2},{12,9}},
            {{6,4},{13,9},{18,14}},
            {{7,2},{1,13},{9,3}},
            {{4,6},{3,2},{23,8}}
            };
            int[][,] Arr = new int[3][,];//声明并实例化三个二维数组的交错数组
            Arr [0]=new int[,]{{10,20},{100,200}};
            Arr [1]=new int[,]{{30,40,50},{300,400,500}};
            Arr [2]=new int[,]{{60,70,80,90},{600,700,800,900}};
            int[] intArr1 = new int[15];//声明一维数组
            intArr1[2] = 10;//向第三个元素写入值
            int var1 = intArr1[2];//从第二个元素读数
            int[,]intArr2=new int[5,10];//声明二维数组
            intArr2[2, 3] = 7;//向数组写入值
            int var2=intArr2 [2,3];//向数组读取值
            int[] myIntArray;//声明数组
            myIntArray = new int[4];//实例化数组
            for (int i = 0; i < 4; i++)//读取并输出每个数组的元素值
                myIntArray[i] = i * 10;
            for (int i = 0; i < 4; i++)
                Console.WriteLine("value of element {0}={1}",i,myIntArray [i]);
        }
    }
}

clone方法在数组中的运用

namespace clone方法
{
    class Program
    {
        /*clone方法为数组进行浅复制。也就是说，它只
         创建了数组本身的克隆。如果是引用类型的数组
         ，它不会复制元素的引用的对象。对值类型的数组和
         引用类型的数组而言，有不同的结果。
         克隆值类型数组会产生两个独立数组。
         克隆引用类型数组会产生指向相同对象的两个数组。
         以下给出一个值类型的数组克隆，他产生两个独立数组*/
        static void Main(string[] args)
        {
            int[] intArr1 = { 1, 2, 3 };
            int[] intArr2 = (int[])intArr1.Clone();
            intArr2[0] = 100; intArr2[1] = 200; intArr2[2] = 300;
        }
    }
}

 

foreach语句与多维数组

namespace foreach语句与多维数组
{
    class Program
    {
        static void Main(string[] args)
        {
            int total = 0;
            int[,] arr1 = { { 10, 11 }, { 12, 13 } };
            foreach (var element in arr1)
            {
                total += element;
                Console.WriteLine("Element:{0},Current Total:{1}",element ,total );
            }
        }
    }
}

委托

namespace 委托
{
    delegate void PrintFunction();//声明委托
    /*委托和类一样，是一种用户自定义的类型。
     但类表示的是数据集合，而委托保存的是一个和多个方法。
     委托既可以增加方法，也可以移除方法，例如
     MyDel delVar=inst.MyM1;
     * delVar+=SCI.m3;
     * delVar+=X.Act;
     * delVar-=SCI.m3;
     */
    class Test
    {
        public void Print1()
        {
            Console.WriteLine("Print1---instance");
        }
        public static void Print2()
        {
            Console.WriteLine("Print2--static");
        }
   }
    class Program
    {
        static void Main(string[] args)
        {
            Test t = new Test();//创建一个测试类实例
            PrintFunction pf;//创建一个空委托
            pf = t.Print1;//实例化并初始化该委托
            //给委托增加3个另外的方法
            pf += Test.Print2;
            pf += t.Print1;
            pf += Test.Print2;
            //现在，委托含有四个方法
            if (null != pf)//确认委托有方法
                pf();//调用方法
            else
                Console.WriteLine("Delegate is empty");
        }
    }
}

调用带返回值的委托

namespace 调用带返回值的委托
{
    class Program
    {
        delegate int MyDel();
        class MyClass
        {
            int IntValue = 5;
            public int Add1()//声明有返回值的方法
            {
                IntValue += 2; return IntValue;
            }
            public int Add2()
            {
                IntValue += 3; return IntValue;
            }
        }
        static void Main(string[] args)
        {
            MyClass mc = new MyClass();
            MyDel mDel = mc.Add1;//创建并初始化委托。
            mDel += mc.Add2;//添加方法
            mDel += mc.Add1;//添加方法
            Console.WriteLine("Value:{0}",mDel ());//调用委托，并使用返回值
        }
    }
}

调用带引用参数的委托

namespace 调用带引用参数的委托
{
    delegate void MyDel(ref int X);
    /*如果委托有引用参数，在调用委托列表中的
     * 下一个方法时，参数的新值
     会传给下一个方法*/
    class MyClass
    {
        public void Add2(ref int X)
        {
            X += 2;
        }
        public void Add3(ref int X)
        {
            X += 3;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyClass mc = new MyClass();
            MyDel mDel = mc.Add2;
            mDel += mc.Add3;
            mDel += mc.Add2;//参数发生了三次改变，最终为12
            int X = 5;
            mDel(ref X );
            Console.WriteLine("value:{0}",X);
            Console.ReadKey();
        }
    }
}

事件

namespace 事件
{
    /*事件和委托相似
事件的很多方面和委托相似。其实，
     * 事件就好像被简化的针对特殊用途的委托。
注册到事件上的方法会在事件触发时被调用。
    事件有私有委托
    委托和事件的行为之所以相似，是有充分理由的
     * 。事件包含了一个私有的委托。有关事件的私
     * 有委托需要了解的重要事项如下：
    事件提供了对它的私有控制委托的结构化访问。
    与委托中的其他操作不一样，对于事件我们只
     * 可以添加、删除或调用事件处理程序。
事件被触发时，它调用委托来依次调用调用列
     * 表中的方法。 */
    public class MyTimerClass
    {
        public event EventHandler Elapsed;//事件声明
        private void OnOneSecond(object source, EventArgs args)
        {
            if (Elapsed != null)//确认有方法可执行
                Elapsed(source, args);
        }
        //缺少代码
    }
    class ClassA
    {
        public void TimerHandlerA(object source, EventArgs args)//事件处理程序
        {
            Console.WriteLine("Class A handler called");
        }
    }
    class ClassB
    {
        public static void TimeHandlerB(object source, EventArgs args)
            //静态的事件处理程序
        {
            Console.WriteLine("Class B handler called");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            ClassA ca = new ClassA();//创建类对象
            MyTimerClass mc = new MyTimerClass();//创建计时器对象
            mc.Elapsed += ca.TimerHandlerA;//添加处理程序A（实例）
            mc.Elapsed += ClassB.TimeHandlerB;//添加处理程序B（静态）
            Thread.Sleep(2250);
        }
    }
}