为文件生成指纹，可以比较文件是否篡改。
C# 计算文件的MD5值：http://www.cnblogs.com/anjou/archive/2008/08/05/1261290.html

参考：http://www.cnblogs.com/yuanbao/archive/2007/09/25/905322.html

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;

namespace BallotAiying2
{
    class UnCodebase
    {
        public Bitmap bmpobj;
        public UnCodebase(Bitmap pic)
        {
            bmpobj = new Bitmap(pic);    //转换为Format32bppRgb
        }

        /// <summary>
        /// 根据RGB，计算灰度值
        /// </summary>
        /// <param name="posClr">Color值</param>
        /// <returns>灰度值，整型</returns>
        private int GetGrayNumColor(System.Drawing.Color posClr)
        {
            return (posClr.R * 19595 + posClr.G * 38469 + posClr.B * 7472) >> 16;
        }

        /// <summary>
        /// 灰度转换,逐点方式
        /// </summary>
        public void GrayByPixels()
        {
            for (int i = 0; i < bmpobj.Height; i++)
            {
                for (int j = 0; j < bmpobj.Width; j++)
                {
                    int tmpValue = GetGrayNumColor(bmpobj.GetPixel(j, i));
                    bmpobj.SetPixel(j, i, Color.FromArgb(tmpValue, tmpValue, tmpValue));
                }
            }
        }

        /// <summary>
        /// 去图形边框
        /// </summary>
        /// <param name="borderWidth"></param>
        public void ClearPicBorder(int borderWidth)
        {
            for (int i = 0; i < bmpobj.Height; i++)
            {
                for (int j = 0; j < bmpobj.Width; j++)
                {
                    if (i < borderWidth || j < borderWidth || j > bmpobj.Width - 1 - borderWidth || i > bmpobj.Height - 1 - borderWidth)
                        bmpobj.SetPixel(j, i, Color.FromArgb(255, 255, 255));
                }
            }
        }

        /// <summary>
        /// 灰度转换,逐行方式
        /// </summary>
        public void GrayByLine()
        {
            Rectangle rec = new Rectangle(0, 0, bmpobj.Width, bmpobj.Height);
            BitmapData bmpData = bmpobj.LockBits(rec, ImageLockMode.ReadWrite, bmpobj.PixelFormat);// PixelFormat.Format32bppPArgb);
            //    bmpData.PixelFormat = PixelFormat.Format24bppRgb;
            IntPtr scan0 = bmpData.Scan0;
            int len = bmpobj.Width * bmpobj.Height;
            int[] pixels = new int[len];
            Marshal.Copy(scan0, pixels, 0, len);

            //对图片进行处理
            int GrayValue = 0;
            for (int i = 0; i < len; i++)
            {
                GrayValue = GetGrayNumColor(Color.FromArgb(pixels[i]));
                pixels[i] = (byte)(Color.FromArgb(GrayValue, GrayValue, GrayValue)).ToArgb();      //Color转byte
            }

            bmpobj.UnlockBits(bmpData);
        }

        /// <summary>
        /// 得到有效图形并调整为可平均分割的大小
        /// </summary>
        /// <param name="dgGrayValue">灰度背景分界值</param>
        /// <param name="CharsCount">有效字符数</param>
        /// <returns></returns>
        public void GetPicValidByValue(int dgGrayValue, int CharsCount)
        {
            int posx1 = bmpobj.Width; int posy1 = bmpobj.Height;
            int posx2 = 0; int posy2 = 0;
            for (int i = 0; i < bmpobj.Height; i++)      //找有效区
            {
                for (int j = 0; j < bmpobj.Width; j++)
                {
                    int pixelValue = bmpobj.GetPixel(j, i).R;
                    if (pixelValue < dgGrayValue)     //根据灰度值
                    {
                        if (posx1 > j) posx1 = j;
                        if (posy1 > i) posy1 = i;

                        if (posx2 < j) posx2 = j;
                        if (posy2 < i) posy2 = i;
                    };
                };
            };
            // 确保能整除
            int Span = CharsCount - (posx2 - posx1 + 1) % CharsCount;   //可整除的差额数
            if (Span < CharsCount)
            {
                int leftSpan = Span / 2;    //分配到左边的空列 ，如span为单数,则右边比左边大1
                if (posx1 > leftSpan)
                    posx1 = posx1 - leftSpan;
                if (posx2 + Span - leftSpan < bmpobj.Width)
                    posx2 = posx2 + Span - leftSpan;
            }
            //复制新图
            Rectangle cloneRect = new Rectangle(posx1, posy1, posx2 - posx1 + 1, posy2 - posy1 + 1);
            bmpobj = bmpobj.Clone(cloneRect, bmpobj.PixelFormat);
        }
        
        /// <summary>
        /// 得到有效图形,图形为类变量
        /// </summary>
        /// <param name="dgGrayValue">灰度背景分界值</param>
        /// <param name="CharsCount">有效字符数</param>
        /// <returns></returns>
        public void GetPicValidByValue(int dgGrayValue)
        {
            int posx1 = bmpobj.Width; int posy1 = bmpobj.Height;
            int posx2 = 0; int posy2 = 0;
            for (int i = 0; i < bmpobj.Height; i++)      //找有效区
            {
                for (int j = 0; j < bmpobj.Width; j++)
                {
                    int pixelValue = bmpobj.GetPixel(j, i).R;
                    if (pixelValue < dgGrayValue)     //根据灰度值
                    {
                        if (posx1 > j) posx1 = j;
                        if (posy1 > i) posy1 = i;

                        if (posx2 < j) posx2 = j;
                        if (posy2 < i) posy2 = i;
                    };
                };
            };
            //复制新图
            Rectangle cloneRect = new Rectangle(posx1, posy1, posx2 - posx1 + 1, posy2 - posy1 + 1);
            bmpobj = bmpobj.Clone(cloneRect, bmpobj.PixelFormat);
        }

        /// <summary>
        /// 得到有效图形,图形由外面传入
        /// </summary>
        /// <param name="dgGrayValue">灰度背景分界值</param>
        /// <param name="CharsCount">有效字符数</param>
        /// <returns></returns>
        public Bitmap GetPicValidByValue(Bitmap singlepic, int dgGrayValue)
        {
            int posx1 = singlepic.Width; int posy1 = singlepic.Height;
            int posx2 = 0; int posy2 = 0;
            for (int i = 0; i < singlepic.Height; i++)      //找有效区
            {
                for (int j = 0; j < singlepic.Width; j++)
                {
                    int pixelValue = singlepic.GetPixel(j, i).R;
                    if (pixelValue < dgGrayValue)     //根据灰度值
                    {
                        if (posx1 > j) posx1 = j;
                        if (posy1 > i) posy1 = i;

                        if (posx2 < j) posx2 = j;
                        if (posy2 < i) posy2 = i;
                    };
                };
            };
            //复制新图
            Rectangle cloneRect = new Rectangle(posx1, posy1, posx2 - posx1 + 1, posy2 - posy1 + 1);
            return singlepic.Clone(cloneRect, singlepic.PixelFormat);
        }
        
        /// <summary>
        /// 平均分割图片
        /// </summary>
        /// <param name="RowNum">水平上分割数</param>
        /// <param name="ColNum">垂直上分割数</param>
        /// <returns>分割好的图片数组</returns>
        public Bitmap [] GetSplitPics(int RowNum,int ColNum)
        {
            if (RowNum == 0 || ColNum == 0)
                return null;
            int singW = bmpobj.Width / RowNum;
            int singH = bmpobj.Height / ColNum;
            Bitmap [] PicArray=new Bitmap[RowNum*ColNum];

            Rectangle cloneRect;
            for (int i = 0; i < ColNum; i++)      //找有效区
            {
                for (int j = 0; j < RowNum; j++)
                {
                    cloneRect = new Rectangle(j*singW, i*singH, singW , singH);
                    PicArray[i*RowNum+j]=bmpobj.Clone(cloneRect, bmpobj.PixelFormat);//复制小块图
                }
            }
            return PicArray;
        }

        /// <summary>
        /// 返回灰度图片的点阵描述字串，1表示灰点，0表示背景
        /// </summary>
        /// <param name="singlepic">灰度图</param>
        /// <param name="dgGrayValue">背前景灰色界限</param>
        /// <returns></returns>
        public string GetSingleBmpCode(Bitmap singlepic, int dgGrayValue)
        {
            Color piexl;
            string code = "";
            for (int posy = 0; posy < singlepic.Height; posy++)
                for (int posx = 0; posx < singlepic.Width; posx++)
                {
                    piexl = singlepic.GetPixel(posx, posy);
                    if (piexl.R < dgGrayValue)    // Color.Black )
                        code = code + "1";
                    else
                        code = code + "0";
                }
            return code;
        }
    }
}

Random ra = new Random() ;
Console.WriteLine(ra.Next());
Console.WriteLine(ra.Next(10))
生成规则

* 获取电脑启动以来的时间，与一固定值进行连续减法操作（0x9a4ec86 – Math.Abs(Environment.TickCount)），所得结果均匀的存放到一56位数组内
* 每次取时，第一次取SeedArray[0] – SeedArray[21]的值，然后顺移,故第二次取SeedArray[1] – SeedArray[22]的值….
* 因取的启动时间的间隔最小单位是0.5秒，故在这0.5秒内，若连续构造Random,产生随机数，因启动时间相同，故每次的SeedArray[0] – SeedArray[21]的值也会相同。为避免这种情况，应构造一个Random,连续用Next()取值，这样会递邓56位数组中的下一次相减数。

注：因产生数组的方法是固定的，传入同一启动时间，所得数组值也是固定的，故知C#随机数是伪随即数，这也符合计算机程序的特性的确定性，即：即对于相同的输入只能得出相同的输出。

生成一系列数字：0x9a4ec86 – Math.Abs(Environment.TickCount)

C#语法拾遗

1，using;

* using 命名空间名字;
* using 别名 = 包括详细命名空间信息的具体类型，以区别两个不同命名空间有相同的类名。
* using定义范围：即时释放资源，在范围结束时即时释放资源，
* 如： using (StreamWriter w = File.AppendText(“c:\\temp.txt”))
{
Log(context, w);
w.Close();
}

2，@符号的使用

* 将转义符当成一般字符使用：string s = @”c:\a.txt”;
* 忽略换行：string s =string s = @”sdf
sdf
sfsdf”;

3,预处理命令

* #warning 和#error : 若编译器遇到，则产生警告或错误信息，以提示开发者，而#error会直接退出编译
* 如：#warning : 测试使用，正式发布时请去掉下句代码
* #region description #endregion 将一段代码标记为一个指定名称的代码块，可直接折叠，便于阅读

4，对于引用类型，==类似于比较文件夹的路径是否相同，而equals()比较的是文件夹中的内容是否一样。注：对于string,==比较的是值。
原理：==比较的是栈，值变量存储在栈中，而引用类型地址也是存储在栈中。而equals比较的是堆，而引用类型的值就存在于堆中。
引用类型对应有多个字段，故地址存放于栈中，多个字段存放于堆中。

5，const是编译时常数，须在最开始赋初值，默认是static, 而readonly是运行是常数，默认不是static.

* const是编译时常数，故不能修饰引用类型，因为引用类型的构造要在运行时完成。不过string与null除外。
* 注：数组也是引用类型，同样不可用const修饰。
* const默认是static,故不可在非静态方法中修饰局部变量。

6，sealed：不可继承，断子绝孙。virtual与override进行覆盖。

7，变量与属性的区别：属性是对字段的一种封装，可以控制读写，体现了面向对象的封装性。

8，class与struct的区别：class是引用类型，内存分配于堆上，而struct是引用类型，内存分配于线程的栈上。

 public static void WriteLog(string context)
        {
            using (StreamWriter w = File.AppendText("c:\\temp.txt"))
            {
                Log(context, w);
                w.Close();
            }


        }

        public static void Log(String logMessage, TextWriter w)
        {
            w.Write("\r\nLog Entry : ");
            w.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(),
                DateTime.Now.ToLongDateString());
            w.WriteLine("  :");
            w.WriteLine("  :{0}", logMessage);
            w.WriteLine("-------------------------------");
            // Update the underlying file.
            w.Flush();
        }

    Thread mouseThread = new Thread(new ThreadStart(Run));//两个线程共同做一件事情
            mouseThread.Name = "mouneClick";
            mouseThread.Start();

       public void Run()
    {
        int dx = 40;
        int dy = 40;
        while (true)
        {
            if (IsMouseStart)
            {
                //WriteLog(IsMouseStart.ToString());
                mouse_event((int)(MouseEventFlags.LeftDown | MouseEventFlags.Absolute), 0, 0, 0, IntPtr.Zero);
                mouse_event((int)(MouseEventFlags.LeftUp | MouseEventFlags.Absolute), 0, 0, 0, IntPtr.Zero);
                Thread.Sleep(100);

            }
           
        }
    }

//在最后要去掉线程
 if (mouseThread != null)
            {
                mouseThread.Abort();
            }

1，//调用Type类的静态方法GetType，并将Type对象引用返回给tp变量
Type tp = Type.GetType(“ClassA”, false, false);
//tp对象调用GetMethods方法，返回对象中所有公共方法数组，并赋值给ma数组
MethodInfo[] ma = tp.GetMethods();
Console.WriteLine(“\n\t=================ClassA类所含的方法=================”);
//遍历ma数组中的所有MethodInfo类型子项
foreach (MethodInfo s in ma){
//依次输出MethodInfo类型子项的属性值
Console.WriteLine(“\n\t【{0}方法】”, s.Name);
Console.Write(“方法所属类名称：【{0}】”, s.DeclaringType);
Console.WriteLine(“\t方法是否为构造函数：【{0}】”, s.IsConstructor);
Console.Write(“方法是否为public成员：【{0}】”, s.IsPublic);
Console.WriteLine(“\t方法是否为internal成员：【{0}】”, s.IsAssembly);
Console.Write(“方法是否为protected成员：【{0}】”, s.IsFamily);
Console.WriteLine(“\t方法是否为private成员：【{0}】”, s.IsPrivate);
Console.Write(“方法是否为泛型方法：【{0}】”, s.IsGenericMethod);
Console.WriteLine(“\t方法是否为静态方法：【{0}】”, s.IsStatic);
Console.Write(“方法是否为virtual方法：【{0}】”, s.IsVirtual);
Console.WriteLine(“\t方法返回类型为：【{0}】”, s.ReturnType);

//调用s的GetParameters方法，返回ParameterInfo类型数组//遍历数组的ParameterInfo类型子项
foreach (ParameterInfo pms in s.GetParameters()){//输出ParameterInfo类型子项的属性
Console.WriteLine(“\n\t——【{0}参数】——“, pms.Name);
Console.Write(“参数类型：【{0}】”, pms.ParameterType);
Console.WriteLine(“\t参数位置：【{0}】”, pms.Position);
}
}??

注：当跨项目引用dll时要采用如下形式：
Assembly asmb = Assembly.LoadFrom(“EnterpriseServerBase.dll”) ;
Type supType = asmb.GetType(“EnterpriseServerBase.DataAccess.IDBAccesser”) ;
?
或者在当前项目已经引用目标dll的情况下采用：
Type supType = typeof(BNameSpace.SubSpace.Class);

2，得到所有属性
? Type type = typeof(T);???? System.Reflection.PropertyInfo[] properties = type.GetProperties();
//可用 properties[i].SetValue(t, dr[properties[i].Name], null); 赋值

3，创建对象实例
?T t = Activator.CreateInstance<T>();??
或者：Type type = typeof(T);????? T t = Activator.CreateInstance(type);

4,调用方法：
Assembly asmb = Assembly.LoadFrom(“LvShouSecurity.dll”);
//Type supType = asmb.GetType(“LvShouSecurity.SecurityMan”);
MethodInfo m = asmb.GetType(“LvShouSecurity.SecurityMan”).GetMethod(“Encrypto”);
Object ret = m.Invoke(null, new object[]{“hello”});

1，遍历
C#遍历指定文件夹中的所有文件
DirectoryInfo TheFolder=new DirectoryInfo(folderFullName);
//遍历文件夹
foreach(DirectoryInfo NextFolder in TheFolder.GetDirectories())
this.listBox1.Items.Add(NextFolder.Name);
//遍历文件
foreach(FileInfo NextFile in TheFolder.GetFiles()) //foreach(FileInfo NextFile in TheFolder.GetFiles(“*.cs”)) 找类文件
this.listBox2.Items.Add(NextFile.Name);

FileInfo.Exists：获取指定文件是否存在；
FileInfo.Name，FileInfo.Extensioin：获取文件的名称和扩展名；
FileInfo.FullName：获取文件的全限定名称（完整路径）；
FileInfo.Directory：获取文件所在目录，返回类型为DirectoryInfo；
FileInfo.DirectoryName：获取文件所在目录的路径（完整路径）；
FileInfo.Length：获取文件的大小（字节数）；
FileInfo.IsReadOnly：获取文件是否只读；
FileInfo.Attributes：获取或设置指定文件的属性，返回类型为FileAttributes枚举，可以是多个值的组合
FileInfo.CreationTime、FileInfo.LastAccessTime、FileInfo.LastWriteTime：分别用于获取文件的创建时间、访问时间、修改时间；

2，读写

 //创建并写入(将覆盖已有文件)
      if (!File.Exists(path))
      {          
         using (StreamWriter sw = File.CreateText(path))
         {
            sw.WriteLine("Hello");
         } 
      }
      //读取文件
      using (StreamReader sr = File.OpenText(path)) 
      {
        string s = "";
        while ((s = sr.ReadLine()) != null) 
        {
           Console.WriteLine(s);
             if (s.IndexOf("aaa") != -1)
                {
                   //.... 搜索文件是否包含某关键字
                }
        }
     }
     //删除/拷贝
     try 
     {
        File.Delete(path);
        File.Copy(path, @"f:\tt.txt");
     } 
     catch (Exception e) 
     {
        Console.WriteLine("The process failed: {0}", e.ToString());
     }
   }


//查找关键字是否存在于指定目标所有文件中的任一
    private void SearchKeyWordListInDirectroyFiles(string DirectoryPath, IList KeyWordsList,string filePattern ) {
        //KeyWordsList,关键字集合，filePattern指定搜索哪些文件，notFile指定不搜索哪个文件
        try
        {
            DirectoryInfo di = new DirectoryInfo(DirectoryPath);
            foreach (FileInfo NextFile in di.GetFiles(filePattern))
            {
                using (StreamReader sr = NextFile.OpenText())
                    {
                        string s = "";
                        while ((s = sr.ReadLine()) != null)
                        {
                            for (int i = 0; i < KeyWordsList.Count; i++)
                            {
                                if (s.IndexOf(KeyWordsList[i].ToString()) != -1)
                                {
                                    KeyWordsList.RemoveAt(i);
                                }
                            }
                        }
                    }
                
            }

            foreach (DirectoryInfo NextFolder in di.GetDirectories())
            {
                SearchKeyWordListInDirectroyFiles(NextFolder.FullName, KeyWordsList, filePattern);
            }

        }
        catch (Exception e) { 
            
        }
    }

1,基本内容是：可以在 Console.WriteLine（以及 String.Format，它被 Console.WriteLine 调用）中的格式字符串内的括号中放入非索引数字的内容。
格式规范的完整形式如下：
{index [, width][:formatstring]}
其中，index 是此格式程序引用的格式字符串之后的参数，从零开始计数；width（如果有的话）是要设置格式的字段的宽度（以空格计）。width 取正数表示结果右对齐，取负数则意味着数字在字段中左对齐。formatstring 是可选项，其中包含有关设置类型格式的格式说明.
2,数字格式
请注意，数字的格式是区分语言的：分隔符以及分隔符之间的空格，还有货币符号，都是由语言决定的 ? 默认情况下，是您计算机上的默认语言。默认语言与执行线程相关，可以通过 Thread.CurrentThread.CurrentCulture 了解和设置语言。有几种方法，可以不必仅为一种给定的格式操作就立即更改语言。
内置类型的字母格式
有一种格式命令以单个字母开头，表示下列设置：
G?常规，E 或 F 中较短的
F?浮点数，常规表示法
E?用 E 表示法表示的浮点数（其中，E 代表 10 的次幂）
N?带有分隔符的浮点数（在美国为逗号）? 如:N4 代表取四位小数
C?货币，带有货币符号和分隔符（在美国为逗号）
D?十进制数，仅用于整型
X?十六进制数，仅用于整型

double pi = Math.PI;
double p0 = pi * 10000;
int i = 123;

Console.WriteLine(“pi, G4?? {0, 25:G4}”, pi); //???????????????????? 3.142

Console.WriteLine(“pi, G4?? {0, 25:G4}”, pi); //???????????????????? 3.142

Console.WriteLine(“i,? D7?? {0, 25:D7}”, i ); //?????????????????? 0000123

1.字符串拼接：

string msg = ” Hello, ” + thisUser.Name + “.Today is ” + DateTime.Now.ToString( ));

更有效率的写法：

string msg = string .Format ( ” Hello, {0}. Today is {1}” , thisUser.Name, DateTime.Now.ToString( ));

2.大量数据拼接则使用StringBuilder。

3.字符串的比较：

（1）判断是否是空串

if ( str != ” ” )与if ( str == ” ” )

更有效率的写法：

if ( str.Length != 0 )与if ( str.Length ==0 )

有效率且可读性更好的写法：

if ( str != string .Empty )与if( str .Equals( string .Empty)

比较是否是NULL或空字串用：string.IsNullOrEmpty

（2） 字符串之间的比较

?if (string.Compare(s,b,true) ==0)?? s<b 小于0，s==b ,0 s>b 大于0 这种比较用true指定忽略大小写，不用再toUpper()之类

4,截取最后一位之前的数据TrimEnd
string s = “1,2,3,4,5,”;
Console.Write(s.ToString().TrimStart(‘,’));
Console.Read();

5,分割字符串:
1）单个字符：string[] args = str.split(‘,’);
2)字符串切分：string[] arrays = Regex.Splits,”##”,RegexOptions.IgnoreCase); //System.Text.RegularExpressions;

6,转换：

int.Parse:用法，将抛出异常

Convert.ToInt32(s): 当s为空时不抛出异常，当为string.Empty或字符串时”sdfsd”则抛出异常

int.TryParse(s,out i) 不抛出异常，若有异常，返回false,

//性能：int.TryParse > int.Parse > Convert.ToInt32

7，求两个整数的商及余数

int yes; double s = Math.DivRem(5,0,out yes);

8, 返回>=指定数字的最小整数 Math.Ceiling(0.5)

1，资料

2，特殊字母
（1）
. 匹配除了换行符（\n）以外的任意一个字符。要匹配小数点本身，请使用 “\.”

^ 匹配输入字符串的开始位置。要匹配 “^” 字符本身，请使用 “\^”

$ 匹配输入字符串的结尾位置。要匹配 “$” 字符本身，请使用 “\$”

( ) 标记一个子表达式的开始和结束位置。要匹配小括号，请使用 “\(” 和 “\)”

[ ] 用来自定义能够匹配 ‘多种字符’ 的表达式。要匹配中括号，请使用 “\[” 和 “\]”

{ } 修饰匹配次数的符号。要匹配大括号，请使用 “\{” 和 “\}”

? 修饰匹配次数为 0 次或 1 次。要匹配 “?” 字符本身，请使用 “\?”

+ 修饰匹配次数为至少 1 次。要匹配 “+” 字符本身，请使用 “\+”

* 修饰匹配次数为 0 次或任意次。要匹配 “*” 字符本身，请使用 “\*”

| 左右两边表达式之间 “或” 关系。匹配 “|” 本身，请使用 “\|”

（2）“\”
\w 可以匹配任何一个字母或者数字或者下划线

\W W大写，可以匹配任何一个字母或者数字或者下划线以外的字符

\s 可以匹配空格、制表符、换页符等空白字符的其中任意一个

\S S大写，可以匹配任何一个空白字符以外的字符

\d 可以匹配任何一个 0~9 数字字符

\D D大写，可以匹配任何一个非数字字符

(3) {}
{n} 表达式固定重复n次，比如：”\w{2}” 相当于 “\w\w”

{m, n} 表达式尽可能重复n次，至少重复m次：”ba{1,3}”可以匹配 “ba”或”baa”或”baaa”

{m, } 表达式尽可能的多匹配，至少重复m次：”\w\d{2,}”可以匹配 “a12”,”x456″…

19, C#的数组

C#的数组都是对象，继承自Array类，故都拥有属性及方法，如Rank,数组的维数，equals等。而java中的数组只有一个length属性。 Array intArray1 = Array.CreateInstance(typeof(int), 5); 等同于：int[] intArray1 = new int[5]; int[] intArray2 = (int[])intArray1;

除一般数组外，C#支持不规则数组如： int[][] jagged = new int[3][];
jagged[0] = new int[2] { 1, 2 };
jagged[1] = new int[6] { 3, 4, 5, 6, 7, 8 };
jagged[2] = new int[3] { 9, 10, 11 };
20，操作符：
is 判断左是否是右类型
as 类型转换

21，运算符重载
Vector x = new Vector ( 1,1 ); Vector y = new Vector (2,2)
Vector z = x + y // 或者用point z = x.add( y ); 但显然前者更直观。

实现：方法为public , static 运算符前加operator: public static Vector operator + (Vector lhs, Vector rhs)
{
Vector result = new Vector(lhs);
result.x += rhs.x;
result.y += rhs.y;
result.z += rhs.z;
return result;
} //此时 x + y会执行此方法，实际上，当出现运算符时，c#都先在左，右操作数的方法找是否具有重载此操作符的方法，且此方法参数与给出的操作符左右操作数相同，若相同，执行之。
x = 2 * x public static Vector operator * (int lhs, Vector rhs)
{
Vector result = new Vector(lhs);
result.x = 2 * rhs.x;
result.y += 2 * rhs.y;
return result;
} 若是x = x * 2 则不会执行，因为形参不匹配，此时需要再定义一个 public static Vector operator * (Vector rhs，int lhs )
{
return lhs * rhs;
}
能重载的运算符有： +, *, /, -, %
+, -, ++, —
&, |, ^, <<, >>
!, ~true, false
==, !=,>=, <=>, <, //没有 = 此外： true false;== ！=； > <; >= <=; 重载时重载一个，另一个必须重载且返回结果要为boolean ,在重载了 + 之后相当于重载了+= ，+=不能显式重载 22, 委托 --- 类是数据，方法也可当做数据，也能被赋值。 using System; public partial class AA { public delegate string show( string name ); public string list( string name ) { return "hdello world " + name; } public static void Main(){ AA a = new AA(); //show _show = new show(a.list); show _show = a.list; Console.Write(_show("123")); Console.Write(a.go( _show )); } public string go( show _show ){ return _show("345"); } } 委托可当做类来看待，即委托方法就是一个类，可用new来创建，同js,不同js的方法当成类还可以有属性。 委托不要方法体, 前要加关键字 delegate 调用：委托方法 + 括号， 直接用，不用创建对象引用。 方法当做变量来看，在赋值，传参时当然不要用(), 只有在调用时才用() 委托还可以进行 + , - 操作，一次运行多个方法，但方法返回值最好为void,否则后者会将前者覆盖掉 using System; public partial class AA { public delegate void show( string name ); public void list( string name ) { Console.Write("hdello world " + name); } public void list1( string name ) { Console.Write( "list1 world " + name); } public static void Main(){ AA a = new AA(); show _show = a.list; _show += a.list1; _show("123"); } } 23，集合 Hashtable ht = new Hashtable(); foreach (DictionaryEntry de in myHT) { Console.Write( dr.key + dr.value ); } 取值： ht["name"] //注意，因为HashTable是按散列排序，不是数据那种位置类的，故它的输出与add的位置不同。 IList接口 List 提供范型 List list = new List(); list[0]
java中接口与范型都是List

1，编译类文件：csc Class1.cs ? ? ? ?因编译后直接生成.exe文件，故可直接点击运行??? csc:开始–2008 – tools – 命令行提示

?2，C#的命名空间类似于java中的包的概念

?3，静态成员只能通过类名来访问，不能通过对象实例来访问

?4， 常量定义用const,而不是java中的final,并且const自动为static类型,因java的常量支持构造器初始化故不是自动static类型
?? ? ? 同时常量定义还可以用readonly,它同final一样，在运行时才确定其值，故它的值可以在构造函数中给值，即然如此，那么它就不再自动为
?? ? ? static类型
?? ? ? var : 代表任意类型，在方法内部使用如：var i = 10
?
?5，值类型

• ??java中的基型在c#称为值类型，如int,并且每个值类型实际上是一个struct,也拥有自己的方法！！！ ?
• ??值类型分为有符号数与无符号数如int?( – 2 31 :2 31 – 1) ?而对应的无符号数uint(0:2 32 – 1)
• ??int 与 char的转换要强制执行，而不再是默认
• ??char大小为16位，故可以用来存一个汉字如：char c = ‘中’，同java。从8位上升到16位的原因是ASCII码表示不完所有字符，如汉字，故当出现符号与汉字在一起时，单个截取就不用再担心汉字被一分为二的问题。
• ??转义字符\ 但字符串中多时如路径就要写很多\\可用@:string filepath = @”C:’ProCSharp\First.cs”; \就会是\而不代表转义。
• ??switch可以用字符串，而java只能用int以下

?? ?using?string?=?System.String;?
?? ?using?sbyte?=?System.SByte;?
?? ?using?byte?=?System.Byte;?
?? ?using?short?=?System.Int16;?
?? ?using?ushort?=?System.UInt16;
?? ?using?int?=?System.Int32;?
?? ?using?uint?=?System.UInt32?