有时候想为我们的网页提供多语言支持,如果一种语言用一张网页来做实在太麻烦了,幸好Google提供了语言工具功能,下面介绍如何利用它来实现网页多种语言之间的转换。

lan.htm

<form>
<select name="lan">
<option value="en|de">英语 翻译成 德语</option>
<option value="en|es">英语 翻译成 西班牙语</option>
<option value="en|fr">英语 翻译成 法语</option>
<option value="en|it">英语 翻译成 意大利语</option>
<option value="en|pt">英语 翻译成 葡萄牙语</option>
<option value="en|ja">英语 翻译成 日语 BETA</option>
<option value="en|ko">英语 翻译成 朝鲜语 BETA</option>
<option value="en|zh-CN" >英语 翻译成 中文(简体) BETA</option>
<option value="de|en">德语 翻译成 英语</option>
<option value="de|fr">德语 翻译成 法语</option>
<option value="es|en">西班牙语 翻译成 英语</option>
<option value="fr|en">法语 翻译成 英语</option>
<option value="fr|de">法语 翻译成 德语</option>
<option value="it|en">意大利语 翻译成 英语</option>
<option value="pt|en">葡萄牙语 翻译成 英语</option>
<option value="ja|en">日语 翻译成 英语 BETA</option>
<option value="ko|en">朝鲜语 翻译成 英语 BETA</option>
<option value="zh-CN|en">中文(简体) 翻译成 英语 BETA</option>
<input style="FONT-SIZE: 12px" type="button" value="Go->" name="Button1" onClick="javascript:window.open(‘translate.asp?urls=‘+document.location+‘&lan=‘+lan.value,‘_self‘,‘‘)">
</select>
</form>

  lan.htm中的内容用来选择要翻译的语言包括原来的语言和要翻译成的语言。我们只需要将lan.htm中的内容拷到提供多语言翻译的页面中就可以了。

translate.asp
<html>
<head>
<title>在线翻译</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>

<body>
<%
‘on error resume next
‘ 如果网速很慢的话,可以调整以下时间。单位秒
Server.ScriptTimeout = 999999
‘========================================================
‘字符编码函数
‘========================================================
Function BytesToBstr(body,code)
dim objstream
set objstream = Server.CreateObject("adodb.stream")
objstream.Type = 1
objstream.Mode =3
objstream.Open
objstream.Write body
objstream.Position = 0
objstream.Type = 2
objstream.Charset =code
BytesToBstr = objstream.ReadText
objstream.Close
set objstream = nothing
End Function

‘取行字符串在另一字符串中的出现位置
Function Newstring(wstr,strng)
Newstring=Instr(lcase(wstr),lcase(strng))
if Newstring<=0 then Newstring=Len(wstr)
End Function
‘替换字符串函数
function ReplaceStr(ori,str1,str2)
ReplaceStr=replace(ori,str1,str2)
end function
‘=====================================================
function ReadXml(url,code,start,ends)
set oSend=createobject("Microsoft.XMLHTTP")
SourceCode = oSend.open ("GET",url,false)
oSend.send()
ReadXml=BytesToBstr(oSend.responseBody,code )
if(start="" or ends="") then
else
start=Newstring(ReadXml,start)
ReadXml=mid(ReadXml,start)
ends=Newstring(ReadXml,ends)
ReadXml=left(ReadXml,ends-1)
end if
end function
dim urlpage,lan
urlpage=request("urls")
lan=request("lan")
%>
<form method="post" action="translate.asp">
<input type="text" name="urls" size="150" value="<%=urlpage%>">
<input type="hidden" name="lan" value="<%=lan%>">
<input type="submit" value="submit">
</form>
<%
dim transURL
transURL="http://216.239.39.104/translate_c?hl=zh-CN&ie=UTF-8&oe=UTF-8&langpair="&server.URLEncode(lan)&"&u="&urlpage&"&prev=/language_tools"
if(len(urlpage)>3) then
getcont=ReadXml(transURL,"gb2312","","")
response.Write(getcont)
end if

%>
</body>
</html>

  translate.asp实现翻译功能,这是利用google的语言工具实现的。

  注意,因为提供多语言支持,所以translate.asp文件所用的编码是支持所有字符的"utf-8" 。

论坛

动网论坛 
http://www.dvbbs.net/

Discuz! 
http://www.discuz.net/

PHPWind 
http://www.phpwind.com/

vBB(vBulletin) 
http://www.phpforce.cn/

LeadBBS 
http://www.leadbbs.com/

MolyX(MolyX Board) 
http://www.molyx.com/

BMForum  
http://www.bmforum.com/

phpbb 
http://www.cnphpbb.com/forum/

IPB(Invision Power Board) 
http://www.invisionpower.com/
http://www.ipber.org/

CMS

DEDECMS
http://www.dedecms.com/

风讯
http://www.foosun.cn/

渐飞
http://www.jfcms.net/

科讯
http://www.kesion.com/

新云
http://www.newasp.cn/

PHPCMS
http://www.phpcms.cn/

CMSware
http://www.cmsware.com/

帝国
http://www.phome.net/

Joomla
http://www.joomla.org.tw/

Type3(Typo3 dummy)
http://www.typo3.org.cn/

BLOG

PJBLOG
http://www.pjhome.net/

Z-BLOG
http://www.rainbowsoft.org/

DRUPAL
http://drupal.org/

OBLOG
http://www.oblog.cn/
http://bbs.oblog.cn/

WordPress
http://www.wordpress.org/
http://www.gtp2p.com/

注:本文为西部E网(weste.net)整理,转载请注明来源。谢谢!

HTML代码:

按钮样式:

找到几个相关代码,都整理出来。
第一个:
[php]
public static string WapPush(string Host,int Port,string Data,int Timeout)
  {
   TcpClient tc = new TcpClient();
   tc.Connect(Host, Port);
   NetworkStream ns = tc.GetStream();
   byte[] bytes = null;
   if (ns.CanWrite)
   {
    int i = 0;
    byte[] buffer = System.Text.Encoding.GetEncoding("gb2312").GetBytes(Data);
    ns.Write(buffer,0,buffer.Length);   
   
   }  
   return "发送成功 ^_^";
  }
example:
WapPush("主机IP","端口号","手机号"+" "+"链接url"+" "+描述+" 1
",5)
[/php]
还有一个:
[php]
CMPP3.0 , C# 源码
submit.TP_pID=0
submit.TP_udhi=1
submit.Msg_Fmt=0x04
WAPPUSH wap=new WAPPUSH();
sumbit.Msg_content=wap.toBytes(msg,url);
  public class WAPPUSH
        {
            public WAPPUSH()
            {
            }
            //第一部分
            static private readonly byte[] WapPushHeader1 = new byte[]
{
  0x0B, 0x05, 0x04, 0x0B, 0x84, 0x23, 0xF0, 0x00, 0x03, 0x03, 0x01, 0x01
};
            //第二部分
            static private readonly byte[] WapPushHeader2 = new byte[]
{
  0x29, 0x06, 0x06, 0x03, 0xAE, 0x81, 0xEA, 0x8D, 0xCA
};
            //第三部分
            static private readonly byte[] WapPushIndicator = new byte[]
{
  0x02, 0x05, 0x6A, 0x00, 0x45, 0xC6, 0x0C, 0x03
};
            //第四部分:URL去掉http://后的UTF8编码
            //第五部分
            static private readonly byte[] WapPushDisplayTextHeader = new byte[]
   {
    0x00, 0x01, 0x03,
   };
            //第六部分:消息文字的UTF8编码
            //第七部分:
            static private readonly byte[] EndOfWapPush = new byte[]
   {
  0x00, 0x01, 0x01,
   };
            public byte[] toBytes(string WAP_Msg, string WAP_URL)
            {
                byte[] submitData = new byte[400];
                int index = 0;
                WapPushHeader1.CopyTo(submitData, index);
                index += WapPushHeader1.Length;
                WapPushHeader2.CopyTo(submitData, index);
                index += WapPushHeader2.Length;
                              
                WapPushIndicator.CopyTo(submitData, index);
                index += WapPushIndicator.Length;
                byte[] url = Encoding.UTF8.GetBytes(WAP_URL);
                url.CopyTo(submitData, index);
                index += url.Length;
                WapPushDisplayTextHeader.CopyTo(submitData, index);
                index += WapPushDisplayTextHeader.Length;
                byte[] msg2 = Encoding.UTF8.GetBytes(WAP_Msg);
                msg2.CopyTo(submitData, index);
                index += msg2.Length;
                              
                EndOfWapPush.CopyTo(submitData, index);
                index += 3;
                byte[] reVal = new byte[index];
                for (int i = 0; i < reVal.Length; i++)
                {
                    reVal = submitData;
                }
                return (reVal);
            }
           
        }
[/php]
还有:
前一段,给移动做一个wappush的东西,在网上找资料,发现几乎没有,有的也是说的很含糊,最后,尝试了很久,终于解决了,奉献给大家.
(1):使用http://www.codeproject.com/csharp/wappush.asp这里说的方法生成一个16进制的字符串,这个串就是短信内容content.
(2):由于CMPP使用socket发送,因此content需要进行二进制编码,那么如果你采用c#语言,请使用下面的方法,其他语言类同。
[php]
public static byte[] hex2Ascii(string s)
         {
 
              int len = s.Length;
 
              byte[] temp = new byte[len/2];
              int j = 0;
              for(int i=0;i<len;i++)
              {
                   string s2 = s.Substring(i,2);
                   string s21 = s2.Substring(0,1);
                   string s22 = s2.Substring(1,1);
                   temp[j]=(byte)(str2byte(s21) * 16 + str2byte(s22));
                   i++;
                   j++;
              }
              return temp;
         }
         public static int str2byte(string ch)
         {
              string aa = ch.ToLower();
              if(aa.Equals("a")) return 10;
              if(aa.Equals("b")) return 11;
              if(aa.Equals("c")) return 12;
              if(aa.Equals("d")) return 13;
              if(aa.Equals("e")) return 14;
              if(aa.Equals("f")) return 15;
              return Convert.ToInt32(aa);
 
         }
[/php]
(3):在CMPP协议中,在发送WAPPUSH时候,需要将TP_pID设置为0,将TP_udhi设置为64。
(4):test it!

身份证18位验证

     18位身份证标准在国家质量技术监督局于1999年7月1日实施的GB11643-1999《公民身份号码》中做了明确的规定。 GB11643-1999《公民身份号码》为GB11643-1989《社会保障号码》的修订版,其中指出将原标准名称"社会保障号码"更名为"公民身份号码",另外GB11643-1999《公民身份号码》从实施之日起代替GB11643-1989。GB11643-1999《公民身份号码》主要内容如下:

一、范围
该标准规定了公民身份号码的编码对象、号码的结构和表现形式,使每个编码对象获得一个唯一的、不变的法定号码。
二、编码对象
公民身份号码的编码对象是具有中华人民共和国国籍的公民。
三、号码的结构和表示形式
1、号码的结构
公民身份号码是特征组合码,由十七位数字本体码和一位校验码组成。排列顺序从左至右依次为:六位数字地址码,八位数字出生日期码,三位数字顺序码和一位数字校验码。
2、地址码
表示编码对象常住户口所在县(市、旗、区)的行政区划代码,按GB/T2260的规定执行。
3、出生日期码
表示编码对象出生的年、月、日,按GB/T7408的规定执行,年、月、日代码之间不用分隔符。
4、顺序码
表示在同一地址码所标识的区域范围内,对同年、同月、同日出生的人编定的顺序号,顺序码的奇数分配给男性,偶数分配给女性。
5、校验码
(1)十七位数字本体码加权求和公式
S = Sum(Ai * Wi), i = 0, … , 16 ,先对前17位数字的权求和
Ai:表示第i位置上的身份证号码数字值
Wi:表示第i位置上的加权因子
Wi: 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2
(2)计算模
Y = mod(S, 11)

(3)通过模得到对应的校验码
Y: 0 1 2 3 4 5 6 7 8 9 10
校验码: 1 0 X 9 8 7 6 5 4 3 2
四、举例如下:
北京市朝阳区: 11010519491231002X
广东省汕头市: 440524188001010014

15位升18的方法

根据〖中华人民共和国国家标准 GB 11643-1999〗中有关公民身份号码的规定,公民身份号码是特征组合码,由十七位数字本体码和一位数字校验码组成。排列顺序从左至右依次为:六位数字地址码,八位数字出生日期码,三位数字顺序码和一位数字校验码。

地址码表示编码对象常住户口所在县(市、旗、区)的行政区划代码。生日期码表示编码对象出生的年、月、日,其中年份用四位数字表示,年、月、日之间不用分隔符。顺序码表示同一地址码所标识的区域范围内,对同年、月、日出生的人员编定的顺序号。顺序码的奇数分给男性,偶数分给女性。校验码是根据前面十七位数字码,按照ISO 7064:1983.MOD 11-2校验码计算出来的检验码。下面举例说明该计算方法。

15位的身份证编码首先把出生年扩展为4位,简单的就是增加一个19,但是这对于1900年出生的人不使用(这样的寿星不多了)

某男性公民身份号码本体码为34052419800101001,首先按照公式⑴计算:

∑(ai×Wi)(mod 11)……………………………………(1)

公式(1)中:
i—-表示号码字符从由至左包括校验码在内的位置序号;
ai—-表示第i位置上的号码字符值;
Wi—-示第i位置上的加权因子,其数值依据公式Wi=2(n-1)(mod 11)计算得出。

i 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1

ai 3 4 0 5 2 4 1 9 8 0 0 1 0 1 0 0 1 a1

Wi 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2 1

ai×Wi 21 36 0 25 16 16 2 9 48 0 0 9 0 5 0 0 2 a1

根据公式(1)进行计算:

∑(ai×Wi) =(21+36+0+25+16+16+2+9+48++0+0+9+0+5+0+0+2) = 189

189 ÷ 11 = 17 + 2/11

∑(ai×Wi)(mod 11) = 2

然后根据计算的结果,从下面的表中查出相应的校验码,其中X表示计算结果为10:

∑(ai×WI)(mod 11) 0 1 2 3 4 5 6 7 8 9 10
校验码字符值ai 1 0 X 9 8 7 6 5 4 3 2
根据上表,查出计算结果为2的校验码为所以该人员的公民身份号码应该为 34052419800101001X。

C#代码:

  private string per15To18(string perIDSrc)
  {
   int iS = 0;
 
   //加权因子常数
   int[] iW=new int[]{7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2};
   //校验码常数
   string LastCode="10X98765432";
   //新身份证号
   string perIDNew;
 
   perIDNew=perIDSrc.Substring(0,6);
   //填在第6位及第7位上填上‘1’,‘9’两个数字
   perIDNew += "19";
 
   perIDNew += perIDSrc.Substring(6,9);
 
   //进行加权求和
   for( int i=0; i<17; i++)
   {
    iS += int.Parse(perIDNew.Substring(i,1)) * iW[i];
   }
    
   //取模运算,得到模值
   int iY = iS%11;
   //从LastCode中取得以模为索引号的值,加到身份证的最后一位,即为新身份证号。
   perIDNew += LastCode.Substring(iY,1);

   return perIDNew;
  }

    C# 出来也有些日子了,最近由于编程的需要,对 C# 的类型转换做了一些研究,其内容涉及 C# 的装箱/拆箱/别名、数值类型间相互转换、字符的 ASCII 码和 Unicode 码、数值字符串和数值之间的转换、字符串和字符数组/字节数组之间的转换、各种数值类型和字节数组之间的转换、十六进制数输出以及日期型数据的一些转换处理,在这里与大家分享——

1. 装箱、拆箱还是别名

    许多 C#.NET 的书上都有介绍 int -> Int32 是一个装箱的过程,反之则是拆箱的过程。许多其它变量类型也是如此,如:short <-> Int16,long <-> Int64 等。对于一般的程序员来说,大可不必去了解这一过程,因为这些装箱和拆箱的动作都是可以自动完成的,不需要写代码进行干预。但是我们需要记住这些类型之间的关系,所以,我们使用“别名”来记忆它们之间的关系。
    C# 是全面向对象的语言,比 Java 的面向对象都还彻底——它把简单数据类型通过默认的装箱动作封装成了类。Int32、Int16、Int64 等就是相应的类名,而那些我们熟悉的、简单易记的名称,如 int、short、long 等,我们就可以把它称作是 Int32、Int16、Int64 等类型的别名。
    那么除了这三种类型之外,还有哪些类有“别名”呢?常用的有如下一些:

    bool -> System.Boolean (布尔型,其值为 true 或者 false)
    char -> System.Char (字符型,占有两个字节,表示 1 个 Unicode 字符)
    byte -> System.Byte (字节型,占 1 字节,表示 8 位正整数,范围 0 ~ 255)
    sbyte -> System.SByte (带符号字节型,占 1 字节,表示 8 位整数,范围 -128 ~ 127)
    ushort -> System.UInt16 (无符号短整型,占 2 字节,表示 16 位正整数,范围 0 ~ 65,535)
    uint -> System.UInt32 (无符号整型,占 4 字节,表示 32 位正整数,范围 0 ~ 4,294,967,295)
    ulong -> System.UInt64 (无符号长整型,占 8 字节,表示 64 位正整数,范围 0 ~ 大约 10 的 20 次方)
    short -> System.Int16 (短整型,占 2 字节,表示 16 位整数,范围 -32,768 ~ 32,767)
    int -> System.Int32 (整型,占 4 字节,表示 32 位整数,范围 -2,147,483,648 到 2,147,483,647)
    long -> System.Int64  (长整型,占 8 字节,表示 64 位整数,范围大约 -(10 的 19) 次方 到 10 的 19 次方)
    float -> System.Single (单精度浮点型,占 4 个字节)
    double -> System.Double (双精度浮点型,占 8 个字节)

    我们可以用下列代码做一个实验

    private void TestAlias() {
        // this.textBox1 是一个文本框,类型为 System.Windows.Forms.TextBox
        // 设计中已经将其 Multiline 属性设置为 true
        byte a = 1; char b = ‘a‘; short c = 1;
        int d = 2; long e = 3; uint f = 4; bool g = true;
        this.textBox1.Text = ;
        this.textBox1.AppendText(byte -> + a.GetType().FullName +
);

        this.textBox1.AppendText(char -> + b.GetType().FullName +
);

        this.textBox1.AppendText(short -> + c.GetType().FullName +
);

        this.textBox1.AppendText(int -> + d.GetType().FullName +
);

        this.textBox1.AppendText(long -> + e.GetType().FullName +
);

        this.textBox1.AppendText(uint -> + f.GetType().FullName +
);

        this.textBox1.AppendText(bool -> + g.GetType().FullName +
);

    }

    在窗体中新建一个按钮,并在它的单击事件中调用该 TestAlias() 函数,我们将看到运行结果如下:

    byte -> System.Byte
    char -> System.Char
    short -> System.Int16
    int -> System.Int32
    long -> System.Int64
    uint -> System.UInt32
    bool -> System.Boolean

    这足以说明各别名对应的类!

2. 数值类型之间的相互转换

    这里所说的数值类型包括 byte, short, int, long, fload, double 等,根据这个排列顺序,各种类型的值依次可以向后自动进行转换。举个例来说,把一个 short 型的数据赋值给一个 int 型的变量,short 值会自动行转换成 int 型值,再赋给 int 型变量。如下例:

    private void TestBasic() {
        byte a = 1; short b = a; int c = b;
        long d = c; float e = d; double f = e;
        this.textBox1.Text = ;
        this.textBox1.AppendText(byte a = + a.ToString() +
);

        this.textBox1.AppendText(short b = + b.ToString() +
);

        this.textBox1.AppendText(int c = + c.ToString() +
);

        this.textBox1.AppendText(long d = + d.ToString() +
);

        this.textBox1.AppendText(float e = + e.ToString() +
);

        this.textBox1.AppendText(double f = + f.ToString() +
);

    }

    编译顺利通过,运行结果是各变量的值均为 1;当然,它们的类型分别还是 System.Byte 型……System.Double 型。现在我们来试试,如果把赋值的顺序反过来会怎么样呢?在 TestBasic() 函数中追加如下语句:

        int g = 1;
        short h = g;
        this.textBox1.AppendText(h = + h.ToString() +
);

    结果编译报错:
    G:ProjectsVisual C#ConvertForm1.cs(118): 无法将类型“int”隐式转换为“short”
    其中,Form1.cs 的 118 行即 short h = g 所在行。

    这个时候,如果我们坚持要进行转换,就应该使用强制类型转换,这在 C 语言中常有提及,就是使用“(类型名) 变量名”形式的语句来对数据进行强制转换。如上例修改如下:

        short g = 1;
        byte h = (byte) g;  // 将 short 型的 g 的值强制转换成 short 型后再赋给变量 h
        this.textBox1.AppendText(h = + h.ToString() +
);

    编译通过,运行结果输出了 h = 1,转换成功。
    但是,如果我们使用强制转换,就不得不再考虑一个问题:short 型的范围是 -32768 ~ 23767,而 byte 型的范围是 0 ~ 255,那么,如果变量 g 的大小超过了 byte 型的范围又会出现什么样的情况呢?我们不妨再一次改写代码,将值改为 265,比 255 大 10

        short g = 265; //265 = 255 + 10
        byte h = (byte) g;
        this.textBox1.AppendText(h = + h.ToString() +
);

    编译没有出错,运行结果却不是 h = 265,而是 h = 9。
    因此,我们在进行转换的时候,应当注意被转换的数据不能超出目标类型的范围。这不仅体现在多字节数据类型(相对,如上例的 short) 转换为少字节类型(相对,如上例的 byte) 时,也体现在字节数相同的有符号类型和无符号类型之间,如将 byte 的 129 转换为 sbyte 就会溢出。这方面的例子大同小异,就不详细说明了。

3. 字符的 ASCII 码和 Unicode 码

    很多时候我们需要得到一个英文字符的 ASCII 码,或者一个汉字字符的 Unicode 码,或者从相关的编码查询它是哪一个字符的编码。很多人,尤其是从 VB 程序序转过来学 C# 的人,会报怨 C# 里为什么没有提供现成的函数来做这个事情——因为在 VB 中有 Asc() 函数和 Chr() 函数用于这类转换。
    但是如果你学过 C,你就会清楚,我们只需要将英文字符型数据强制转换成合适的数值型数据,就可以得到相应的 ASCII 码;反之,如果将一个合适的数值型数据强制转换成字符型数据,就可以得到相应的字符。
    C# 中字符的范围扩大了,不仅包含了单字节字符,也可以包含双字节字符,如中文字符等。而在字符和编码之间的转换,则仍延用了 C 语言的做法——强制转换。不妨看看下面的例子

    private void TestChar() {
        char ch = ‘a‘; short ii = 65;
        this.textBox1.Text = ;
        this.textBox1.AppendText(The ASCII code of ‘ + ch + ‘ is: + (short) ch +
);

        this.textBox1.AppendText(ASCII is + ii.ToString() + , the char is: + (char) ii +
);

        char cn = ‘中‘; short uc = 22478;
        this.textBox1.AppendText(The Unicode of ‘ + cn + ‘ is: + (short) cn +
);

        this.textBox1.AppendText(Unicode is + uc.ToString() + , the char is: + (char) uc +
);

    }

    它的运行结果是

    The ASCII code of ‘a‘ is: 97
    ASCII is 65, the char is: A
    The Unicode of ‘中‘ is: 20013
    Unicode is 22478, the char is: 城

    从这个例子中,我们便能非常清楚的了解——通过强制转换,可以得以字符的编码,或者得到编码表示的字符。如果你需要的不是 short 型的编码,请参考第 1 条进行转换,即可得到 int 等类型的编码值。

4. 数值字符串和数值之间的转换

    首先,我们得搞明白,什么是数值字符串。我们知道,在 C# 中,字符串是用一对双引号包含的若干字符来表示的,如 123。而 123 又相对特殊,因为组成该字符串的字符都是数字,这样的字符串,就是数值字符串。在我们的眼中,这即是一串字符,也是一个数,但计算机却只认为它是一个字符串,不是数。因此,我们在某些时候,比如输入数值的时候,把字符串转换成数值;而在另一些时候,我们需要相反的转换。
    将数值转换成字符串非常简单,因为每一个类都有一个 void ToString() 方法。所有数值型的 void ToString() 方法都能将数据转换为数值字符串。如 123.ToSting() 就将得到字符串 123。
    那么反过来,将数值型字符串转换成数值又该怎么办呢?我们仔细查找一下,会发现 short, int, float 等数值类型均有一个 static Parse() 函数。这个函数就是用来将字符串转换为相应数值的。我们以一个 float 类型的转换为例: float f = float.Parse(543.21); 其结果 f 的值为 543.21F。当然,其它的数值类型也可以使用同样的方法进行转换,下面的例子可以更明确的说明转换的方法:

    private void TestStringValue() {
        float f = 54.321F;
        string str = 123;
        this.textBox1.Text = ;
        this.textBox1.AppendText(f = + f.ToString() +
);

        if (int.Parse(str) == 123) {
            this.textBox1.AppendText(str convert to int successfully.);
        } else {
            this.textBox1.AppendText(str convert to int failed.);
        }
    }

    运行结果:

    f = 54.321
    str convert to int successfully.

5. 字符串和字符数组之间的转换

    字符串类 System.String 提供了一个 void ToCharArray() 方法,该方法可以实现字符串到字符数组的转换。如下例:

    private void TestStringChars() {
        string str = mytest;
        char[] chars = str.ToCharArray();
        this.textBox1.Text = ;
        this.textBox1.AppendText(Length of mytest is + str.Length +
);

        this.textBox1.AppendText(Length of char array is + chars.Length +
);

        this.textBox1.AppendText(char[2] = + chars[2] +
);

    }

    例中以对转换转换到的字符数组长度和它的一个元素进行了测试,结果如下:

    Length of mytest is 6
    Length of char array is 6
    char[2] = t

    可以看出,结果完全正确,这说明转换成功。那么反过来,要把字符数组转换成字符串又该如何呢?
    我们可以使用 System.String 类的构造函数来解决这个问题。System.String 类有两个构造函数是通过字符数组来构造的,即 String(char[]) 和 String[char[], int, int)。后者之所以多两个参数,是因为可以指定用字符数组中的哪一部分来构造字符串。而前者则是用字符数组的全部元素来构造字符串。我们以前者为例,在 TestStringChars() 函数中输入如下语句:

        char[] tcs = {‘t‘, ‘e‘, ‘s‘, ‘t‘, ‘ ‘, ‘m‘, ‘e‘};
        string tstr = new String(tcs);
        this.textBox1.AppendText(tstr = + tstr + \n);

    运行结果输入 tstr = test me,测试说明转换成功。
    实际上,我们在很多时候需要把字符串转换成字符数组只是为了得到该字符串中的某个字符。如果只是为了这个目的,那大可不必兴师动众的去进行转换,我们只需要使用 System.String 的 [] 运算符就可以达到目的。请看下例,再在 TestStringChars() 函数中加入如如下语名:

        char ch = tstr[3];
        this.textBox1.AppendText( + tstr + [3] = + ch.ToString());

    正确的输出是 test me[3] = t,经测试,输出正确。

6. 字符串和字节数组之间的转换

    如果还想从 System.String 类中找到方法进行字符串和字节数组之间的转换,恐怕你会失望了。为了进行这样的转换,我们不得不借助另一个类:System.Text.Encoding。该类提供了 bye[] GetBytes(string) 方法将字符串转换成字节数组,还提供了 string GetString(byte[]) 方法将字节数组转换成字符串。
    System.Text.Encoding 类似乎没有可用的构造函数,但我们可以找到几个默认的 Encoding,即 Encoding.Default(获取系统的当前 ANSI 代码页的编码)、Encoding.ASCII(获取 7 位 ASCII 字符集的编码)、Encoding.Unicode(获取采用 Little-Endian 字节顺序的 Unicode 格式的编码)、Encoding.UTF7(获取 UTF-7 格式的编码)、Encoding.UTF8(获取 UTF-8 格式的编码) 等。这里主要说说 Encoding.Default 和 Encoding.Unicode 用于转换的区别。
    在字符串转换到字节数组的过程中,Encoding.Default 会将每个单字节字符,如半角英文,转换成 1 个字节,而把每个双字节字符,如汉字,转换成 2 个字节。而 Encoding.Unicode 则会将它们都转换成两个字节。我们可以通过下列简单的了解一下转换的方法,以及使用 Encoding.Default 和 Encodeing.Unicode 的区别:

    private void TestStringBytes() {
        string s = C#语言;
        byte[] b1 = System.Text.Encoding.Default.GetBytes(s);
        byte[] b2 = System.Text.Encoding.Unicode.GetBytes(s);
        string t1 = , t2 = ;
        foreach (byte b in b1) {
            t1 += b.ToString() + ;
        }
        foreach (byte b in b2) {
            t2 += b.ToString() + ;
        }
        this.textBox1.Text = ;
        this.textBox1.AppendText(b1.Length = + b1.Length +
);
        this.textBox1.AppendText(t1 +
);
        this.textBox1.AppendText(b2.Length = + b2.Length +
);
        this.textBox1.AppendText(t2 +
);
    }

    运行结果如下,不说详述,相信大家已经明白了。

    b1.Length = 6
    67 35 211 239 209 212
    b2.Length = 8
    67 0 35 0 237 139 0 138

    将字节数组转换成字符串,使用 Encoding 类的 string GetString(byte[]) 或 string GetString(byte[], int, int) 方法,具体使用何种 Encoding 还是由编码决定。在 TestStringBytes() 函数中添加如下语句作为实例:

        byte[] bs = {97, 98, 99, 100, 101, 102};
        string ss = System.Text.Encoding.ASCII.GetString(bs);
        this.textBox1.AppendText(The string is: + ss +
);

    运行结果为:The string is: abcdef

7. 各种数值类型和字节数组之间的转换

    在第 1 条中我们可以查到各种数值型需要使用多少字节的空间来保存数据。将某种数值类型的数据转换成字节数组的时候,得到的一定是相应大小的字节数组;同样,需要把字节数组转换成数值类型,也需要这个字节数组大于相应数值类型的字节数。
    现在介绍此类转换的主角:System.BitConverter。该类提供了 byte[] GetBytes(…) 方法将各种数值类型转换成字节数组,也提供了 ToInt32、ToInt16、ToInt64、ToUInt32、ToSignle、ToBoolean 等方法将字节数组转换成相应的数值类型。

    由于这类转换通常只是在需要进行较细微的编码/解码操作时才会用到,所以这里就不详细叙述了,仅把 System.BitConverter 类介绍给大家。

8. 转换成十六进制

    任何数据在计算机内部都是以二进制保存的,所以进制与数据的存储无关,只与输入输出有关。所以,对于进制转换,我们只关心字符串中的结果。
    在上面的第 4 条中提到了 ToString() 方法可以将数值转换成字符串,不过在字符串中,结果是以十进制显示的。现在我们带给它加一些参数,就可以将其转换成十六进制——使用 ToString(string) 方法。
    这里需要一个 string 类型的参数,这就是格式说明符。十六进制的格式说明符是 x 或者 X,使用这两种格式说明符的区别主要在于 A-F 六个数字:x 代表 a-f 使用小写字母表示,而 X 而表示 A-F 使用大字字母表示。如下例:

    private void TestHex() {
        int a = 188;
        this.textBox1.Text = ;
        this.textBox1.AppendText(a(10) = + a.ToString() +
);
        this.textBox1.AppendText(a(16) = + a.ToString(x) +
);
        this.textBox1.AppendText(a(16) = + a.ToString(X) +
);
    }

    运行结果如下:

    a(10) = 188
    a(16) = bc
    a(16) = BC

    这时候,我们可能有另一种需求,即为了显示结果的整齐,我们需要控制十六进制表示的长度,如果长度不够,用前导的 0 填补。解决这个问题,我们只需要在格式说明符“x”或者“X”后写上表示长度的数字就行了。比如,要限制在 4 个字符的长度,可以写成“X4”。在上例中追加一句:

        this.textBox1.AppendText(a(16) = + a.ToString(X4) +
);

    其结果将输出 a(16) = 00BC。
    现在,我们还要说一说如何将一个表示十六进制数的字符串转换成整型。这一转换,同样需要借助于 Parse() 方法。这里,我需要 Parse(string, System.Globalization.NumberStyles) 方法。第一个参数是表示十六进制数的字符串,如“AB”、“20”(表示十进制的 32) 等。第二个参数 System.Globalization.NumberStyles 是一个枚举类型,用来表示十六进制的枚举值是 HexNumber。因此,如果我们要将“AB”转换成整型,就应该这样写:int b = int.Parse(AB, System.Globalization.NumberStyles.HexNumber),最后得到的 b 的值是 171。

9. 日期型数据和长整型数据之间的转换

    为什么要将日期型数据转换为长整型数据呢?原因很多,但就我个人来说,经常将它用于数据库的日期存储。由于各种数据库对日期型的定义和处理是不一样的,各种语言对日期型数据的定义的处理也各不相同,因为,我宁愿将日期型数据转换成长整型再保存到数据库中。虽然也可以使用字符串来保存,但使用字符串也会涉及到许多问题,如区域等问题,而且,它需要比保存长整型数据更多的空间。
    日期型数据,在 C# 中的参与运算的时候,应该也是转换为长整型数据来运算的。它的长整型值是自 0001 年 1 月 1 日午夜 12:00 以来所经过时间以 100 毫微秒为间隔表示时的数字。这个数在 C# 的 DateTime 中被称为 Ticks(刻度)。DateTime 类型有一个名为 Ticks 的长整型只读属性,就保存着这个值。如此,要从一个 DataTime 型数据得到 long 型值就非常简单了,只需要读出 DataTime 对象的 Ticks 值即可,如:

    long longDate = DateTime.Now.Ticks;

    DateTime 的构造函数中也提供了相应的,从长整型数据构造 DateTime 型数据的函数:DateTime(long)。如:

    DateTime theDate = new DateTime(longDate);

    但这样对于很多 VB6 程序员来说,是给他们出了一道难题,因为 VB6 中的日期型数据内部是以 Double 型表示的,将其转换为长整型后得到的仅仅是日期,而没有时间。如何协调这两种日期类型呢?
     System.DateTime 提供了 double ToOADate() 和 static DateTime FromOADate(double) 两个函数来解决这个问题。前者将当前对象按原来的 double 值输出,后者则从一个 double 值获得一个 System.DateTime 对象。举例如下:

    private void TestDateTimeLong() {
        double doubleDate = DateTime.Now.ToOADate();
        DateTime theDate = DateTime.FromOADate(doubleDate);
        this.textBox1.Text = ;
        this.textBox1.AppendText(Double value of now: + doubleDate.ToString() +
);
        this.textBox1.AppendText(DateTime from double value: + theDate.ToString() +
);
    }

    运行结果:

    Double value of now: 37494.661541713
    DateTime from double value: 2002-8-26 15:52:37 

10. 格式化日期型数据

    编程的过程中,通常需要将日期型数据按照一定的格式输出,当然,输出结果肯定是字符串。为此,我们需要使用 System.DateTime 类的 ToString() 方法,并为其指定格式字符串。
    MSDN 中,System.Globalization.DateTimeFormatInfo 类的概述里对模式字符串有非常详细的说明,因此,这里我只对常用的一些格式进行说明,首先请看下表:

    d       月中的某一天。一位数的日期没有前导零。
    dd      月中的某一天。一位数的日期有一个前导零。
    ddd     周中某天的缩写名称,在 AbbreviatedDayNames 中定义。
    dddd    周中某天的完整名称,在 DayNames 中定义。
    M       月份数字。一位数的月份没有前导零。
    MM      月份数字。一位数的月份有一个前导零。
    MMM     月份的缩写名称,在 AbbreviatedMonthNames 中定义。
    MMMM    月份的完整名称,在 MonthNames 中定义。
    y       不包含纪元的年份。如果不包含纪元的年份小于 10,则显示不具有前导零的年份。
    yy      不包含纪元的年份。如果不包含纪元的年份小于 10,则显示具有前导零的年份。
    yyyy    包括纪元的四位数的年份。
    h       12 小时制的小时。一位数的小时数没有前导零。
    hh      12 小时制的小时。一位数的小时数有前导零。
    H       24 小时制的小时。一位数的小时数没有前导零。
    HH      24 小时制的小时。一位数的小时数有前导零。
    m       分钟。一位数的分钟数没有前导零。
    mm      分钟。一位数的分钟数有一个前导零。
    s       秒。一位数的秒数没有前导零。
    ss      秒。一位数的秒数有一个前导零。

    为了便于大家的理解,不妨试试下面的程序:

    private void TestDateTimeToString() {
        DateTime now = DateTime.Now;
        string format;
        this.textBox1.Text = ;
        format = yyyy-MM-dd HH:mm:ss;
        this.textBox1.AppendText(format + : + now.ToString(format) +
);
        format = yy年M日d日;
        this.textBox1.AppendText(format + : + now.ToString(format) +
);
    }

    这段程序将输出结果:

    yyyy-MM-dd HH:mm:ss: 2002-08-26 17:03:04
    yy年M日d日: 02年8日26日

    这时候,又出现一个问题,如果要输出的文本信息中包含格式字符怎么办?如

        format = year: yyyy, month: MM, day: dd;
        this.textBox1.AppendText(now.ToString(format) +
);

    将输出:

    2ear: 2002, 4on下5: 08, 26a2: 26

    这并不是我想要的结果,怎么办呢?有办法——

        format = year: yyyy, ‘month‘: MM, ‘day‘: dd;
        this.textBox1.AppendText(now.ToString(format) +
);

    看,这次运行结果对了:

    year: 2002, month: 08, day: 26

    可以看出,只需要使用单引号或者双引号将文本信息括起来就好。
    如果文本信息中包含双引号或者单引号又怎么办呢?这个问题,请读者们动动脑筋吧!

  代码审查是消灭Bug最重要的方法之一,这些审查在大多数时候都特别奏效。由于代码审查本身所针对的对象,就是俯瞰整个代码在测试过程中的问题和Bug。并且,代码审查对消除一些特别细节的错误大有裨益,尤其是那些能够容易在阅读代码的时候发现的错误,这些错误往往不容易通过机器上的测试识别出来。本文就常见的Java代码中容易出现的问题提出一些建设性建议,以便您在审查代码的过程中注意到这些常见的细节性错误。

  通常给别人的工作挑错要比找自己的错容易些。别样视角的存在也解释了为什么作者需要编辑,而运动员需要教练的原因。不仅不应当拒绝别人的批评,我们应该欢迎别人来发现并指出我们的编程工作中的不足之处,我们会受益匪浅的。

   正规的代码审查(code inspection)是提高代码质量的最强大的技术之一,代码审查—由同事们寻找代码中的错误—所发现的错误与在测试中所发现的错误不同,因此两者的关系是互补的,而非竞争的。

  如果审查者能够有意识地寻找特定的错误,而不是靠漫无目的的浏览代码来发现错误,那么代码审查的效果会事半功倍。在这篇文章中,我列出了11个Java编程中常见的错误。你可以把这些错误添加到你的代码审查的检查列表(checklist)中,这样在经过代码审查后,你可以确信你的代码中不再存在这类错误了。

  一、常见错误1# :多次拷贝字符串

  测试所不能发现的一个错误是生成不可变(immutable)对象的多份拷贝。不可变对象是不可改变的,因此不需要拷贝它。最常用的不可变对象是String。

  如果你必须改变一个String对象的内容,你应该使用StringBuffer。下面的代码会正常工作:

String s = new String ("Text here");

  但是,这段代码性能差,而且没有必要这么复杂。你还可以用以下的方式来重写上面的代码:

String temp = "Text here";
String s = new String (temp);

  但是这段代码包含额外的String,并非完全必要。更好的代码为:

String s = "Text here";

  二、常见错误2#: 没有克隆(clone)返回的对象

  封装(encapsulation)是面向对象编程的重要概念。不幸的是,Java为不小心打破封装提供了方便——Java允许返回私有数据的引用(reference)。下面的代码揭示了这一点:

import java.awt.Dimension;
/***Example class.The x and y values should never*be negative.*/
public class Example{
  private Dimension d = new Dimension (0, 0);
  public Example (){ }

  /*** Set height and width. Both height and width must be nonnegative * or an exception is thrown.*/
  public synchronized void setValues (int height,int width) throws IllegalArgumentException{
   if (height < 0 || width < 0)
    throw new IllegalArgumentException();
    d.height = height;
      d.width = width;
  }

  public synchronized Dimension getValues(){
   // Ooops! Breaks encapsulation
   return d;
  }
}

  Example类保证了它所存储的height和width值永远非负数,试图使用setValues()方法来设置负值会触发异常。不幸的是,由于getValues()返回d的引用,而不是d的拷贝,你可以编写如下的破坏性代码:

Example ex = new Example();
Dimension d = ex.getValues();
d.height = -5;
d.width = -10;

  现在,Example对象拥有负值了!如果getValues() 的调用者永远也不设置返回的Dimension对象的width 和height值,那么仅凭测试是不可能检测到这类的错误。

  不幸的是,随着时间的推移,客户代码可能会改变返回的Dimension对象的值,这个时候,追寻错误的根源是件枯燥且费时的事情,尤其是在多线程环境中。

  更好的方式是让getValues()返回拷贝:

public synchronized Dimension getValues(){
return new Dimension (d.x, d.y);
}

  现在,Example对象的内部状态就安全了。调用者可以根据需要改变它所得到的拷贝的状态,但是要修改Example对象的内部状态,必须通过setValues()才可以。

  三、常见错误3#:不必要的克隆

  我们现在知道了get方法应该返回内部数据对象的拷贝,而不是引用。但是,事情没有绝对:

/*** Example class.The value should never * be negative.*/
public class Example{
  private Integer i = new Integer (0);
  public Example (){ }

  /*** Set x. x must be nonnegative* or an exception will be thrown*/
  public synchronized void setValues (int x) throws IllegalArgumentException{
   if (x < 0)
    throw new IllegalArgumentException();
    i = new Integer (x);
  }

  public synchronized Integer getValue(){
   // We can’t clone Integers so we makea copy this way.
   return new Integer (i.intValue());
  }
}

  这段代码是安全的,但是就象在错误1#那样,又作了多余的工作。Integer对象,就象String对象那样,一旦被创建就是不可变的。因此,返回内部Integer对象,而不是它的拷贝,也是安全的。

  方法getValue()应该被写为:

public synchronized Integer getValue(){
// ’i’ is immutable, so it is safe to return it instead of a copy.
return i;
}

  Java程序比C++程序包含更多的不可变对象。JDK 所提供的若干不可变类包括:

  ·Boolean
   ·Byte
   ·Character
   ·Class
   ·Double
   ·Float
   ·Integer
   ·Long
   ·Short
   ·String
   ·大部分的Exception的子类

    四、常见错误4# :自编代码来拷贝数组

  Java允许你克隆数组,但是开发者通常会错误地编写如下的代码,问题在于如下的循环用三行做的事情,如果采用Object的clone方法用一行就可以完成:

public class Example{
  private int[] copy;
  /*** Save a copy of ’data’. ’data’ cannot be null.*/
  public void saveCopy (int[] data){
   copy = new int[data.length];
   for (int i = 0; i < copy.length; ++i)
    copy[i] = data[i];
  }
}

  这段代码是正确的,但却不必要地复杂。saveCopy()的一个更好的实现是:

void saveCopy (int[] data){
  try{
   copy = (int[])data.clone();
  }catch (CloneNotSupportedException e){
   // Can’t get here.
  }
}

  如果你经常克隆数组,编写如下的一个工具方法会是个好主意:

static int[] cloneArray (int[] data){
  try{
   return(int[])data.clone();
  }catch(CloneNotSupportedException e){
   // Can’t get here.
  }
}

  这样的话,我们的saveCopy看起来就更简洁了:

void saveCopy (int[] data){
  copy = cloneArray ( data);
}

  五、常见错误5#:拷贝错误的数据

  有时候程序员知道必须返回一个拷贝,但是却不小心拷贝了错误的数据。由于仅仅做了部分的数据拷贝工作,下面的代码与程序员的意图有偏差:

import java.awt.Dimension;
/*** Example class. The height and width values should never * be
negative. */
public class Example{
  static final public int TOTAL_VALUES = 10;
  private Dimension[] d = new Dimension[TOTAL_VALUES];
  public Example (){ }

  /*** Set height and width. Both height and width must be nonnegative * or an exception will be thrown. */
  public synchronized void setValues (int index, int height, int width) throws IllegalArgumentException{
   if (height < 0 || width < 0)
    throw new IllegalArgumentException();
    if (d[index] == null)
     d[index] = new Dimension();
     d[index].height = height;
     d[index].width = width;
  }
  public synchronized Dimension[] getValues()
   throws CloneNotSupportedException{
    return (Dimension[])d.clone();
  }
}

  这儿的问题在于getValues()方法仅仅克隆了数组,而没有克隆数组中包含的Dimension对象,因此,虽然调用者无法改变内部的数组使其元素指向不同的Dimension对象,但是调用者却可以改变内部的数组元素(也就是Dimension对象)的内容。方法getValues()的更好版本为:

public synchronized Dimension[] getValues() throws CloneNotSupportedException{
  Dimension[] copy = (Dimension[])d.clone();
  for (int i = 0; i < copy.length; ++i){
   // NOTE: Dimension isn’t cloneable.
   if (d != null)
    copy[i] = new Dimension (d[i].height, d[i].width);
  }
  return copy;
}

  在克隆原子类型数据的多维数组的时候,也会犯类似的错误。原子类型包括int,float等。简单的克隆int型的一维数组是正确的,如下所示:

public void store (int[] data) throws CloneNotSupportedException{
  this.data = (int[])data.clone();
  // OK
}

  拷贝int型的二维数组更复杂些。Java没有int型的二维数组,因此一个int型的二维数组实际上是一个这样的一维数组:它的类型为int[]。简单的克隆int[][]型的数组会犯与上面例子中getValues()方法第一版本同样的错误,因此应该避免这么做。下面的例子演示了在克隆int型二维数组时错误的和正确的做法:

public void wrongStore (int[][] data) throws CloneNotSupportedException{
  this.data = (int[][])data.clone(); // Not OK!
}
public void rightStore (int[][] data){
  // OK!
  this.data = (int[][])data.clone();
  for (int i = 0; i < data.length; ++i){
   if (data != null)
    this.data[i] = (int[])data[i].clone();
  }
}

   六、常见错误6#:检查new 操作的结果是否为null

  Java编程新手有时候会检查new操作的结果是否为null。可能的检查代码为:

Integer i = new Integer (400);
if (i == null)
throw new NullPointerException();

  检查当然没什么错误,但却不必要,if和throw这两行代码完全是浪费,他们的唯一功用是让整个程序更臃肿,运行更慢。

  C/C++程序员在开始写java程序的时候常常会这么做,这是由于检查C中malloc()的返回结果是必要的,不这样做就可能产生错误。检查C++中new操作的结果可能是一个好的编程行为,这依赖于异常是否被使能(许多编译器允许异常被禁止,在这种情况下new操作失败就会返回null)。在java 中,new 操作不允许返回null,如果真的返回null,很可能是虚拟机崩溃了,这时候即便检查返回结果也无济于事。

    七、常见错误7#:用== 替代.equals

  在Java中,有两种方式检查两个数据是否相等:通过使用==操作符,或者使用所有对象都实现的.equals方法。原子类型(int, flosat, char 等)不是对象,因此他们只能使用==操作符,如下所示:

int x = 4;
int y = 5;
if (x == y)
   System.out.println ("Hi");
// This ’if’ test won’t compile.
if (x.equals (y))
   System.out.println ("Hi");

  对象更复杂些,==操作符检查两个引用是否指向同一个对象,而equals方法则实现更专门的相等性检查。

  更显得混乱的是由java.lang.Object 所提供的缺省的equals方法的实现使用==来简单的判断被比较的两个对象是否为同一个。

  许多类覆盖了缺省的equals方法以便更有用些,比如String类,它的equals方法检查两个String对象是否包含同样的字符串,而Integer的equals方法检查所包含的int值是否相等。

  大部分时候,在检查两个对象是否相等的时候你应该使用equals方法,而对于原子类型的数据,你用该使用==操作符。

  八、常见错误8#: 混淆原子操作和非原子操作

  Java保证读和写32位数或者更小的值是原子操作,也就是说可以在一步完成,因而不可能被打断,因此这样的读和写不需要同步。以下的代码是线程安全(thread safe)的:

public class Example{
  private int value; // More code here…
  public void set (int x){
   // NOTE: No synchronized keyword
   this.value = x;
  }
}

  不过,这个保证仅限于读和写,下面的代码不是线程安全的:

public void increment (){
  // This is effectively two or three instructions:
  // 1) Read current setting of ’value’.
  // 2) Increment that setting.
  // 3) Write the new setting back.
  ++this.value;
}

  在测试的时候,你可能不会捕获到这个错误。首先,测试与线程有关的错误是很难的,而且很耗时间。其次,在有些机器上,这些代码可能会被翻译成一条指令,因此工作正常,只有当在其它的虚拟机上测试的时候这个错误才可能显现。因此最好在开始的时候就正确地同步代码:

public synchronized void increment (){
  ++this.value;
}

  九、常见错误9#:在catch 块中作清除工作

  一段在catch块中作清除工作的代码如下所示:

OutputStream os = null;
try{
  os = new OutputStream ();
  // Do something with os here.
  os.close();
}catch (Exception e){
  if (os != null)
  os.close();
}

  尽管这段代码在几个方面都是有问题的,但是在测试中很容易漏掉这个错误。下面列出了这段代码所存在的三个问题:

  1.语句os.close()在两处出现,多此一举,而且会带来维护方面的麻烦。

  2.上面的代码仅仅处理了Exception,而没有涉及到Error。但是当try块运行出现了Error,流也应该被关闭。

  3.close()可能会抛出异常。

  上面代码的一个更优版本为:

OutputStream os = null;
try{
  os = new OutputStream ();
  // Do something with os here.
}finally{
  if (os != null)
   os.close();
}

  这个版本消除了上面所提到的两个问题:代码不再重复,Error也可以被正确处理了。但是没有好的方法来处理第三个问题,也许最好的方法是把close()语句单独放在一个try/catch块中。

  十、常见错误10#: 增加不必要的catch 块

  一些开发者听到try/catch块这个名字后,就会想当然的以为所有的try块必须要有与之匹配的catch块。

  C++程序员尤其是会这样想,因为在C++中不存在finally块的概念,而且try块存在的唯一理由只不过是为了与catch块相配对。

  增加不必要的catch块的代码就象下面的样子,捕获到的异常又立即被抛出:

try{
  // Nifty code here
}catch(Exception e){
  throw e;
}finally{
  // Cleanup code here
}

  不必要的catch块被删除后,上面的代码就缩短为:

try{
  // Nifty code here
}finally{
  // Cleanup code here
}

  常见错误11#;没有正确实现equals,hashCode,或者clone 等方法

  方法equals,hashCode,和clone 由java.lang.Object提供的缺省实现是正确的。不幸地是,这些缺省实现在大部分时候毫无用处,因此许多类覆盖其中的若干个方法以提供更有用的功能。但是,问题又来了,当继承一个覆盖了若干个这些方法的父类的时候,子类通常也需要覆盖这些方法。在进行代码审查时,应该确保如果父类实现了equals,hashCode,或者clone等方法,那么子类也必须正确。正确的实现equals,hashCode,和clone需要一些技巧。

  小结

  我在代码审查的时候至少遇到过一次这些错误,我自己也犯过其中的几个错误。好消息是只要你知道你在找什么错误,那么代码审查就很容易管理,错误也很容易被发现和修改。即便你找不到时间来进行正规的代码审查,以自审的方式把这些错误从你的代码中根除会大大节省你的调试时间。花时间在代码审查上是值得的。

NMEA是GPS 的標準protocol,她是ASCII的字串,像

$GPRMC,053322.682,A,2502.6538,N,12121.4838,E,0.00,315.00,080905,,,A*6F

這一個command是GPS Recommanded GNSS data

053322.682

是UTC Time : 格式是hhmmss.sss所以是5:33:22.682

A

代表data是valid (如果找不到衛星,就會是V)

2502.6538

是緯度,格式是degree * 100 + minutes。但是minutes是100進位,所以要/100 * 60轉為degree,轉換後就是25‘02‘39.228‘‘.

N

是代表緯度是北緯

12121.4838

是經度,格式是degree * 100 + minutes。minutes一樣要做/100*60的轉換,轉換後就是121‘21‘29.02‘‘.

E

代表經度是東經

0.00

是速度,因為GPS天線沒動,所以是0.00

315.00

是方向

080905

是目前的日期,格式是ddmmyy,所以是05年9月8日

– –

接著有兩個欄位沒有用,所以空著

A

是Autonomous ?

*6F

是checksum

*** 所以用google earth就知道我把天線放在哪了****


格式是:
1.一律以 $ 符號開頭
2.$ 後是Message id. 5個ASCII Code.
3.一連串以‘,‘分開的欄位.
4.Checksum,checkum以‘*‘開始,後面是兩個ASCII code.
5.

$GPGSV,1,1,02,14,,,37,25,,,46,,,,,,,,*7F

$GPGSV : Satellites in View

Message ID : $GPGSV
Number of Messages : 1
Message number : 1
Satellites in view : 02 目看到的衛星數
Satellite Id : 14 Satellite vehicle 以下是第一個看到的衛星,編號14
Elevation : – Elevation of satellite in degree
Azimuth : – Azimuth of satellite in defree
SNR : 37 Signal to Noise ration in dbHz
Satellite id : 25 Satellite vehicle,以下是第二個看到的衛星,邊號25


NMEA Protocol中checksum的算法:
不包含開頭的‘$‘,一直計算到‘*‘之前。一個byte一個byte的作XOR.


data++; // skip the heading ‘

所以可以知道,連command間的‘,‘符號也加入計算。


一般NMEA的report data中,用


有些擴充協定,用來設定,例如
$PNMRX103, NMEA report rate control
可以指定NMEA report資料的頻率
GGA,GLL,GSA,GSV,RMC,VTG,ZDA,ALL
例如:
$PNMRX103,ALL,0*1A
所有的report都停止。
$PNMRX103,RMC,2*02
每2 sec送出一次RMC report


$PNMRX100 設定baud rate
$PNMRX100,0,4800,0*48
設定
Protocol : 0 : NMEA Mode, 1: Bindary Mode (不要用這一個)
baud rate: 4800 其他可以設1200,2400,4800,9600,19200,38400,57600.
Parity : 0 : None, 其他1 2代表Odd, 2代表 Even.
所以上面的example代表:使用NMEA Mode, 4800, None Parity


這些設定在reset後都消失……


雖然Manual中說明support message有GGA,GLL,GSA,GSV,RMC,VTG,ZDA但是用ALL command開啟後,發現只有report GGA,GSA,RMC,VTG.


NMEA是"National Marine Electronics Association"(国际海洋电子协会)缩写,同时也是数据传输标准工业协会,在这里,实际上应为NMEA 0183。它是一套定义接收机输出的标准信息,有几种不同的格式,每种都是独立相关的ASCII格式,逗点隔开数据流,数据流长度从30-100字符不 等,通常以每秒间隔选择输出,最常用的格式为"GGA",它包含了定位时间,纬度,经度,高度,定位所用的卫星数,DOP值,差分状态和校正时段等,其他 的有速度,跟踪,日期等。NMEA实际上已成为所有的GPS接收机和最通用的数据输出格式,同时它也被用于与GPS接收机接口的大多数的软件包里。

  NMEA-0183协议定义的语句非常多,但是常用的或者说兼容性最广的语句只有$GPGGA、$GPGSA、$GPGSV、$GPRMC、$GPVTG、$GPGLL等。下面给出这些常用NMEA-0183语句的字段定义解释。

$GPGGA
例:$GPGGA,092204.999,4250.5589,S,14718.5084,E,1,04,24.4,19.7,M,,,,0000*1F
字段0:$GPGGA,语句ID,表明该语句为Global Positioning System Fix Data(GGA)GPS定位信息
字段1:UTC 时间,hhmmss.sss,时分秒格式
字段2:纬度ddmm.mmmm,度分格式(前导位数不足则补0)
字段3:纬度N(北纬)或S(南纬)
字段4:经度dddmm.mmmm,度分格式(前导位数不足则补0)
字段5:经度E(东经)或W(西经)
字段6:GPS状态,0=未定位,1=非差分定位,2=差分定位,3=无效PPS,6=正在估算
字段7:正在使用的卫星数量(00 – 12)(前导位数不足则补0)
字段8:HDOP水平精度因子(0.5 – 99.9)
字段9:海拔高度(-9999.9 – 99999.9)
字段10:地球椭球面相对大地水准面的高度
字段11:差分时间(从最近一次接收到差分信号开始的秒数,如果不是差分定位将为空)
字段12:差分站ID号0000 – 1023(前导位数不足则补0,如果不是差分定位将为空)
字段13:校验值

$GPGSA
例:$GPGSA,A,3,01,20,19,13,,,,,,,,,40.4,24.4,32.2*0A
字段0:$GPGSA,语句ID,表明该语句为GPS DOP and Active Satellites(GSA)当前卫星信息
字段1:定位模式,A=自动手动2D/3D,M=手动2D/3D
字段2:定位类型,1=未定位,2=2D定位,3=3D定位
字段3:PRN码(伪随机噪声码),第1信道正在使用的卫星PRN码编号(00)(前导位数不足则补0)
字段4:PRN码(伪随机噪声码),第2信道正在使用的卫星PRN码编号(00)(前导位数不足则补0)
字段5:PRN码(伪随机噪声码),第3信道正在使用的卫星PRN码编号(00)(前导位数不足则补0)
字段6:PRN码(伪随机噪声码),第4信道正在使用的卫星PRN码编号(00)(前导位数不足则补0)
字段7:PRN码(伪随机噪声码),第5信道正在使用的卫星PRN码编号(00)(前导位数不足则补0)
字段8:PRN码(伪随机噪声码),第6信道正在使用的卫星PRN码编号(00)(前导位数不足则补0)
字段9:PRN码(伪随机噪声码),第7信道正在使用的卫星PRN码编号(00)(前导位数不足则补0)
字段10:PRN码(伪随机噪声码),第8信道正在使用的卫星PRN码编号(00)(前导位数不足则补0)
字段11:PRN码(伪随机噪声码),第9信道正在使用的卫星PRN码编号(00)(前导位数不足则补0)
字段12:PRN码(伪随机噪声码),第10信道正在使用的卫星PRN码编号(00)(前导位数不足则补0)
字段13:PRN码(伪随机噪声码),第11信道正在使用的卫星PRN码编号(00)(前导位数不足则补0)
字段14:PRN码(伪随机噪声码),第12信道正在使用的卫星PRN码编号(00)(前导位数不足则补0)
字段15:PDOP综合位置精度因子(0.5 – 99.9)
字段16:HDOP水平精度因子(0.5 – 99.9)
字段17:VDOP垂直精度因子(0.5 – 99.9)
字段18:校验值

$GPGSV
例:$GPGSV,3,1,10,20,78,331,45,01,59,235,47,22,41,069,,13,32,252,45*70
字段0:$GPGSV,语句ID,表明该语句为GPS Satellites in View(GSV)可见卫星信息
字段1:本次GSV语句的总数目(1 – 3)
字段2:本条GSV语句是本次GSV语句的第几条(1 – 3)
字段3:当前可见卫星总数(00 – 12)(前导位数不足则补0)
字段4:PRN 码(伪随机噪声码)(01 – 32)(前导位数不足则补0)
字段5:卫星仰角(00 – 90)度(前导位数不足则补0)
字段6:卫星方位角(00 – 359)度(前导位数不足则补0)
字段7:信噪比(00-99)dbHz
字段8:PRN 码(伪随机噪声码)(01 – 32)(前导位数不足则补0)
字段9:卫星仰角(00 – 90)度(前导位数不足则补0)
字段10:卫星方位角(00 – 359)度(前导位数不足则补0)
字段11:信噪比(00-99)dbHz
字段12:PRN 码(伪随机噪声码)(01 – 32)(前导位数不足则补0)
字段13:卫星仰角(00 – 90)度(前导位数不足则补0)
字段14:卫星方位角(00 – 359)度(前导位数不足则补0)
字段15:信噪比(00-99)dbHz
字段16:校验值

$GPRMC
例:$GPRMC,024813.640,A,3158.4608,N,11848.3737,E,10.05,324.27,150706,,,A*50
字段0:$GPRMC,语句ID,表明该语句为Recommended Minimum Specific GPS/TRANSIT Data(RMC)推荐最小定位信息
字段1:UTC时间,hhmmss.sss格式
字段2:状态,A=定位,V=未定位
字段3:纬度ddmm.mmmm,度分格式(前导位数不足则补0)
字段4:纬度N(北纬)或S(南纬)
字段5:经度dddmm.mmmm,度分格式(前导位数不足则补0)
字段6:经度E(东经)或W(西经)
字段7:速度,节,Knots
字段8:方位角,度
字段9:UTC日期,DDMMYY格式
字段10:磁偏角,(000 – 180)度(前导位数不足则补0)
字段11:磁偏角方向,E=东W=西
字段16:校验值

$GPVTG
例:$GPVTG,89.68,T,,M,0.00,N,0.0,K*5F
字段0:$GPVTG,语句ID,表明该语句为Track Made Good and Ground Speed(VTG)地面速度信息
字段1:运动角度,000 – 359,(前导位数不足则补0)
字段2:T=真北参照系
字段3:运动角度,000 – 359,(前导位数不足则补0)
字段4:M=磁北参照系
字段5:水平运动速度(0.00)(前导位数不足则补0)
字段6:N=节,Knots
字段7:水平运动速度(0.00)(前导位数不足则补0)
字段8:K=公里/时,km/h
字段9:校验值

$GPGLL
例:$GPGLL,4250.5589,S,14718.5084,E,092204.999,A*2D
字段0:$GPGLL,语句ID,表明该语句为Geographic Position(GLL)地理定位信息
字段1:纬度ddmm.mmmm,度分格式(前导位数不足则补0)
字段2:纬度N(北纬)或S(南纬)
字段3:经度dddmm.mmmm,度分格式(前导位数不足则补0)
字段4:经度E(东经)或W(西经)
字段5:UTC时间,hhmmss.sss格式
字段6:状态,A=定位,V=未定位
字段7:校验值

密码已经是我们生活工作中必不可少的工具,但一个不安全的密码有又有可能会给我们造成不必要的损失。作为网站设计者,如果我们在网页中能对用户输入的密码进行安全评估,并显示出相应的提示信息,那么对用户设置一个安全的密码将有很大帮助。同时也使得网站更具人性化,更有吸引力.
什么是一个安全的密码呢?本程序按以下的方式进行评估.
1.如果密码少于5位,那么就认为这是一个弱密码.
2.如果密码只由数字、小写字母、大写字母或其它特殊符号当中的一种组成,则认为这是一个弱密码.
3.如果密码由数字、小写字母、大写字母或其它特殊符号当中的两种组成,则认为这是一个中度安全的密码.
4.如果密码由数字、小写字母、大写字母或其它特殊符号当中的三种以上组成,则认为这是一个比较安全的密码.

具体程序如下(演示地址:http://www.netInter.cn/reg):

< script language=javascript>

//程序设计:环球万维 netInter.cn
//本程序是环球万维原创程序,若需转载,请注明网址及出处,谢谢.
//以上信息与文章正文是不可分割的一部分,所以如果您要转载本文章,您必须保留以上信息.

//CharMode函数
//测试某个字符是属于哪一类.
function CharMode(iN){
if (iN>=48 && iN <=57) //数字
return 1;
if (iN>=65 && iN <=90) //大写字母
return 2;
if (iN>=97 && iN <=122) //小写
return 4;
else
return 8; //特殊字符
}

//bitTotal函数
//计算出当前密码当中一共有多少种模式
function bitTotal(num){
modes=0;
for (i=0;i<4;i++){
if (num & 1) modes++;
num>>>=1;
}
return modes;
}

//checkStrong函数
//返回密码的强度级别

function checkStrong(sPW){
if (sPW.length<=4)
return 0; //密码太短
Modes=0;
for (i=0;i<sPW.length;i++){
//测试每一个字符的类别并统计一共有多少种模式.
Modes|=CharMode(sPW.charCodeAt(i));
}

return bitTotal(Modes);

}

//pwStrength函数
//当用户放开键盘或密码输入框失去焦点时,根据不同的级别显示不同的颜色

function pwStrength(pwd){
O_color="#eeeeee";
L_color="#FF0000";
M_color="#FF9900";
H_color="#33CC00";
if (pwd==null||pwd==‘‘){
Lcolor=Mcolor=Hcolor=O_color;
}
else{
S_level=checkStrong(pwd);
switch(S_level) {
case 0:
Lcolor=Mcolor=Hcolor=O_color;
case 1:
Lcolor=L_color;
Mcolor=Hcolor=O_color;
break;
case 2:
Lcolor=Mcolor=M_color;
Hcolor=O_color;
break;
default:
Lcolor=Mcolor=Hcolor=H_color;
}
}

document.getElementById("strength_L").style.background="/Lcolor";
document.getElementById("strength_M").style.background=Mcolor;
document.getElementById("strength_H").style.background=Hcolor;
return;
}

< /script>

< form name=form1 action="" >
输入密码:< input type=password size=10 onKeyUp=pwStrength(this.value) onBlur=pwStrength(this.value)>
< br>密码强度:
< table width="217" border="1" cellspacing="0" cellpadding="1" bordercolor="#cccccc" height="23" style=‘display:inline‘>
< tr align="center" bgcolor="#eeeeee">

< td width="33%" id="strength_L">弱< /td>

< td width="33%" id="strength_M">中< /td>

< td width="33%" id="strength_H">强< /td>
< /tr>
< /table>

< /form>

using System;
using System.Runtime.InteropServices;
using System.Text;

namespace BaseStationPDA
{
 class GPS
 {

  public string PortNum;
  public int BaudRate;
  public byte ByteSize;
  public byte Parity; // 0-4=no,odd,even,mark,space
  public byte StopBits; // 0,1,2 = 1, 1.5, 2
  public int ReadTimeout;
  
  //comm port win32 file handle
  private int hComm = -1;
  
  public bool Opened = false;
  
  //win32 api constants
  private const uint GENERIC_READ = 0x80000000;
  private const uint GENERIC_WRITE = 0x40000000;
  private const int OPEN_EXISTING = 3;  
  private const int INVALID_HANDLE_VALUE = -1;
  
  [StructLayout(LayoutKind.Sequential)]
   public struct DCB
  {
   //taken from c struct in platform sdk
   public int DCBlength;           // sizeof(DCB)
   public int BaudRate;            // 指定当前波特率 current baud rate
   // these are the c struct bit fields, bit twiddle flag to set
   public int fBinary;          // 指定是否允许二进制模式,在windows95中必须主TRUE binary mode, no EOF check
   public int fParity;          // 指定是否允许奇偶校验 enable parity checking
   public int fOutxCtsFlow;      // 指定CTS是否用于检测发送控制,当为TRUE是CTS为OFF,发送将被挂起。 CTS output flow control
   public int fOutxDsrFlow;      // 指定CTS是否用于检测发送控制 DSR output flow control
   public int fDtrControl;       // DTR_CONTROL_DISABLE值将DTR置为OFF, DTR_CONTROL_ENABLE值将DTR置为ON, DTR_CONTROL_HANDSHAKE允许DTR"握手" DTR flow control type
   public int fDsrSensitivity;   // 当该值为TRUE时DSR为OFF时接收的字节被忽略 DSR sensitivity
   public int fTXContinueOnXoff; // 指定当接收缓冲区已满,并且驱动程序已经发送出XoffChar字符时发送是否停止。TRUE时,在接收缓冲区接收到缓冲区已满的字节XoffLim且驱动程序已经发送出XoffChar字符中止接收字节之后,发送继续进行。 FALSE时,在接收缓冲区接收到代表缓冲区已空的字节XonChar且驱动程序已经发送出恢复发送的XonChar之后,发送继续进行。XOFF continues Tx
   public int fOutX;          // TRUE时,接收到XoffChar之后便停止发送接收到XonChar之后将重新开始 XON/XOFF out flow control
   public int fInX;           // TRUE时,接收缓冲区接收到代表缓冲区满的XoffLim之后,XoffChar发送出去接收缓冲区接收到代表缓冲区空的XonLim之后,XonChar发送出去 XON/XOFF in flow control
   public int fErrorChar;     // 该值为TRUE且fParity为TRUE时,用ErrorChar 成员指定的字符代替奇偶校验错误的接收字符 enable error replacement
   public int fNull;          // eTRUE时,接收时去掉空(0值)字节 enable null stripping
   public int fRtsControl;     // RTS flow control
   /*RTS_CONTROL_DISABLE时,RTS置为OFF
            RTS_CONTROL_ENABLE时, RTS置为ON
            RTS_CONTROL_HANDSHAKE时,
            当接收缓冲区小于半满时RTS为ON
             当接收缓冲区超过四分之三满时RTS为OFF
            RTS_CONTROL_TOGGLE时,
            当接收缓冲区仍有剩余字节时RTS为ON ,否则缺省为OFF*/

   public int fAbortOnError;   // TRUE时,有错误发生时中止读和写操作 abort on error
   public int fDummy2;        // 未使用 reserved
   
   public uint flags;
   public ushort wReserved;          // 未使用,必须为0 not currently used
   public ushort XonLim;             // 指定在XON字符发送这前接收缓冲区中可允许的最小字节数 transmit XON threshold
   public ushort XoffLim;            // 指定在XOFF字符发送这前接收缓冲区中可允许的最小字节数 transmit XOFF threshold
   public byte ByteSize;           // 指定端口当前使用的数据位 number of bits/byte, 4-8
   public byte Parity;             // 指定端口当前使用的奇偶校验方法,可能为:EVENPARITY,MARKPARITY,NOPARITY,ODDPARITY  0-4=no,odd,even,mark,space
   public byte StopBits;           // 指定端口当前使用的停止位数,可能为:ONESTOPBIT,ONE5STOPBITS,TWOSTOPBITS  0,1,2 = 1, 1.5, 2
   public char XonChar;            // 指定用于发送和接收字符XON的值 Tx and Rx XON character
   public char XoffChar;           // 指定用于发送和接收字符XOFF值 Tx and Rx XOFF character
   public char ErrorChar;          // 本字符用来代替接收到的奇偶校验发生错误时的值 error replacement character
   public char EofChar;            // 当没有使用二进制模式时,本字符可用来指示数据的结束 end of input character
   public char EvtChar;            // 当接收到此字符时,会产生一个事件 received event character
   public ushort wReserved1;         // 未使用 reserved; do not use
  }

  [StructLayout(LayoutKind.Sequential)]
   private struct COMMTIMEOUTS
  { 
   public int ReadIntervalTimeout;
   public int ReadTotalTimeoutMultiplier;
   public int ReadTotalTimeoutConstant;
   public int WriteTotalTimeoutMultiplier;
   public int WriteTotalTimeoutConstant;
  }  

  [StructLayout(LayoutKind.Sequential)] 
   private struct OVERLAPPED
  {
   public int  Internal;
   public int  InternalHigh;
   public int  Offset;
   public int  OffsetHigh;
   public int hEvent;
  } 
  
  [DllImport("coredll.dll")]
  private static extern int CreateFile(
   string lpFileName,                         // 要打开的串口名称
   uint dwDesiredAccess,                      // 指定串口的访问方式,一般设置为可读可写方式
   int dwShareMode,                          // 指定串口的共享模式,串口不能共享,所以设置为0
   int lpSecurityAttributes, // 设置串口的安全属性,WIN9X下不支持,应设为NULL
   int dwCreationDisposition,                // 对于串口通信,创建方式只能为OPEN_EXISTING
   int dwFlagsAndAttributes,                 // 指定串口属性与标志,设置为FILE_FLAG_OVERLAPPED(重叠I/O操作),指定串口以异步方式通信
   int hTemplateFile                        // 对于串口通信必须设置为NULL
   );
  [DllImport("coredll.dll")]
  private static extern bool GetCommState(
   int hFile,  //通信设备句柄
   ref DCB lpDCB    // 设备控制块DCB
   ); 
  [DllImport("coredll.dll")]
  private static extern bool BuildCommDCB(
   string lpDef,  // 设备控制字符串
   ref DCB lpDCB     // 设备控制块
   );
  [DllImport("coredll.dll")]
  private static extern bool SetCommState(
   int hFile,  // 通信设备句柄
   ref DCB lpDCB    // 设备控制块
   );
  [DllImport("coredll.dll")]
  private static extern bool GetCommTimeouts(
   int hFile,                  // 通信设备句柄 handle to comm device
   ref COMMTIMEOUTS lpCommTimeouts  // 超时时间 time-out values
   ); 
  [DllImport("coredll.dll")] 
  private static extern bool SetCommTimeouts(
   int hFile,                  // 通信设备句柄 handle to comm device
   ref COMMTIMEOUTS lpCommTimeouts  // 超时时间 time-out values
   );
  [DllImport("coredll.dll")]
  private static extern bool ReadFile(
   int hFile,                // 通信设备句柄 handle to file
   byte[] lpBuffer,             // 数据缓冲区 data buffer
   int nNumberOfBytesToRead,  // 多少字节等待读取 number of bytes to read
   ref int lpNumberOfBytesRead, // 读取多少字节 number of bytes read
   ref OVERLAPPED lpOverlapped    // 溢出缓冲区 overlapped buffer
   );
  [DllImport("coredll.dll")] 
  private static extern bool WriteFile(
   int hFile,                    // 通信设备句柄 handle to file
   byte[] lpBuffer,                // 数据缓冲区 data buffer
   int nNumberOfBytesToWrite,     // 多少字节等待写入 number of bytes to write
   ref int lpNumberOfBytesWritten,  // 已经写入多少字节 number of bytes written
   ref OVERLAPPED lpOverlapped        // 溢出缓冲区 overlapped buffer
   );
  [DllImport("coredll.dll")]
  private static extern bool CloseHandle(
   int hObject   // handle to object
   );
  [DllImport("coredll.dll")]
  private static extern uint GetLastError();
  
  public void Open()
  {
  
   DCB dcbCommPort = new DCB();
   COMMTIMEOUTS ctoCommPort = new COMMTIMEOUTS(); 
    
   // 打开串口 OPEN THE COMM PORT.
   hComm = CreateFile(PortNum ,GENERIC_READ | GENERIC_WRITE,0, 0,OPEN_EXISTING,0,0);
   // 如果串口没有打开,就打开 IF THE PORT CANNOT BE OPENED, BAIL OUT.
   if(hComm == INVALID_HANDLE_VALUE)
   {
    throw(new ApplicationException("非法操作,不能打开串口!"));
   }
  
   // 设置通信超时时间 SET THE COMM TIMEOUTS.
   GetCommTimeouts(hComm,ref ctoCommPort);
   ctoCommPort.ReadTotalTimeoutConstant = ReadTimeout;
   ctoCommPort.ReadTotalTimeoutMultiplier = 0;
   ctoCommPort.WriteTotalTimeoutMultiplier = 0;
   ctoCommPort.WriteTotalTimeoutConstant = 0; 
   SetCommTimeouts(hComm,ref ctoCommPort);
  
   // 设置串口 SET BAUD RATE, PARITY, WORD SIZE, AND STOP BITS.
   GetCommState(hComm, ref dcbCommPort);
   dcbCommPort.BaudRate=BaudRate;
   dcbCommPort.flags=0;
   //dcb.fBinary=1;
   dcbCommPort.flags|=1;
   if (Parity>0)
   {
    //dcb.fParity=1
    dcbCommPort.flags|=2;
   }
   dcbCommPort.Parity=Parity;
   dcbCommPort.ByteSize=ByteSize;
   dcbCommPort.StopBits=StopBits;
   if (!SetCommState(hComm, ref dcbCommPort))
   {
    //uint ErrorNum=GetLastError();
    throw(new ApplicationException("非法操作,不能打开串口!"));
   }
   //unremark to see if setting took correctly
   //DCB dcbCommPort2 = new DCB();
   //GetCommState(hComm, ref dcbCommPort2);
   Opened = true;
  }
  
  public void Close()
  {
   if (hComm!=INVALID_HANDLE_VALUE)
   {
    CloseHandle(hComm);
   }
  }
  
  public byte[] Read(int NumBytes)
  {
   byte[] BufBytes;
   byte[] OutBytes;
   BufBytes = new byte[NumBytes];
   if (hComm!=INVALID_HANDLE_VALUE)
   {
    OVERLAPPED ovlCommPort = new OVERLAPPED();
    int BytesRead=0;
    ReadFile(hComm,BufBytes,NumBytes,ref BytesRead,ref ovlCommPort);
    try
    {
     OutBytes = new byte[BytesRead];
     Array.Copy(BufBytes,0,OutBytes,0,BytesRead);
    }
    catch
    {
     return BufBytes;
    }
    
   }
   else
   {
    throw(new ApplicationException("串口未打开!"));
   }
   return OutBytes;
   //   return BufBytes;
  }
  
  public void Write(byte[] WriteBytes)
  {
   if (hComm!=INVALID_HANDLE_VALUE)
   {
    OVERLAPPED ovlCommPort = new OVERLAPPED();
    int BytesWritten = 0;
    WriteFile(hComm,WriteBytes,WriteBytes.Length,ref BytesWritten,ref ovlCommPort);
   }
   else
   {
    throw(new ApplicationException("串口未打开!"));
   }  
  }

  public string GetGPS(string strGPS,string strFind)
  {
   ///从GPS中读取的数据中,找出想要的数据
   ///GPSstring原始字符串,
   ///strFind要查找的内容,X:经度,Y:纬度,T:时间,V:速度,是数字从1开始,即以“,”分隔的位置
   ///返回查找到指定位置的字符串
   string handerStr="$GPRMC";//GPS串头
   int findHander=strGPS.IndexOf(handerStr);//看是否含有GPS串头
   if (findHander<0)
   {
    return "-1";
   }
   else
   {
    strGPS=strGPS.Substring(findHander,strGPS.Length-findHander);
    string[] ArryTmp=strGPS.Split(",".ToCharArray());
    try
    {
     if(ArryTmp[2]=="V")
     {
      return "V";//没有信号
     }
     else
     {
      switch(strFind)
      {
       case "X":
        return DM2DD(ArryTmp[5]);
        
       case "Y":
        return DM2DD(ArryTmp[3]);
        
       case "T":
        return T2Time(ArryTmp[9],ArryTmp[1]);
        
       case "V":
        return Convert.ToString(Convert.ToDouble(ArryTmp[7])* 1.852);
        
       default:
        return "V";
        
      }
     }
    }
    catch
    {
     return "V";
    }
   }
  }

  public string T2Time(string strDate,string strTime)
  {
   string dT="20"+strDate.Substring(4,2)+"-"+strDate.Substring(2,2)+"-"+strDate.Substring(0,2);
   string TT=Convert.ToString(Convert.ToInt32(strTime.Substring(0,2)))+":"+strTime.Substring(2,2)+":"+strTime.Substring(4,2);
   DateTime T=Convert.ToDateTime(dT+" "+TT);
   T=T.AddHours(8);
   return T.ToString();
  }

  public string DM2DD(string DegreeMinutes)
  {
   //转换NMEA协议的“度分”格式为十进制“度度”格式
   string sDegree;
   string sMinute;
   string sReturn="";
   if(DegreeMinutes.IndexOf(".")==4)
   {
    //DegreeMinutes = Replace(DegreeMinutes, ".", "")
    //DM2DD = CDbl(Left(DegreeMinutes, 2)) + CDbl(Left(CStr(CDbl(Right(DegreeMinutes, Len(DegreeMinutes) – 2)) / 60), 8)) / 10000
    DegreeMinutes=DegreeMinutes.Replace(".","");
    double sDegree1=Convert.ToDouble(DegreeMinutes.Substring(0,2));
    double sDegree2=Convert.ToDouble(DegreeMinutes.Substring(2,DegreeMinutes.Length-2));
    string sTmp=Convert.ToString(sDegree2/60);
    sDegree2=Convert.ToDouble(sTmp.Substring(0,sTmp.Length));
    sDegree2=sDegree2/10000;
    sDegree=Convert.ToString(sDegree1+sDegree2);
    if(sDegree.Length>11)
     sDegree=sDegree.Substring(0,11);
    sReturn=sDegree;
   }
   else if(DegreeMinutes.IndexOf(".")==5)
   {
    //DegreeMinutes = Replace(DegreeMinutes, ".", "")
    //DM2DD = CDbl(Left(DegreeMinutes, 2)) + CDbl(Left(CStr(CDbl(Right(DegreeMinutes, Len(DegreeMinutes) – 2)) / 60), 8)) / 10000
    DegreeMinutes=DegreeMinutes.Replace(".","");
    double sMinute1=Convert.ToDouble(DegreeMinutes.Substring(0,3));
    double sMinute2=Convert.ToDouble(DegreeMinutes.Substring(3,DegreeMinutes.Length-2));
    string sTmp=Convert.ToString(sMinute2/60);
    sMinute2=Convert.ToDouble(sTmp.Substring(0,sTmp.Length));
    sMinute2=sMinute2/10000;
    sMinute=Convert.ToString(sMinute1+sMinute2);
    if(sMinute.Length>10)
     sMinute=sMinute.Substring(0,10);
    sReturn=sMinute;
   }
   return sReturn;
  }

  public bool ScanPort()
  {
   
   try
   {
    if (Opened)
    {
     Close();
     Open();
    }
    else
    {
     Open();//打开串口
     
    }
    byte[] bytRead=Read(512);
    Close();
    if(Encoding.ASCII.GetString(bytRead,0,bytRead.Length).IndexOf("$GP")>=0)
     return true;
    else
     return false;
   }
   catch
   {
    return false;
   }

  }
 }

 class HexCon
 {
  // 把十六进制字符串转换成字节型和把字节型转换成十六进制字符串 converter hex string to byte and byte to hex string
  public static string ByteToString(byte[] InBytes)
  {
   string StringOut="";
   foreach (byte InByte in InBytes)
   {
    StringOut=StringOut + String.Format("{0:X2} ",InByte);
   }
   return StringOut;
  }
  public static byte[] StringToByte(string InString)
  {
   string[] ByteStrings;
   ByteStrings = InString.Split(" ".ToCharArray());
   byte[] ByteOut;
   ByteOut = new byte[ByteStrings.Length-1];
   for (int i = 0;i==ByteStrings.Length-1;i++)
   {
    ByteOut[i] = Convert.ToByte(("0x" + ByteStrings[i]));
   }
   return ByteOut;
  }
 }
}

在别的class中调用时如Frmlogoin(是通过一个时间控件来循环的)

public class Frmlogin : System.Windows.Forms.Form
 {

private GPS ss_port=new GPS();

}

#region 读取GPS
  private void opengps(string ComPoint)
  {
   ss_port.PortNum = ComPoint;
   ss_port.BaudRate = 4800;
   ss_port.ByteSize = 8;
   ss_port.Parity = 0;
   ss_port.StopBits = 1;
   ss_port.ReadTimeout = 1000;

   try
   {
    if (ss_port.Opened)
    {
     ss_port.Close();
     ss_port.Open();
     timer1.Enabled=true;
    }
    else
    {
     ss_port.Open();//打开串口
     timer1.Enabled=true;
    }
    
   }
   catch
    
   {
//    MessageBox.Show("读取GPS错误!" ,"系统提示");
    
   }
  }
  private void timer1_Tick(object sender, System.EventArgs e)
  {
   
   if (ss_port.Opened)
    gpsread();
   else
    ss_port.Open();//打开串口
  }
  
  private void gpsread()
  {
   byte[] aa=ss_port.Read(512);
   string gpsinfo =System.Text.Encoding.ASCII.GetString(aa,0,aa.Length);
   GetParam.GpsLongitude=ss_port.GetGPS(gpsinfo,"X");
   GetParam.GpsLatitude=ss_port.GetGPS(gpsinfo,"Y");
   GetParam.GpsSpeed=ss_port.GetGPS(gpsinfo,"V");
   GetParam.GpsTime=ss_port.GetGPS(gpsinfo,"T");
   if(GetParam.GpsLongitude=="-1")
    GetParam.GpsState="0";
   if(GetParam.GpsLongitude=="V" && GetParam.GpsLatitude=="V")
    GetParam.GpsState="0";
   if(GetParam.GpsLongitude!="-1" && GetParam.GpsLongitude!="V")
    GetParam.GpsState="1";

    GetParam.GpsLongitude=(GetParam.GpsLongitude=="V") ? "0" : GetParam.GpsLongitude;
    GetParam.GpsLatitude=(GetParam.GpsLatitude=="V") ? "0" : GetParam.GpsLatitude;
    GetParam.GpsSpeed=(GetParam.GpsSpeed=="V") ? "0" : GetParam.GpsSpeed;
    GetParam.GpsTime=(GetParam.GpsTime=="V") ? "0" :GetParam.GpsTime;
   
  }
  private void GpsClose()
  {
   timer1.Enabled=false;
   if (ss_port.Opened)
    ss_port.Close();
  }
  #endregion