精华内容
下载资源
问答
  • py_引用

    2019-06-04 21:27:33
    在python中变量(列表,...,所有赋值)以引用方式传递 a=100 b=a a,b指向同一地址 id()返回变量在内存空间中的地址 此时修改A(B)的值,实为修改A(B)的指向 没有指向的会成为垃圾被回收 可变类型: ...

    在python中变量(列表,...,所有赋值)以引用方式传递

    a=100
    b=a
    

    a,b指向同一地址

    id()返回变量在内存空间中的地址

    此时修改A(B)的值,实为修改A(B)的指向

    没有指向的量会成为垃圾被回收

    可变类型:

    定义之后可以修改(不可哈希, 哈希地址无意义)

    列表

    a=[11,22,33]

    a[0]="fff"#true

    字典

    a={"name":"laowang"}

    a["name"]="Laowang"

    #a={"n ame"}

    #字典的key必须是不可变类型(数字,字符串,元组)

    不可变类型:

    定义之后不能修改(可以哈希,同一个值哈希结果相同)

    数字 a=100

    a=50 #a指向一个新值

    字符串 a="hello"

    a[0]="w" #报错

    a="whaha"#a指向一个新值

    元组 a=(11,22,33)

    a[0]="fff"#报错 元组不可修改

    展开全文
  • 33、socket通讯

    2019-05-21 16:39:00
    socket编程是网络常用的编程,我们通过在网络中创建socket关键字来实现网络间的通信,通过收集大量的资料,通过这一章节,充分的了解socket编程,文章用引用了大量大神的分析,加上自己的理解,做个总结性的文章 ...

    socket编程是网络常用的编程,我们通过在网络中创建socket关键字来实现网络间的通信,通过收集大量的资料,通过这一章节,充分的了解socket编程,文章用引用了大量大神的分析,加上自己的理解,做个总结性的文章

    1:socket大致介绍

          socket编程是一门技术,它主要是在网络通信中经常用到

          既然是一门技术,由于现在是面向对象的编程,一些计算机行业的大神通过抽象的理念,在现实中通过反复的理论或者实际的推导,提出了抽象的一些通信协议,基于tcp/ip协议,提出大致的构想,一些泛型的程序大牛在这个协议的基础上,将这些抽象化的理念接口化,针对协议提出的每个理念,专门的编写制定的接口,与其协议一一对应,形成了现在的socket标准规范,然后将其接口封装成可以调用的接口,供开发者使用

         目前,开发者开发出了很多封装的类来完善socket编程,都是更加方便的实现刚开始socket通信的各个环节,所以我们首先必须了解socket的通信原理,只有从本质上理解socket的通信,才可能快速方便的理解socket的各个环节,才能从底层上真正的把握

    2:TCP/IP协议

         要理解socket必须的得理解tcp/ip,它们之间好比送信的线路和驿站的作用,比如要建议送信驿站,必须得了解送信的各个细节。

         TCP/IP协议不同于iso的7个分层,它是根据这7个分层,将其重新划分,好比打扫卫生,本来有扫帚,垃圾斗,抹布,涂料,盆栽等就好比OSI的标准几个分层,tcp/ip根据用途和功能,将扫帚,垃圾斗放到粗略整理层,抹布涂料放到中度整理层,盆栽放到最终效果层。这里TCP/IP也对OSI的网络模型层进行了划分:大致如下:

    OSI模型:

     

    TCP/IP协议参考模型把所有的TCP/IP系列协议归类到四个抽象层中

    应用层:TFTP,HTTP,SNMP,FTP,SMTP,DNS,Telnet 等等

    传输层:TCP,UDP

    网络层:IP,ICMP,OSPF,EIGRP,IGMP

    数据链路层:SLIP,CSLIP,PPP,MTU

    每一抽象层建立在低一层提供的服务上,并且为高一层提供服务,看起来大概是这样子的

    通过上面的图形,由于底一层的需要向高一层的提供服务,我们大致的理解应用程序需要传输层的tcp和网络层的ip协议提供服务,但是我们这章要分析的socket它是在tcpip协议的那一部分呢,就好比,我们的通讯线路已经有明确的规定,我们的驿站要设计在哪个地方一样

    3:回过头再来理解socket

         到目前为止,大致的了解了应用程序和tcpip协议的大致关系,我们只是知道socket编程是在tcp/IP上的网络编程,但是socket在上述的模型的什么位置呢。这个位置被一个天才的理论家或者是抽象的计算机大神提出并且安排出来

    我们可以发现socket就在应用程序的传输层和应用层之间,设计了一个socket抽象层,传输层的底一层的服务提供给socket抽象层,socket抽象层再提供给应用层,问题又来了,应用层和socket抽象层之间和传输层,网络层之间如何通讯的呢,了解这个之前,我们还是回到原点

       要想理解socket编程怎么通过socket关键词实现服务器和客户端通讯,必须得实现的了解tcp/ip是怎么通讯的,在这个的基础上在去理解socket的握手通讯

        在tcp/ip协议中,tcp通过三次握手建立起一个tcp的链接,大致如下

         第一次握手:客户端尝试连接服务器,向服务器发送syn包,syn=j,客户端进入SYN_SEND状态等待服务器确认

        第二次握手:服务器接收客户端syn包并确认(ack=j+1),同时向客户端发送一个SYN包(syn=k),即SYN+ACK包,此时服务器进入SYN_RECV状态

       第三次握手:客户端收到服务器的SYN+ACK包,向服务器发送确认包ACK(ack=k+1),此包发送完毕,客户端和服务器进入ESTABLISHED状态,完成三次握手

        三次握手如下图:

         

         根据tcp的三次握手,socket也定义了三次握手,也许是参考tcp的三次握手,一些计算机大神们画出了socket的三次握手的模型图

         模型图如下:

         

         在上面图的基础上,如果我们得到上面的图形,需要我们自己开发一些接口,来满足上面的通讯的三次握手,问题就出来了,我们会需要开发哪些函数

    4:socket的一些接口函数原理

          通过上面的图,我们清楚,我们好比一些泛型的程序员,一些理论提供者提供给了我们上面的图形的理论,我们需要做的就是讲上面的图形的抽象化的东西具体化

          第一次握手:客户端需要发送一个syn j 包,试着去链接服务器端,于是客户端我们需要提供一个链接函数

         第二次握手:服务器端需要接收客户端发送过来的syn J+1 包,然后在发送ack包,所以我们需要有服务器端接受处理函数

         第三次握手:客户端的处理函数和服务器端的处理函数

         三次握手只是一个数据传输的过程,但是,我们传输前需要一些准备工作,比如将创建一个套接字,收集一些计算机的资源,将一些资源绑定套接字里面,以及接受和发送数据的函数等等,这些功能接口在一起构成了socket的编程

         下面大致的按照客户端和服务端将所需的函数详细的列举出来

    上面的两个图都概述了socket的通讯原理

    5:socket的一个例子,总结上述的问题

    详细就不在说明,通过一段代码详细的解释

    客户端的代码:

     

    1. #include <winsock2.h>                
    2. #include <stdio.h>  
    3. #pragma comment(lib,"ws2_32.lib")  
    4. int main()  
    5. {  
    6.     //SOCKET前的一些检查,检查协议库的版本,为了避免别的版本的socket,并且通过  
    7.     //WSAStartup启动对应的版本,WSAStartup的参数一个是版本信息,一个是一些详细的细节,注意高低位  
    8.     //WSAStartup与WSACleanup对应  
    9.     int err;  
    10.     WORD versionRequired;  
    11.     WSADATA wsaData;  
    12.     versionRequired=MAKEWORD(1,1);       
    13.     err=WSAStartup(versionRequired,&wsaData);//协议库的版本信息  
    14.   
    15.     //通过WSACleanup的返回值来确定socket协议是否启动  
    16.     if (!err)  
    17.     {  
    18.         printf("客户端嵌套字已经打开!\n");  
    19.     }  
    20.     else  
    21.     {  
    22.         printf("客户端的嵌套字打开失败!\n");  
    23.         return 0;//结束  
    24.     }  
    25.     //创建socket这个关键词,这里想一下那个图形中的socket抽象层  
    26.     //注意socket这个函数,他三个参数定义了socket的所处的系统,socket的类型,以及一些其他信息  
    27.     SOCKET clientSocket=socket(AF_INET,SOCK_STREAM,0);  
    28.   
    29.     //socket编程中,它定义了一个结构体SOCKADDR_IN来存计算机的一些信息,像socket的系统,  
    30.     //端口号,ip地址等信息,这里存储的是服务器端的计算机的信息  
    31.     SOCKADDR_IN clientsock_in;  
    32.     clientsock_in.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");  
    33.     clientsock_in.sin_family=AF_INET;  
    34.     clientsock_in.sin_port=htons(6000);  
    35.   
    36.     //前期定义了套接字,定义了服务器端的计算机的一些信息存储在clientsock_in中,  
    37.     //准备工作完成后,然后开始将这个套接字链接到远程的计算机  
    38.     //也就是第一次握手  
    39.   
    40.     connect(clientSocket,(SOCKADDR*)&clientsock_in,sizeof(SOCKADDR));//开始连接  
    41.   
    42.   
    43.     char receiveBuf[100];  
    44.   
    45.     //解释socket里面的内容  
    46.     recv(clientSocket,receiveBuf,101,0);  
    47.     printf("%s\n",receiveBuf);  
    48.   
    49.     //发送socket数据  
    50.     send(clientSocket,"hello,this is client",strlen("hello,this is client")+1,0);  
    51.   
    52.     //关闭套接字  
    53.     closesocket(clientSocket);  
    54.     //关闭服务  
    55.     WSACleanup();  
    56.     return 0;  
    57. }  


    对应的服务端的代码

     
    1. #include <winsock2.h>  
    2. #include <stdio.h>  
    3. #pragma comment(lib,"ws2_32.lib")  
    4. int main()  
    5. {  
    6.        //创建套接字,socket前的一些检查工作,包括服务的启动  
    7.        WORD myVersionRequest;  
    8.        WSADATA wsaData;  
    9.        myVersionRequest=MAKEWORD(1,1);  
    10.        int err;  
    11.        err=WSAStartup(myVersionRequest,&wsaData);  
    12.        if (!err)  
    13.        {  
    14.               printf("已打开套接字\n");              
    15.        }  
    16.        else  
    17.        {  
    18.               //进一步绑定套接字  
    19.               printf("嵌套字未打开!");  
    20.               return 0;  
    21.        }  
    22.        SOCKET serSocket=socket(AF_INET,SOCK_STREAM,0);//创建了可识别套接字  
    23.        //需要绑定的参数,主要是本地的socket的一些信息。  
    24.        SOCKADDR_IN addr;  
    25.        addr.sin_family=AF_INET;  
    26.        addr.sin_addr.S_un.S_addr=htonl(INADDR_ANY);//ip地址  
    27.        addr.sin_port=htons(6000);//绑定端口  
    28.   
    29.        bind(serSocket,(SOCKADDR*)&addr,sizeof(SOCKADDR));//绑定完成  
    30.        listen(serSocket,5);//其中第二个参数代表能够接收的最多的连接数  
    31.   
    32.        SOCKADDR_IN clientsocket;  
    33.        int len=sizeof(SOCKADDR);  
    34.        while (1)  
    35.        {  
    36.           //第二次握手,通过accept来接受对方的套接字的信息  
    37.               SOCKET serConn=accept(serSocket,(SOCKADDR*)&clientsocket,&len);//如果这里不是accept而是conection的话。。就会不断的监听  
    38.               char sendBuf[100];  
    39.               sprintf(sendBuf,"welcome %s to bejing",inet_ntoa(clientsocket.sin_addr));//找对对应的IP并且将这行字打印到那里  
    40.               //发送信息  
    41.           send(serConn,sendBuf,strlen(sendBuf)+1,0);  
    42.               char receiveBuf[100];//接收  
    43.               recv(serConn,receiveBuf,strlen(receiveBuf)+1,0);  
    44.               printf("%s\n",receiveBuf);  
    45.               closesocket(serConn);//关闭  
    46.               WSACleanup();//释放资源的操作  
    47.        }  
    48.        return 0;  
    49. }  



     

    6:上面例子用到的知识点

     

    (摘抄carter大神文章):

    服务器端:

    其过程是首先服务器方要先启动,并根据请求提供相应服务:

    (1)打开一通信通道并告知本地主机,它愿意在某一公认地址上的某端口(如FTP的端口可能为21)接收客户请求;

    (2)等待客户请求到达该端口;

    (3)接收到客户端的服务请求时,处理该请求并发送应答信号。接收到并发服务请求,要激活一新进程来处理这个客户请求(如UNIX系统中用fork、exec)。新进程处理此客户请求,并不需要对其它请求作出应答。服务完成后,关闭此新进程与客户的通信链路,并终止。

    (4)返回第(2)步,等待另一客户请求。

    (5)关闭服务器

    客户端:

    (1)打开一通信通道,并连接到服务器所在主机的特定端口;

    (2)向服务器发服务请求报文,等待并接收应答;继续提出请求......

    (3)请求结束后关闭通信通道并终止。

     

    从上面所描述过程可知:

    (1)客户与服务器进程的作用是非对称的,因此代码不同。

    (2)服务器进程一般是先启动的。只要系统运行,该服务进程一直存在,直到正常或强迫终止。

     

     

    7:下面就介绍一些API函数:(摘抄carter大神文章):

     

     

    创建套接字──socket()

    应用程序在使用套接字前,首先必须拥有一个套接字,系统调用socket()向应用程序提供创建套接字的手段,其调用格式如下: 

    1. SOCKET PASCAL FAR socket(int af, int type, int protocol)  

     

    该调用要接收三个参数:af、type、protocol。参数af指定通信发生的区域:AF_UNIX、AF_INET、AF_NS等,而DOS、WINDOWS中仅支持AF_INET,它是网际网区域。因此,地址族与协议族相同。参数type 描述要建立的套接字的类型。这里分三种:

    (1)一是TCP流式套接字(SOCK_STREAM)提供了一个面向连接、可靠的数据传输服务,数据无差错、无重复地发送,且按发送顺序接收。内设流量控制,避免数据流超限;数据被看作是字节流,无长度限制。文件传送协议(FTP)即使用流式套接字。

    (2)二是数据报式套接字(SOCK_DGRAM)提供了一个无连接服务。数据包以独立包形式被发送,不提供无错保证,数据可能丢失或重复,并且接收顺序混乱。网络文件系统(NFS)使用数据报式套接字。

    (3)三是原始式套接字(SOCK_RAW)该接口允许对较低层协议,如IP、ICMP直接访问。常用于检验新的协议实现或访问现有服务中配置的新设备。

    参数protocol说明该套接字使用的特定协议,如果调用者不希望特别指定使用的协议,则置为0,使用默认的连接模式。根据这三个参数建立一个套接字,并将相应的资源分配给它,同时返回一个整型套接字号。因此,socket()系统调用实际上指定了相关五元组中的“协议”这一元。

     

    指定本地地址──bind()

    当一个套接字用socket()创建后,存在一个名字空间(地址族),但它没有被命名。bind()将套接字地址(包括本地主机地址和本地端口地址)与所创建的套接字号联系起来,即将名字赋予套接字,以指定本地半相关。其调用格式如下: 

    1. int PASCAL FAR bind(SOCKET s, const struct sockaddr FAR * name, int namelen);  

     

    参数s是由socket()调用返回的并且未作连接的套接字描述符(套接字号)。参数name 是赋给套接字s的本地地址(名字),其长度可变,结构随通信域的不同而不同。namelen表明了name的长度。如果没有错误发生,bind()返回0。否则返回SOCKET_ERROR。

     

    建立套接字连接──connect()与accept()

    这两个系统调用用于完成一个完整相关的建立,其中connect()用于建立连接。accept()用于使服务器等待来自某客户进程的实际连接。

    connect()的调用格式如下

    1. int PASCAL FAR connect(SOCKET s, const struct sockaddr FAR * name, int namelen);  

     

    参数s是欲建立连接的本地套接字描述符。参数name指出说明对方套接字地址结构的指针。对方套接字地址长度由namelen说明。

    如果没有错误发生,connect()返回0。否则返回值SOCKET_ERROR。在面向连接的协议中,该调用导致本地系统和外部系统之间连接实际建立。

    由于地址族总被包含在套接字地址结构的前两个字节中,并通过socket()调用与某个协议族相关。因此bind()和connect()无须协议作为参数。

    accept()的调用格式如下:

    1. SOCKET PASCAL FAR accept(SOCKET s, struct sockaddr FAR* addr, int FAR* addrlen);  

     

    参数s为本地套接字描述符,在用做accept()调用的参数前应该先调用过listen()。addr 指向客户方套接字地址结构的指针,用来接收连接实体的地址。addr的确切格式由套接字创建时建立的地址族决定。addrlen 为客户方套接字地址的长度(字节数)。如果没有错误发生,accept()返回一个SOCKET类型的值,表示接收到的套接字的描述符。否则返回值INVALID_SOCKET。

    accept()用于面向连接服务器。参数addr和addrlen存放客户方的地址信息。调用前,参数addr 指向一个初始值为空的地址结构,而addrlen 的初始值为0;调用accept()后,服务器等待从编号为s的套接字上接受客户连接请求,而连接请求是由客户方的connect()调用发出的。当有连接请求到达时,accept()调用将请求连接队列上的第一个客户方套接字地址及长度放入addr 和addrlen,并创建一个与s有相同特性的新套接字号。新的套接字可用于处理服务器并发请求。

    四个套接字系统调用,socket()、bind()、connect()、accept(),可以完成一个完全五元相关的建立。socket()指定五元组中的协议元,它的用法与是否为客户或服务器、是否面向连接无关。bind()指定五元组中的本地二元,即本地主机地址和端口号,其用法与是否面向连接有关:在服务器方,无论是否面向连接,均要调用bind(),若采用面向连接,则可以不调用bind(),而通过connect()自动完成。若采用无连接,客户方必须使用bind()以获得一个唯一的地址。

    监听连接──listen()

    此调用用于面向连接服务器,表明它愿意接收连接。listen()需在accept()之前调用,其调用格式如下

    1. int PASCAL FAR listen(SOCKET s, int backlog);  

    参数s标识一个本地已建立、尚未连接的套接字号,服务器愿意从它上面接收请求。backlog表示请求连接队列的最大长度,用于限制排队请求的个数,目前允许的最大值为5。如果没有错误发生,listen()返回0。否则它返回SOCKET_ERROR。

    listen()在执行调用过程中可为没有调用过bind()的套接字s完成所必须的连接,并建立长度为backlog的请求连接队列。

    调用listen()是服务器接收一个连接请求的四个步骤中的第三步。它在调用socket()分配一个流套接字,且调用bind()给s赋于一个名字之后调用,而且一定要在accept()之前调用。

    数据传输──send()与recv()

    当一个连接建立以后,就可以传输数据了。常用的系统调用有send()和recv()。

    send()调用用于s指定的已连接的数据报或流套接字上发送输出数据,格式如下:

    1. int PASCAL FAR send(SOCKET s, const char FAR *buf, int len, int flags);  

     

    参数s为已连接的本地套接字描述符。buf 指向存有发送数据的缓冲区的指针,其长度由len 指定。flags 指定传输控制方式,如是否发送带外数据等。如果没有错误发生,send()返回总共发送的字节数。否则它返回SOCKET_ERROR。

    recv()调用用于s指定的已连接的数据报或流套接字上接收输入数据,格式如下:

    1. int PASCAL FAR recv(SOCKET s, char FAR *buf, int len, int flags);  

     

    参数s 为已连接的套接字描述符。buf指向接收输入数据缓冲区的指针,其长度由len 指定。flags 指定传输控制方式,如是否接收带外数据等。如果没有错误发生,recv()返回总共接收的字节数。如果连接被关闭,返回0。否则它返回SOCKET_ERROR。

    输入/输出多路复用──select()

    select()调用用来检测一个或多个套接字的状态。对每一个套接字来说,这个调用可以请求读、写或错误状态方面的信息。请求给定状态的套接字集合由一个fd_set结构指示。在返回时,此结构被更新,以反映那些满足特定条件的套接字的子集,同时, select()调用返回满足条件的套接字的数目,其调用格式如下:

    1. int PASCAL FAR select(int nfds, fd_set FAR * readfds, fd_set FAR * writefds, fd_set FAR * exceptfds, const struct timeval FAR * timeout);  

    参数nfds指明被检查的套接字描述符的值域,此变量一般被忽略。

    参数readfds指向要做读检测的套接字描述符集合的指针,调用者希望从中读取数据。参数writefds 指向要做写检测的套接字描述符集合的指针。exceptfds指向要检测是否出错的套接字描述符集合的指针。timeout指向select()函数等待的最大时间,如果设为NULL则为阻塞操作。select()返回包含在fd_set结构中已准备好的套接字描述符的总数目,或者是发生错误则返回SOCKET_ERROR。

     

    关闭套接字──closesocket()

    closesocket()关闭套接字s,并释放分配给该套接字的资源;如果s涉及一个打开的TCP连接,则该连接被释放。closesocket()的调用格式如下:

    1. BOOL PASCAL FAR closesocket(SOCKET s);  

    参数s待关闭的套接字描述符。如果没有错误发生,closesocket()返回0。否则返回值SOCKET_ERROR。

    转载于:https://www.cnblogs.com/yhxb/p/10900684.html

    展开全文
  • C#大量函数

    2013-02-01 12:59:24
    引用 必须添加 C# code? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 ...

    引用 必须添加

    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    using System;
    using System.Collections.Generic;
    using System.Text;
    using Microsoft.Win32; //对注册表操作
    using System.Collections; //使用Arraylist
    using System.Security.Cryptography;//加密解密
    using System.IO;    //文件操作
    using System.Runtime.InteropServices;//调用DLL DllImport
    using System.Management;  //获取硬件信息
    using System.Net;       //获取IP地址是用到
    using System.Drawing;   //image 
    using System.Net.NetworkInformation;    //ping 用到
    using System.Text.RegularExpressions;   //正则
    using System.Data;
    using System.Data.SqlClient;
    using Microsoft.VisualBasic;   //简体转繁体时用到
    using System.Web;       //html UrlEncode
     
     
    //注册表操作
        public class GF_RegReadWrite
        {
            
            /// <summary>
            /// 读取路径为keypath,键名为keyname的注册表键值,缺省返回def
            /// </summary>
            /// <param name="rootkey"></param>
            /// <param name="keypath">路径</param>
            /// <param name="keyname">键名</param>
            /// <param name="rtn">默认为null</param>
            /// <returns></returns>        
            static public bool GetRegVal(RegistryKey rootkey, string keypath, string keyname, out string rtn)
            {
                rtn = "";
                try
                {
                    RegistryKey key = rootkey.OpenSubKey(keypath);
                    rtn = key.GetValue(keyname).ToString();
                    key.Close();
                    return true;
                }
                catch
                {
                    return false;
                }
            }
          
            /// <summary>
            /// 设置路径为keypath,键名为keyname的注册表键值为keyval
            /// </summary>
            /// <param name="rootkey"></param>
            /// <param name="keypath"></param>
            /// <param name="keyname"></param>
            /// <param name="keyval"></param>
            /// <returns></returns>
            static public bool SetRegVal(RegistryKey rootkey, string keypath, string keyname, string keyval)
            {
                try
                {
                    RegistryKey key = rootkey.OpenSubKey(keypath, true);
                    if (key == null)
                        key = rootkey.CreateSubKey(keypath);
                    key.SetValue(keyname, (object)keyval);
                    key.Close();
                    return true;
                }
                catch
                {
                    return false;
                }
            }
     
            /// 创建路径为keypath的键
            private RegistryKey CreateRegKey(RegistryKey rootkey, string keypath)
            {
                try
                {
                    return rootkey.CreateSubKey(keypath);
                }
                catch
                {
                    return null;
                }
            }
            /// 删除路径为keypath的子项
            private bool DelRegSubKey(RegistryKey rootkey, string keypath)
            {
                try
                {
                    rootkey.DeleteSubKey(keypath);
                    return true;
                }
                catch
                {
                    return false;
                }
            }
            /// 删除路径为keypath的子项及其附属子项
            private bool DelRegSubKeyTree(RegistryKey rootkey, string keypath)
            {
                try
                {
                    rootkey.DeleteSubKeyTree(keypath);
                    return true;
                }
                catch
                {
                    return false;
                }
            }
            /// 删除路径为keypath下键名为keyname的键值
            private bool DelRegKeyVal(RegistryKey rootkey, string keypath, string keyname)
            {
                try
                {
                    RegistryKey key = rootkey.OpenSubKey(keypath, true);
                    key.DeleteValue(keyname);
                    return true;
                }
                catch
                {
                    return false;
                }
            }
        }
    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    //类型转换
        public class GF_Convert
        {
            /// <summary>
            /// 字符串 转换 char数组
            /// </summary>
            /// <param name="in_str"></param>
            /// <param name="in_len"></param>
            /// <returns></returns>
            public static char[] string2chararray(string in_str, int in_len)
            {
                char[] ch = new char[in_len];
                in_str.ToCharArray().CopyTo(ch, 0);
                return ch;
            }
     
            /// <summary>
            /// char数组 转换 字符串
            /// </summary>
            /// <param name="in_str"></param>
            /// <returns></returns>        
            public static string chararray2string(char[] in_str)
            {
                string out_str;
                out_str = new string(in_str);
                int i = out_str.IndexOf('\0', 0);
                if (i == -1)
                    i = 16;
                return out_str.Substring(0, i);
            }
     
            /// <summary>
            /// byte数组 转换 字符串
            /// </summary>
            /// <param name="in_str"></param>
            /// <returns></returns>
            public static string bytearray2string(byte[] in_str)
            {
                string out_str;
                out_str = System.Text.Encoding.Default.GetString(in_str);
                return out_str.Substring(0, out_str.IndexOf('\0', 0));
     
            }
     
            /// <summary>
            /// 字符串 转换 byte数组  注意转换出来会使原来的bytearray长度变短
            /// </summary>
            /// <param name="in_str"></param>
            /// <returns></returns>
            public static byte[] string2bytearray(string in_str)
            {
                return System.Text.Encoding.Default.GetBytes(in_str);
            }
     
            /// <summary>
            /// 字符串 转换 byte数组  长度为传如的长度
            /// </summary>
            /// <param name="in_str">传入字符串</param>
            /// <param name="iLen">目标字节数组长度</param>
            /// <returns></returns>
            public static byte[] string2bytearray(string in_str, int iLen)
            {
                byte[] bytes = new byte[iLen];
                byte[] bsources=System.Text.Encoding.Default.GetBytes(in_str);
                Array.Copy(bsources, bytes, bsources.Length);
                 
                 
                return bytes;
            }
             
            /// <summary>
            /// 将字符串编码为Base64字符串
            /// </summary>
            /// <param name="str"></param>
            /// <returns></returns>
            public static string Base64Encode(string str)
            {
                byte[] barray;
                barray = Encoding.Default.GetBytes(str);
                return Convert.ToBase64String(barray);
            }
     
            /// <summary>
            /// 将Base64字符串解码为普通字符串
            /// </summary>
            /// <param name="str"></param>
            /// <returns></returns>
            public static string Base64Decode(string str)
            {
                byte[] barray;
                try
                {
                    barray = Convert.FromBase64String(str);
                    return Encoding.Default.GetString(barray);
                }
                catch
                {
                    return str;
                }
            }
     
            /// <summary>
            /// 图片 转换 byte数组
            /// </summary>
            /// <param name="pic"></param>
            /// <param name="fmt"></param>
            /// <returns></returns>
            public static byte[] image_Image2Byte(Image pic, System.Drawing.Imaging.ImageFormat fmt)
            {
                MemoryStream mem = new MemoryStream();
                pic.Save(mem, fmt);
                mem.Flush();
                return mem.ToArray();
            }
            /// <summary>
            /// byte数组 转换 图片
            /// </summary>
            /// <param name="bytes"></param>
            /// <returns></returns>
            public static Image image_Byte2Image(byte[] bytes)
            {
                MemoryStream mem = new MemoryStream(bytes, true);
                mem.Read(bytes, 0, bytes.Length);
                mem.Flush();
                Image aa = Image.FromStream(mem);
                return aa;
            }
                     
            /// <summary>
            /// ip 转换 长整形
            /// </summary>
            /// <param name="strIP"></param>
            /// <returns></returns>
            public static long IP2Long(string strIP)
            {
     
                long[] ip = new long[4];
     
                string[] s = strIP.Split('.');
                ip[0] = long.Parse(s[0]);
                ip[1] = long.Parse(s[1]);
                ip[2] = long.Parse(s[2]);
                ip[3] = long.Parse(s[3]);
     
                return (ip[0] << 24) + (ip[1] << 16) + (ip[2] << 8) + ip[3];
            }
     
            /// <summary>
            /// 长整形 转换 IP
            /// </summary>
            /// <param name="longIP"></param>
            /// <returns></returns>
            public static string Long2IP(long longIP)
            {
     
     
                StringBuilder sb = new StringBuilder("");
                sb.Append(longIP >> 24);
                sb.Append(".");
     
                //将高8位置0,然后右移16为
     
     
                sb.Append((longIP & 0x00FFFFFF) >> 16);
                sb.Append(".");
     
     
                sb.Append((longIP & 0x0000FFFF) >> 8);
                sb.Append(".");
     
                sb.Append((longIP & 0x000000FF));
     
     
                return sb.ToString();
            }
     
            /// <summary>
            /// 将8位日期型整型数据转换为日期字符串数据
            /// </summary>
            /// <param name="date">整型日期</param>
            /// <param name="chnType">是否以中文年月日输出</param>
            /// <returns></returns>
            public static string FormatDate(int date, bool chnType)
            {
                string dateStr = date.ToString();
     
                if (date <= 0 || dateStr.Length != 8)
                    return dateStr;
     
                if (chnType)
                    return dateStr.Substring(0, 4) + "年" + dateStr.Substring(4, 2) + "月" + dateStr.Substring(6) + "日";
     
                return dateStr.Substring(0, 4) + "-" + dateStr.Substring(4, 2) + "-" + dateStr.Substring(6);
            }
     
     
            /// <summary>
            /// string型转换为bool型
            /// </summary>
            /// <param name="strValue">要转换的字符串</param>
            /// <param name="defValue">缺省值</param>
            /// <returns>转换后的bool类型结果</returns>
            public static bool StrToBool(object expression, bool defValue)
            {
                if (expression != null)
                    return StrToBool(expression, defValue);
     
                return defValue;
            }
     
            /// <summary>
            /// string型转换为bool型
            /// </summary>
            /// <param name="strValue">要转换的字符串</param>
            /// <param name="defValue">缺省值</param>
            /// <returns>转换后的bool类型结果</returns>
            public static bool StrToBool(string expression, bool defValue)
            {
                if (expression != null)
                {
                    if (string.Compare(expression, "true"true) == 0)
                        return true;
                    else if (string.Compare(expression, "false"true) == 0)
                        return false;
                }
                return defValue;
            }
    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
            /// <summary>
            /// 将对象转换为Int32类型
            /// </summary>
            /// <param name="strValue">要转换的字符串</param>
            /// <param name="defValue">缺省值</param>
            /// <returns>转换后的int类型结果</returns>
            public static int ObjectToInt(object expression)
            {
                return ObjectToInt(expression, 0);
            }
     
            /// <summary>
            /// 将对象转换为Int32类型
            /// </summary>
            /// <param name="strValue">要转换的字符串</param>
            /// <param name="defValue">缺省值</param>
            /// <returns>转换后的int类型结果</returns>
            public static int ObjectToInt(object expression, int defValue)
            {
                if (expression != null)
                    return StrToInt(expression.ToString(), defValue);
     
                return defValue;
            }
     
            /// <summary>
            /// 将对象转换为Int32类型,转换失败返回0
            /// </summary>
            /// <param name="str">要转换的字符串</param>
            /// <returns>转换后的int类型结果</returns>
            public static int StrToInt(string str)
            {
                return StrToInt(str, 0);
            }
     
            /// <summary>
            /// 将对象转换为Int32类型
            /// </summary>
            /// <param name="str">要转换的字符串</param>
            /// <param name="defValue">缺省值</param>
            /// <returns>转换后的int类型结果</returns>
            public static int StrToInt(string str, int defValue)
            {
                if (string.IsNullOrEmpty(str) || str.Trim().Length >= 11 || !Regex.IsMatch(str.Trim(), @"^([-]|[0-9])[0-9]*(\.\w*)?$"))
                    return defValue;
     
                int rv;
                if (Int32.TryParse(str, out rv))
                    return rv;
     
                return Convert.ToInt32(StrToFloat(str, defValue));
            }
     
            /// <summary>
            /// string型转换为float型
            /// </summary>
            /// <param name="strValue">要转换的字符串</param>
            /// <param name="defValue">缺省值</param>
            /// <returns>转换后的int类型结果</returns>
            public static float StrToFloat(object strValue, float defValue)
            {
                if ((strValue == null))
                    return defValue;
     
                return StrToFloat(strValue.ToString(), defValue);
            }
     
            /// <summary>
            /// string型转换为float型
            /// </summary>
            /// <param name="strValue">要转换的字符串</param>
            /// <param name="defValue">缺省值</param>
            /// <returns>转换后的int类型结果</returns>
            public static float ObjectToFloat(object strValue, float defValue)
            {
                if ((strValue == null))
                    return defValue;
     
                return StrToFloat(strValue.ToString(), defValue);
            }
     
            /// <summary>
            /// string型转换为float型
            /// </summary>
            /// <param name="strValue">要转换的字符串</param>
            /// <param name="defValue">缺省值</param>
            /// <returns>转换后的int类型结果</returns>
            public static float ObjectToFloat(object strValue)
            {
                return ObjectToFloat(strValue.ToString(), 0);
            }
     
            /// <summary>
            /// string型转换为float型
            /// </summary>
            /// <param name="strValue">要转换的字符串</param>
            /// <returns>转换后的int类型结果</returns>
            public static float StrToFloat(string strValue)
            {
                if ((strValue == null))
                    return 0;
     
                return StrToFloat(strValue.ToString(), 0);
            }
     
            /// <summary>
            /// string型转换为float型
            /// </summary>
            /// <param name="strValue">要转换的字符串</param>
            /// <param name="defValue">缺省值</param>
            /// <returns>转换后的int类型结果</returns>
            public static float StrToFloat(string strValue, float defValue)
            {
                if ((strValue == null) || (strValue.Length > 10))
                    return defValue;
     
                float intValue = defValue;
                if (strValue != null)
                {
                    bool IsFloat = Regex.IsMatch(strValue, @"^([-]|[0-9])[0-9]*(\.\w*)?$");
                    if (IsFloat)
                        float.TryParse(strValue, out intValue);
                }
                return intValue;
            }
     
            /// <summary>
            /// 将对象转换为日期时间类型
            /// </summary>
            /// <param name="str">要转换的字符串</param>
            /// <param name="defValue">缺省值</param>
            /// <returns>转换后的int类型结果</returns>
            public static DateTime StrToDateTime(string str, DateTime defValue)
            {
                if (!string.IsNullOrEmpty(str))
                {
                    DateTime dateTime;
                    if (DateTime.TryParse(str, out dateTime))
                        return dateTime;
                }
                return defValue;
            }
     
            /// <summary>
            /// 将对象转换为日期时间类型
            /// </summary>
            /// <param name="str">要转换的字符串</param>
            /// <returns>转换后的int类型结果</returns>
            public static DateTime StrToDateTime(string str)
            {
                return StrToDateTime(str, DateTime.Now);
            }
     
            /// <summary>
            /// 将对象转换为日期时间类型
            /// </summary>
            /// <param name="obj">要转换的对象</param>
            /// <returns>转换后的int类型结果</returns>
            public static DateTime ObjectToDateTime(object obj)
            {
                return StrToDateTime(obj.ToString());
            }
     
            /// <summary>
            /// 将对象转换为日期时间类型
            /// </summary>
            /// <param name="obj">要转换的对象</param>
            /// <param name="defValue">缺省值</param>
            /// <returns>转换后的int类型结果</returns>
            public static DateTime ObjectToDateTime(object obj, DateTime defValue)
            {
                return StrToDateTime(obj.ToString(), defValue);
            }
     
            /// <summary>
            /// 替换回车换行符为html换行符
            /// </summary>
            public static string StrFormat(string str)
            {
                string str2;
     
                if (str == null)
                {
                    str2 = "";
                }
                else
                {
                    str = str.Replace("\r\n""<br />");
                    str = str.Replace("\n""<br />");
                    str2 = str;
                }
                return str2;
            }
     
            /// <summary>
            /// 转换为简体中文
            /// </summary>
            public static string ToSChinese(string str)
            {
                return Strings.StrConv(str, VbStrConv.SimplifiedChinese, 0);
                 
            }
     
            /// <summary>
            /// 转换为繁体中文
            /// </summary>
            public static string ToTChinese(string str)
            {
                return Strings.StrConv(str, VbStrConv.TraditionalChinese, 0);
                 
            }
     
     
            /// <summary>
            /// 清除字符串数组中的重复项
            /// </summary>
            /// <param name="strArray">字符串数组</param>
            /// <param name="maxElementLength">字符串数组中单个元素的最大长度</param>
            /// <returns></returns>
            public static string[] DistinctStringArray(string[] strArray, int maxElementLength)
            {
                Hashtable h = new Hashtable();
     
                foreach (string in strArray)
                {
                    string k = s;
                    if (maxElementLength > 0 && k.Length > maxElementLength)
                    {
                        k = k.Substring(0, maxElementLength);
                    }
                    h[k.Trim()] = s;
                }
     
                string[] result = new string[h.Count];
     
                h.Keys.CopyTo(result, 0);
     
                return result;
            }
     
            /// <summary>
            /// 清除字符串数组中的重复项
            /// </summary>
            /// <param name="strArray">字符串数组</param>
            /// <returns></returns>
            public static string[] DistinctStringArray(string[] strArray)
            {
                return DistinctStringArray(strArray, 0);
            }
    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
        //加密解密
        public class GF_Encrypt
        {
            /// <summary>
            /// DES加密
            /// </summary>
            /// <param name="pToEncrypt">加密字符串</param>
            /// <param name="sKey">密钥</param>
            /// <returns></returns>
            public static string string_Encrypt(string pToEncrypt, string sKey)
            {
                if (pToEncrypt == ""return "";
                if (sKey.Length < 8) sKey = sKey + "xuE29xWp";
                if (sKey.Length > 8) sKey = sKey.Substring(0, 8);
                DESCryptoServiceProvider des = new DESCryptoServiceProvider();
                //把字符串放到byte数组中  
                //原来使用的UTF8编码,我改成Unicode编码了,不行  
                byte[] inputByteArray = Encoding.Default.GetBytes(pToEncrypt);
                //建立加密对象的密钥和偏移量  
                //原文使用ASCIIEncoding.ASCII方法的GetBytes方法  
                //使得输入密码必须输入英文文本  
                des.Key = ASCIIEncoding.Default.GetBytes(sKey);
                des.IV = ASCIIEncoding.Default.GetBytes(sKey);
                MemoryStream ms = new MemoryStream();
                CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
                //Write  the  byte  array  into  the  crypto  stream  
                //(It  will  end  up  in  the  memory  stream)  
                cs.Write(inputByteArray, 0, inputByteArray.Length);
                cs.FlushFinalBlock();
                //Get  the  data  back  from  the  memory  stream,  and  into  a  string  
                StringBuilder ret = new StringBuilder();
                foreach (byte in ms.ToArray())
                {
                    //Format  as  hex  
                    ret.AppendFormat("{0:X2}", b);
                }
                ret.ToString();
                return ret.ToString();
            }
     
            /// <summary>
            /// DES解密
            /// </summary>
            /// <param name="pToDecrypt">解密字符串</param>
            /// <param name="sKey">解密密钥</param>
            /// <param name="outstr">返回值</param>
            /// <returns></returns> 
            public static bool string_Decrypt(string pToDecrypt, string sKey, out string outstr)
            {
                if (pToDecrypt == "")
                {
                    outstr = "";
                    return true;
                };
                if (sKey.Length < 8) sKey = sKey + "xuE29xWp";
                if (sKey.Length > 8) sKey = sKey.Substring(0, 8);
                try
                {
                    DESCryptoServiceProvider des = new DESCryptoServiceProvider();
                    //Put  the  input  string  into  the  byte  array  
                    byte[] inputByteArray = new byte[pToDecrypt.Length / 2];
                    for (int x = 0; x < pToDecrypt.Length / 2; x++)
                    {
                        int i = (Convert.ToInt32(pToDecrypt.Substring(x * 2, 2), 16));
                        inputByteArray[x] = (byte)i;
                    }
                    //建立加密对象的密钥和偏移量,此值重要,不能修改  
                    des.Key = ASCIIEncoding.Default.GetBytes(sKey);
                    des.IV = ASCIIEncoding.Default.GetBytes(sKey);
                    MemoryStream ms = new MemoryStream();
                    CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
                    //Flush  the  data  through  the  crypto  stream  into  the  memory  stream  
                    cs.Write(inputByteArray, 0, inputByteArray.Length);
                    cs.FlushFinalBlock();
                    //Get  the  decrypted  data  back  from  the  memory  stream  
                    //建立StringBuild对象,CreateDecrypt使用的是流对象,必须把解密后的文本变成流对象  
                    StringBuilder ret = new StringBuilder();
                    outstr = System.Text.Encoding.Default.GetString(ms.ToArray());
                    return true;
                }
                catch
                {
                    outstr = "";
                    return false;
                }
            }
     
            /// <summary> 
            /// 加密
            /// </summary> 
            public class AES
            {
                //默认密钥向量
                private static byte[] Keys = { 0x41, 0x72, 0x65, 0x79, 0x6F, 0x75, 0x6D, 0x79, 0x53, 0x6E, 0x6F, 0x77, 0x6D, 0x61, 0x6E, 0x3F };
     
                public static string Encode(string encryptString, string encryptKey)
                {
                    encryptKey = GF_GET.GetSubString(encryptKey, 32, "");
                    encryptKey = encryptKey.PadRight(32, ' ');
     
                    RijndaelManaged rijndaelProvider = new RijndaelManaged();
                    rijndaelProvider.Key = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 32));
                    rijndaelProvider.IV = Keys;
                    ICryptoTransform rijndaelEncrypt = rijndaelProvider.CreateEncryptor();
     
                    byte[] inputData = Encoding.UTF8.GetBytes(encryptString);
                    byte[] encryptedData = rijndaelEncrypt.TransformFinalBlock(inputData, 0, inputData.Length);
     
                    return Convert.ToBase64String(encryptedData);
                }
     
                public static string Decode(string decryptString, string decryptKey)
                {
                    try
                    {
                        decryptKey = GF_GET.GetSubString(decryptKey, 32, "");
                        decryptKey = decryptKey.PadRight(32, ' ');
     
                        RijndaelManaged rijndaelProvider = new RijndaelManaged();
                        rijndaelProvider.Key = Encoding.UTF8.GetBytes(decryptKey);
                        rijndaelProvider.IV = Keys;
                        ICryptoTransform rijndaelDecrypt = rijndaelProvider.CreateDecryptor();
     
                        byte[] inputData = Convert.FromBase64String(decryptString);
                        byte[] decryptedData = rijndaelDecrypt.TransformFinalBlock(inputData, 0, inputData.Length);
     
                        return Encoding.UTF8.GetString(decryptedData);
                    }
                    catch
                    {
                        return "";
                    }
     
                }
     
            }
     
            /// <summary> 
            /// 加密
            /// </summary> 
            public class DES
            {
                //默认密钥向量
                private static byte[] Keys = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
     
                /// <summary>
                /// DES加密字符串
                /// </summary>
                /// <param name="encryptString">待加密的字符串</param>
                /// <param name="encryptKey">加密密钥,要求为8位</param>
                /// <returns>加密成功返回加密后的字符串,失败返回源串</returns>
                public static string Encode(string encryptString, string encryptKey)
                {
                    encryptKey = GF_GET.GetSubString(encryptKey, 8, "");
                    encryptKey = encryptKey.PadRight(8, ' ');
                    byte[] rgbKey = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 8));
                    byte[] rgbIV = Keys;
                    byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
                    DESCryptoServiceProvider dCSP = new DESCryptoServiceProvider();
                    MemoryStream mStream = new MemoryStream();
                    CryptoStream cStream = new CryptoStream(mStream, dCSP.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
                    cStream.Write(inputByteArray, 0, inputByteArray.Length);
                    cStream.FlushFinalBlock();
                    return Convert.ToBase64String(mStream.ToArray());
     
                }
     
                /// <summary>
                /// DES解密字符串
                /// </summary>
                /// <param name="decryptString">待解密的字符串</param>
                /// <param name="decryptKey">解密密钥,要求为8位,和加密密钥相同</param>
                /// <returns>解密成功返回解密后的字符串,失败返源串</returns>
                public static string Decode(string decryptString, string decryptKey)
                {
                    try
                    {
                        decryptKey = GF_GET.GetSubString(decryptKey, 8, "");
                        decryptKey = decryptKey.PadRight(8, ' ');
                        byte[] rgbKey = Encoding.UTF8.GetBytes(decryptKey);
                        byte[] rgbIV = Keys;
                        byte[] inputByteArray = Convert.FromBase64String(decryptString);
                        DESCryptoServiceProvider DCSP = new DESCryptoServiceProvider();
     
                        MemoryStream mStream = new MemoryStream();
                        CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
                        cStream.Write(inputByteArray, 0, inputByteArray.Length);
                        cStream.FlushFinalBlock();
                        return Encoding.UTF8.GetString(mStream.ToArray());
                    }
                    catch
                    {
                        return "";
                    }
                }
            }
     
            /// <summary>
            /// MD5函数
            /// </summary>
            /// <param name="str">原始字符串</param>
            /// <returns>MD5结果</returns>
            public static string MD5(string str)
            {
                byte[] b = Encoding.UTF8.GetBytes(str);
                b = new MD5CryptoServiceProvider().ComputeHash(b);
                string ret = "";
                for (int i = 0; i < b.Length; i++)
                    ret += b[i].ToString("x").PadLeft(2, '0');
     
                return ret;
            }
     
            /// <summary>
            /// SHA256函数
            /// </summary>
            /// /// <param name="str">原始字符串</param>
            /// <returns>SHA256结果</returns>
            public static string SHA256(string str)
            {
                byte[] SHA256Data = Encoding.UTF8.GetBytes(str);
                SHA256Managed Sha256 = new SHA256Managed();
                byte[] Result = Sha256.ComputeHash(SHA256Data);
                return Convert.ToBase64String(Result);  //返回长度为44字节的字符串
            }
        }
    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
        //读写INI
        public class GF_INI
        {
            [DllImport("kernel32")]
            private static extern long WritePrivateProfileString(string section, string key, string val, string filePath);
            [DllImport("kernel32")]
            private static extern int GetPrivateProfileString(string section, string key, string def, StringBuilder retVal, int size, string filePath);
            [DllImport("kernel32.dll")]
            public static extern int Beep(int dwFreq, int dwDuration);
     
            //读ini
            public static void iniFile_SetVal(string in_filename, string Section, string Key, string Value)
            {
                WritePrivateProfileString(Section, Key, Value, in_filename);
            }
     
            //写INI
            public static string iniFile_GetVal(string in_filename, string Section, string Key)
            {
                StringBuilder temp = new StringBuilder(255);
                int i = GetPrivateProfileString(Section, Key, "", temp, 255, in_filename);
                if (i == 0)
                    return "";
                else
                    return temp.ToString();
            }
        }
    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
        //硬件信息
        public class GF_Hardware
        {
            /// <summary>
            /// cpu序列号
            /// </summary>
            /// <returns></returns>
            public static string getID_CpuId()
            {
                string cpuInfo = "";//cpu序列号
                ManagementClass cimobject = new ManagementClass("Win32_Processor");
                ManagementObjectCollection moc = cimobject.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    cpuInfo = mo.Properties["ProcessorId"].Value.ToString();
                }
                return cpuInfo;
            }
     
            /// <summary>
            /// 硬盘ID号
            /// </summary>
            /// <returns></returns>
            public static string getID_HardDiskId()
            {
                string HDid = "";
                ManagementClass cimobject = new ManagementClass("Win32_DiskDrive");
                ManagementObjectCollection moc = cimobject.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    HDid = (string)mo.Properties["Model"].Value;
                }
                return HDid;
            }
     
            /// <summary>
            /// 获取网卡MacAddress
            /// </summary>
            /// <returns></returns>
            public static string getID_NetCardId()
            {
                string NCid = "";
                ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    if ((bool)mo["IPEnabled"] == true)
                        NCid = mo["MacAddress"].ToString();
                    mo.Dispose();
                }
                return NCid;
            }
     
     
             
        }
    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
        //网络部分
        public class GF_Network
        {
            /*
             * C#完整的通信代码(点对点,点对多,同步,异步,UDP,TCP)   
             * http://topic.csdn.net/u/20080619/08/dcef3fe2-f95b-4918-8edb-36d48a3d0528_2.html
             
             */
     
     
            /// <summary>
            /// 获取IP地址 返回第一个
            /// </summary>
            /// <returns></returns>
            public static string getIP_This()
            {
                IPHostEntry hostInfo = Dns.GetHostEntry(Dns.GetHostName());
                IPAddress[] address = hostInfo.AddressList;
                if (address.Length == 0)
                    return "";
                else
                    return address[0].ToString();
            }
     
            /// <summary>
            /// ping IP地址 timeout 局域网用200,广域网用2000
            /// </summary>
            /// <param name="ip">IP地址</param>
            /// <param name="timeout">超时 毫秒</param>
            /// <returns></returns>
            public static bool ping(string ip, int timeout)
            {            
                IPAddress ipadd;
                if (!IPAddress.TryParse(ip, out ipadd))
                {
                    return false;   
                }
                Ping pingSender = new Ping();
                PingReply reply = pingSender.Send(ip, timeout, new Byte[] { Convert.ToByte(1) });
                if (reply.Status == IPStatus.Success)
                    return true;
                else
                    return false;
            }
            /// <summary>
            /// 判读是否是IP地址
            /// </summary>
            /// <param name="in_str"></param>
            /// <returns></returns>
            public static bool IsIPStr(string in_str)
            {
                if (in_str.Replace(".""").Length != in_str.Length - 3)
                    return false;
                try
                {
                    IPAddress ip = IPAddress.Parse(in_str);
                    return true;
                }
                catch
                {
                    return false;
                }
            }
     
      
        }
    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
     //读写INI
        public class GF_INI
        {
            [DllImport("kernel32")]
            private static extern long WritePrivateProfileString(string section, string key, string val, string filePath);
            [DllImport("kernel32")]
            private static extern int GetPrivateProfileString(string section, string key, string def, StringBuilder retVal, int size, string filePath);
            [DllImport("kernel32.dll")]
            public static extern int Beep(int dwFreq, int dwDuration);
     
            //读ini
            public static void iniFile_SetVal(string in_filename, string Section, string Key, string Value)
            {
                WritePrivateProfileString(Section, Key, Value, in_filename);
            }
     
            //写INI
            public static string iniFile_GetVal(string in_filename, string Section, string Key)
            {
                StringBuilder temp = new StringBuilder(255);
                int i = GetPrivateProfileString(Section, Key, "", temp, 255, in_filename);
                if (i == 0)
                    return "";
                else
                    return temp.ToString();
            }
        }
    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
        //文件操作
        public class GF_File
        {
     
            /// <summary>
            /// 写日志文件
            /// </summary>
            /// <param name="sPath">    年月  例  2011-04</param>
            /// <param name="sFileName">月日  例  04-22</param>
            /// <param name="content">时间+  内容</param>
            /// <returns></returns>
            public static bool WriteLog(string sPath, string sFileName, string content)
            {
                try
                {
     
                    
                    StreamWriter sr;
                    if (!Directory.Exists(sPath))
                    {
                        Directory.CreateDirectory(sPath);
                    }
                    string v_filename = sPath+"\\"+ sFileName;
     
     
                    if (!File.Exists(v_filename)) //如果文件存在,则创建File.AppendText对象
                    {
                        sr = File.CreateText(v_filename);
                        sr.Close();
                    }
                    using (FileStream fs = new FileStream(v_filename, System.IO.FileMode.Append, System.IO.FileAccess.Write, System.IO.FileShare.Write))
                    {
                        using (sr = new StreamWriter(fs))
                        {
                             
                            sr.WriteLine(DateTime.Now.ToString("hh:mm:ss")+"     "+ content);
                            sr.Close();
                        }
                        fs.Close();
                    }
                    return true;
     
                }
                catch return false; }
            }
     
     
            /// <summary>
            /// 读取文本文件内容,每行存入arrayList 并返回arrayList对象
            /// </summary>
            /// <param name="sFileName"></param>
            /// <returns>arrayList</returns>
            public static ArrayList ReadFileRow(string sFileName)
            {
                string sLine = "";
                ArrayList alTxt = null;
                try
                {
                    using (StreamReader sr = new StreamReader(sFileName))
                    {
                        alTxt = new ArrayList();
     
                        while (!sr.EndOfStream)
                        {
                            sLine = sr.ReadLine();
                            if (sLine != "")
                            {
                                alTxt.Add(sLine.Trim());
                            }
     
                        }
                        sr.Close();
                    }
                }
                catch
                {
     
                }
                return alTxt;
            }
     
     
            /// <summary>
            /// 备份文件
            /// </summary>
            /// <param name="sourceFileName">源文件名</param>
            /// <param name="destFileName">目标文件名</param>
            /// <param name="overwrite">当目标文件存在时是否覆盖</param>
            /// <returns>操作是否成功</returns>
            public static bool BackupFile(string sourceFileName, string destFileName, bool overwrite)
            {
                if (!System.IO.File.Exists(sourceFileName))
                    throw new FileNotFoundException(sourceFileName + "文件不存在!");
     
                if (!overwrite && System.IO.File.Exists(destFileName))
                    return false;
     
                try
                {
                    System.IO.File.Copy(sourceFileName, destFileName, true);
                    return true;
                }
                catch (Exception e)
                {
                    throw e;
                }
            }
     
     
            /// <summary>
            /// 备份文件,当目标文件存在时覆盖
            /// </summary>
            /// <param name="sourceFileName">源文件名</param>
            /// <param name="destFileName">目标文件名</param>
            /// <returns>操作是否成功</returns>
            public static bool BackupFile(string sourceFileName, string destFileName)
            {
                return BackupFile(sourceFileName, destFileName, true);
            }
     
     
            /// <summary>
            /// 恢复文件
            /// </summary>
            /// <param name="backupFileName">备份文件名</param>
            /// <param name="targetFileName">要恢复的文件名</param>
            /// <param name="backupTargetFileName">要恢复文件再次备份的名称,如果为null,则不再备份恢复文件</param>
            /// <returns>操作是否成功</returns>
            public static bool RestoreFile(string backupFileName, string targetFileName, string backupTargetFileName)
            {
                try
                {
                    if (!System.IO.File.Exists(backupFileName))
                        throw new FileNotFoundException(backupFileName + "文件不存在!");
     
                    if (backupTargetFileName != null)
                    {
                        if (!System.IO.File.Exists(targetFileName))
                            throw new FileNotFoundException(targetFileName + "文件不存在!无法备份此文件!");
                        else
                            System.IO.File.Copy(targetFileName, backupTargetFileName, true);
                    }
                    System.IO.File.Delete(targetFileName);
                    System.IO.File.Copy(backupFileName, targetFileName);
                }
                catch (Exception e)
                {
                    throw e;
                }
                return true;
            }
     
            public static bool RestoreFile(string backupFileName, string targetFileName)
            {
                return RestoreFile(backupFileName, targetFileName, null);
            }
        }
    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
     //获取部分
        public class GF_GET
        {
            /// <summary>
            /// 根据坐标点获取屏幕图像
            /// </summary>
            /// <param name="x1">左上角横坐标</param>
            /// <param name="y1">左上角纵坐标</param>
            /// <param name="x2">右下角横坐标</param>
            /// <param name="y2">右下角纵坐标</param>
            /// <returns></returns>
            public static Image GetScreen(int x1, int y1, int x2, int y2)
            {
                int w = (x2 - x1);
                int h = (y2 - y1);
                Image myImage = new Bitmap(w, h);
                Graphics g = Graphics.FromImage(myImage);
                g.CopyFromScreen(new Point(x1, y1), new Point(0, 0), new Size(w, h));
                IntPtr dc1 = g.GetHdc();
                g.ReleaseHdc(dc1);
                return myImage;
            }
     
            /// <summary>
            /// 获取指定文件的扩展名 例:  .txt
            /// </summary>
            /// <param name="fileName">指定文件名</param>
            /// <returns>扩展名</returns>
            public static string GetFileExtName(string fileName)
            {
                if (GF_IsOk.IsStrNullOrEmpty(fileName) || fileName.IndexOf('.') <= 0)
                    return "";
                 
                fileName = fileName.ToLower().Trim();       
     
                 
                return fileName.Substring(fileName.LastIndexOf('.'), fileName.Length - fileName.LastIndexOf('.'));
            }
     
            public static string GetSubString(string p_SrcString, int p_Length, string p_TailString)
            {
                return GetSubString(p_SrcString, 0, p_Length, p_TailString);
            }
     
            public static string GetUnicodeSubString(string str, int len, string p_TailString)
            {
                string result = string.Empty;// 最终返回的结果
                int byteLen = System.Text.Encoding.Default.GetByteCount(str);// 单字节字符长度
                int charLen = str.Length;// 把字符平等对待时的字符串长度
                int byteCount = 0;// 记录读取进度
                int pos = 0;// 记录截取位置
                if (byteLen > len)
                {
                    for (int i = 0; i < charLen; i++)
                    {
                        if (Convert.ToInt32(str.ToCharArray()[i]) > 255)// 按中文字符计算加2
                            byteCount += 2;
                        else// 按英文字符计算加1
                            byteCount += 1;
                        if (byteCount > len)// 超出时只记下上一个有效位置
                        {
                            pos = i;
                            break;
                        }
                        else if (byteCount == len)// 记下当前位置
                        {
                            pos = i + 1;
                            break;
                        }
                    }
     
                    if (pos >= 0)
                        result = str.Substring(0, pos) + p_TailString;
                }
                else
                    result = str;
     
                return result;
            }
     
            /// <summary>
            /// 取指定长度的字符串
            /// </summary>
            /// <param name="p_SrcString">要检查的字符串</param>
            /// <param name="p_StartIndex">起始位置</param>
            /// <param name="p_Length">指定长度</param>
            /// <param name="p_TailString">用于替换的字符串</param>
            /// <returns>截取后的字符串</returns>
            public static string GetSubString(string p_SrcString, int p_StartIndex, int p_Length, string p_TailString)
            {
                string myResult = p_SrcString;
     
                Byte[] bComments = Encoding.UTF8.GetBytes(p_SrcString);
                foreach (char in Encoding.UTF8.GetChars(bComments))
                {    //当是日文或韩文时(注:中文的范围:\u4e00 - \u9fa5, 日文在\u0800 - \u4e00, 韩文为\xAC00-\xD7A3)
                    if ((c > '\u0800' && c < '\u4e00') || (c > '\xAC00' && c < '\xD7A3'))
                    {
                        //if (System.Text.RegularExpressions.Regex.IsMatch(p_SrcString, "[\u0800-\u4e00]+") || System.Text.RegularExpressions.Regex.IsMatch(p_SrcString, "[\xAC00-\xD7A3]+"))
                        //当截取的起始位置超出字段串长度时
                        if (p_StartIndex >= p_SrcString.Length)
                            return "";
                        else
                            return p_SrcString.Substring(p_StartIndex,
                                                           ((p_Length + p_StartIndex) > p_SrcString.Length) ? (p_SrcString.Length - p_StartIndex) : p_Length);
                    }
                }
     
                if (p_Length >= 0)
                {
                    byte[] bsSrcString = Encoding.Default.GetBytes(p_SrcString);
     
                    //当字符串长度大于起始位置
                    if (bsSrcString.Length > p_StartIndex)
                    {
                        int p_EndIndex = bsSrcString.Length;
     
                        //当要截取的长度在字符串的有效长度范围内
                        if (bsSrcString.Length > (p_StartIndex + p_Length))
                        {
                            p_EndIndex = p_Length + p_StartIndex;
                        }
                        else
                        {   //当不在有效范围内时,只取到字符串的结尾
     
                            p_Length = bsSrcString.Length - p_StartIndex;
                            p_TailString = "";
                        }
     
                        int nRealLength = p_Length;
                        int[] anResultFlag = new int[p_Length];
                        byte[] bsResult = null;
     
                        int nFlag = 0;
                        for (int i = p_StartIndex; i < p_EndIndex; i++)
                        {
                            if (bsSrcString[i] > 127)
                            {
                                nFlag++;
                                if (nFlag == 3)
                                    nFlag = 1;
                            }
                            else
                                nFlag = 0;
     
                            anResultFlag[i] = nFlag;
                        }
     
                        if ((bsSrcString[p_EndIndex - 1] > 127) && (anResultFlag[p_Length - 1] == 1))
                            nRealLength = p_Length + 1;
     
                        bsResult = new byte[nRealLength];
     
                        Array.Copy(bsSrcString, p_StartIndex, bsResult, 0, nRealLength);
     
                        myResult = Encoding.Default.GetString(bsResult);
                        myResult = myResult + p_TailString;
                    }
                }
     
                return myResult;
            }
     
            /// <summary>
            /// 获取Email HostName 例 liyangfd@gmail.com   获取出来时@gmail.com
            /// </summary>
            /// <param name="strEmail"></param>
            /// <returns></returns>
            public static string GetEmailHostName(string strEmail)
            {
                if (strEmail.IndexOf("@") < 0)
                {
                    return "";
                }
                return strEmail.Substring(strEmail.LastIndexOf("@")).ToLower();
            }
     
            /// <summary>
            /// 返回URL中结尾的文件名
            /// </summary>       
            public static string GetFilename(string url)
            {
                if (url == null)
                {
                    return "";
                }
                string[] strs1 = url.Split(new char[] { '/' });
                return strs1[strs1.Length - 1].Split(new char[] { '?' })[0];
            }
     
     
            /// <summary>
            /// 根据阿拉伯数字返回月份的名称(可更改为某种语言)
            /// </summary>   
            public static string[] Monthes
            {
                get
                {
                    return new string[] { "January""February""March""April""May""June""July""August""September""October""November""December" };
                }
            }
    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
        //判断部分
        public class GF_IsOk
        {
            /// <summary>
            /// 判读是否是IP地址
            /// </summary>
            /// <param name="in_str"></param>
            /// <returns></returns>
            public static bool IsIPStr(string  in_str)
            {
                IPAddress ip;
                return IPAddress.TryParse(in_str, out ip);
            }
     
            /// <summary>
            /// 判断是否是数字
            /// </summary>
            /// <param name="strNumber"></param>
            /// <returns></returns>
            public static bool IsNumber(string strNumber)
            {
     
                Regex objNotNumberPattern = new Regex("[^0-9.-]");
                Regex objTwoDotPattern = new Regex("[0-9]*[.][0-9]*[.][0-9]*");
                Regex objTwoMinusPattern = new Regex("[0-9]*[-][0-9]*[-][0-9]*");
                String strValidRealPattern = "^([-]|[.]|[-.]|[0-9])[0-9]*[.]*[0-9]+$";
                String strValidIntegerPattern = "^([-]|[0-9])[0-9]*$";
                Regex objNumberPattern = new Regex("(" + strValidRealPattern + ")|(" + strValidIntegerPattern + ")");
                return !objNotNumberPattern.IsMatch(strNumber) &&
                       !objTwoDotPattern.IsMatch(strNumber) &&
                       !objTwoMinusPattern.IsMatch(strNumber) &&
                       objNumberPattern.IsMatch(strNumber);
            }
            
            /// <summary>
            ///  判断是否是日期字符串
            /// </summary>
            /// <param name="in_str"></param>
            /// <returns></returns>
            public static bool IsDateStr_yyyymmdd(string in_str)
            {
                if (in_str == ""return true;
                if (in_str.Length != 8) return false;
                return IsDateStr(in_str);
            }
     
            /// <summary>
            /// 判断是否是日期字符串
            /// </summary>
            /// <param name="in_str"></param>
            /// <returns></returns>
            public static bool IsDateStr(string in_str)
            {
                if (in_str == ""return true;
                if (in_str.Length == 8)
                    in_str = in_str.Substring(0, 4) + "-" + in_str.Substring(4, 2) + "-" + in_str.Substring(6, 2);
                DateTime dtDate;
                bool bValid = true;
                try
                {
                    dtDate = DateTime.Parse(in_str);
                }
                catch (FormatException)
                {
                    // 如果解析方法失败则表示不是日期性数据
                    bValid = false;
                }
                return bValid;
            }
     
            /// <summary>
            /// 判断字符串中是否包含汉字,有返回true 否则为false
            /// </summary>
            /// <param name="str"></param>
            /// <returns></returns>
            public static bool IsExistHanZi(string str)
            {
                Regex reg = new Regex(@"[\u4e00-\u9fa5]");//正则表达式
                if (reg.IsMatch(str))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
     
     
            /// <summary>
            /// 字段串是否为Null或为""(空)
            /// </summary>
            /// <param name="str"></param>
            /// <returns></returns>
            public static bool IsStrNullOrEmpty(string str)
            {
                if (str == null || str.Trim() == string.Empty)
                    return true;
     
                return false;
            }
     
            /// <summary>
            /// 返回文件是否存在
            /// </summary>
            /// <param name="filename">文件名</param>
            /// <returns>是否存在</returns>
            public static bool IsFileExists(string filename)
            {
                return System.IO.File.Exists(filename);
            }
     
     
            /// <summary>
            /// 检测是否符合email格式
            /// </summary>
            /// <param name="strEmail">要判断的email字符串</param>
            /// <returns>判断结果</returns>
            public static bool IsValidEmail(string strEmail)
            {
                return Regex.IsMatch(strEmail, @"^[\w\.]+([-]\w+)*@[A-Za-z0-9-_]+[\.][A-Za-z0-9-_]");
            }
     
            public static bool IsValidDoEmail(string strEmail)
            {
                return Regex.IsMatch(strEmail, @"^@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$");
            }
            /// <summary>
            /// 检测是否是正确的Url
            /// </summary>
            /// <param name="strUrl">要验证的Url</param>
            /// <returns>判断结果</returns>
            public static bool IsURL(string strUrl)
            {
                return Regex.IsMatch(strUrl, @"^(http|https)\://([a-zA-Z0-9\.\-]+(\:[a-zA-Z0-9\.&%\$\-]+)*@)*((25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9])|localhost|([a-zA-Z0-9\-]+\.)*[a-zA-Z0-9\-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{1,10}))(\:[0-9]+)*(/($|[a-zA-Z0-9\.\,\?\'\\\+&%\$#\=~_\-]+))*$");
            }
     
            /// <summary>
            /// 判断是否为base64字符串
            /// </summary>
            /// <param name="str"></param>
            /// <returns></returns>
            public static bool IsBase64String(string str)
            {
                //A-Z, a-z, 0-9, +, /, =
                return Regex.IsMatch(str, @"[A-Za-z0-9\+\/\=]");
            }
     
            /// <summary>
            /// 检测是否有Sql危险字符
            /// </summary>
            /// <param name="str">要判断字符串</param>
            /// <returns>判断结果</returns>
            public static bool IsSafeSqlString(string str)
            {
                return !Regex.IsMatch(str, @"[-|;|,|\/|\(|\)|\[|\]|\}|\{|%|@|\*|!|\']");
            }
     
     
     
     
     
        }
    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
       /// <summary>
            /// 获得伪静态页码显示链接
            /// </summary>
            /// <param name="curPage">当前页数</param>
            /// <param name="countPage">总页数</param>
            /// <param name="url">超级链接地址</param>
            /// <param name="extendPage">周边页码显示个数上限</param>
            /// <returns>页码html</returns>
            public static string GetStaticPageNumbers(int curPage, int countPage, string url, string expname, int extendPage)
            {
                return GetStaticPageNumbers(curPage, countPage, url, expname, extendPage, 0);
            }
     
     
            /// <summary>
            /// 获得伪静态页码显示链接
            /// </summary>
            /// <param name="curPage">当前页数</param>
            /// <param name="countPage">总页数</param>
            /// <param name="url">超级链接地址</param>
            /// <param name="extendPage">周边页码显示个数上限</param>
            /// <param name="forumrewrite">当前版块是否使用URL重写</param>
            /// <returns>页码html</returns>
            public static string GetStaticPageNumbers(int curPage, int countPage, string url, string expname, int extendPage, int forumrewrite)
            {
                int startPage = 1;
                int endPage = 1;
     
                string t1 = "<a href=\"" + url + "-1" + expname + "\">&laquo;</a>";
                string t2 = "<a href=\"" + url + "-" + countPage + expname + "\">&raquo;</a>";
     
                if (forumrewrite == 1)
                {
                    t1 = "<a href=\"" + url + "/1/list" + expname + "\">&laquo;</a>";
                    t2 = "<a href=\"" + url + "/" + countPage + "/list" + expname + "\">&raquo;</a>";
                }
     
                if (forumrewrite == 2)
                {
                    t1 = "<a href=\"" + url + "/\">&laquo;</a>";
                    t2 = "<a href=\"" + url + "/" + countPage + "/\">&raquo;</a>";
                }
     
                if (countPage < 1) countPage = 1;
                if (extendPage < 3) extendPage = 2;
     
                if (countPage > extendPage)
                {
                    if (curPage - (extendPage / 2) > 0)
                    {
                        if (curPage + (extendPage / 2) < countPage)
                        {
                            startPage = curPage - (extendPage / 2);
                            endPage = startPage + extendPage - 1;
                        }
                        else
                        {
                            endPage = countPage;
                            startPage = endPage - extendPage + 1;
                            t2 = "";
                        }
                    }
                    else
                    {
                        endPage = extendPage;
                        t1 = "";
                    }
                }
                else
                {
                    startPage = 1;
                    endPage = countPage;
                    t1 = "";
                    t2 = "";
                }
     
                StringBuilder s = new StringBuilder("");
     
                s.Append(t1);
                for (int i = startPage; i <= endPage; i++)
                {
                    if (i == curPage)
                    {
                        s.Append("<span>");
                        s.Append(i);
                        s.Append("</span>");
                    }
                    else
                    {
                        s.Append("<a href=\"");
                        if (forumrewrite == 1)
                        {
                            s.Append(url);
                            if (i != 1)
                            {
                                s.Append("/");
                                s.Append(i);
                            }
                            s.Append("/list");
                            s.Append(expname);
                        }
                        else if (forumrewrite == 2)
                        {
                            s.Append(url);
                            s.Append("/");
                            if (i != 1)
                            {
                                s.Append(i);
                                s.Append("/");
                            }
                        }
                        else
                        {
                            s.Append(url);
                            if (i != 1)
                            {
                                s.Append("-");
                                s.Append(i);
                            }
                            s.Append(expname);
                        }
                        s.Append("\">");
                        s.Append(i);
                        s.Append("</a>");
                    }
                }
                s.Append(t2);
     
                return s.ToString();
            }
     
     
            /// <summary>
            /// 获得帖子的伪静态页码显示链接
            /// </summary>
            /// <param name="expname"></param>
            /// <param name="countPage">总页数</param>
            /// <param name="url">超级链接地址</param>
            /// <param name="extendPage">周边页码显示个数上限</param>
            /// <returns>页码html</returns>
            public static string GetPostPageNumbers(int countPage, string url, string expname, int extendPage)
            {
                int startPage = 1;
                int endPage = 1;
                int curPage = 1;
     
                string t1 = "<a href=\"" + url + "-1" + expname + "\">&laquo;</a>";
                string t2 = "<a href=\"" + url + "-" + countPage + expname + "\">&raquo;</a>";
     
                if (countPage < 1) countPage = 1;
                if (extendPage < 3) extendPage = 2;
     
                if (countPage > extendPage)
                {
                    if (curPage - (extendPage / 2) > 0)
                    {
                        if (curPage + (extendPage / 2) < countPage)
                        {
                            startPage = curPage - (extendPage / 2);
                            endPage = startPage + extendPage - 1;
                        }
                        else
                        {
                            endPage = countPage;
                            startPage = endPage - extendPage + 1;
                            t2 = "";
                        }
                    }
                    else
                    {
                        endPage = extendPage;
                        t1 = "";
                    }
                }
                else
                {
                    startPage = 1;
                    endPage = countPage;
                    t1 = "";
                    t2 = "";
                }
     
                StringBuilder s = new StringBuilder("");
     
                s.Append(t1);
                for (int i = startPage; i <= endPage; i++)
                {
                    s.Append("<a href=\"");
                    s.Append(url);
                    s.Append("-");
                    s.Append(i);
                    s.Append(expname);
                    s.Append("\">");
                    s.Append(i);
                    s.Append("</a>");
                }
                s.Append(t2);
     
                return s.ToString();
            }
    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
     /// <summary>
            /// 获得页码显示链接
            /// </summary>
            /// <param name="curPage">当前页数</param>
            /// <param name="countPage">总页数</param>
            /// <param name="url">超级链接地址</param>
            /// <param name="extendPage">周边页码显示个数上限</param>
            /// <returns>页码html</returns>
            public static string GetPageNumbers(int curPage, int countPage, string url, int extendPage)
            {
                return GetPageNumbers(curPage, countPage, url, extendPage, "page");
            }
     
            /// <summary>
            /// 获得页码显示链接
            /// </summary>
            /// <param name="curPage">当前页数</param>
            /// <param name="countPage">总页数</param>
            /// <param name="url">超级链接地址</param>
            /// <param name="extendPage">周边页码显示个数上限</param>
            /// <param name="pagetag">页码标记</param>
            /// <returns>页码html</returns>
            public static string GetPageNumbers(int curPage, int countPage, string url, int extendPage, string pagetag)
            {
                return GetPageNumbers(curPage, countPage, url, extendPage, pagetag, null);
            }
     
            /// <summary>
            /// 获得页码显示链接
            /// </summary>
            /// <param name="curPage">当前页数</param>
            /// <param name="countPage">总页数</param>
            /// <param name="url">超级链接地址</param>
            /// <param name="extendPage">周边页码显示个数上限</param>
            /// <param name="pagetag">页码标记</param>
            /// <param name="anchor">锚点</param>
            /// <returns>页码html</returns>
            public static string GetPageNumbers(int curPage, int countPage, string url, int extendPage, string pagetag, string anchor)
            {
                if (pagetag == "")
                    pagetag = "page";
                int startPage = 1;
                int endPage = 1;
     
                if (url.IndexOf("?") > 0)
                    url = url + "&";
                else
                    url = url + "?";
     
                string t1 = "<a href=\"" + url + "&" + pagetag + "=1";
                string t2 = "<a href=\"" + url + "&" + pagetag + "=" + countPage;
                if (anchor != null)
                {
                    t1 += anchor;
                    t2 += anchor;
                }
                t1 += "\">&laquo;</a>";
                t2 += "\">&raquo;</a>";
     
                if (countPage < 1)
                    countPage = 1;
                if (extendPage < 3)
                    extendPage = 2;
     
                if (countPage > extendPage)
                {
                    if (curPage - (extendPage / 2) > 0)
                    {
                        if (curPage + (extendPage / 2) < countPage)
                        {
                            startPage = curPage - (extendPage / 2);
                            endPage = startPage + extendPage - 1;
                        }
                        else
                        {
                            endPage = countPage;
                            startPage = endPage - extendPage + 1;
                            t2 = "";
                        }
                    }
                    else
                    {
                        endPage = extendPage;
                        t1 = "";
                    }
                }
                else
                {
                    startPage = 1;
                    endPage = countPage;
                    t1 = "";
                    t2 = "";
                }
     
                StringBuilder s = new StringBuilder("");
     
                s.Append(t1);
                for (int i = startPage; i <= endPage; i++)
                {
                    if (i == curPage)
                    {
                        s.Append("<span>");
                        s.Append(i);
                        s.Append("</span>");
                    }
                    else
                    {
                        s.Append("<a href=\"");
                        s.Append(url);
                        s.Append(pagetag);
                        s.Append("=");
                        s.Append(i);
                        if (anchor != null)
                        {
                            s.Append(anchor);
                        }
                        s.Append("\">");
                        s.Append(i);
                        s.Append("</a>");
                    }
                }
                s.Append(t2);
     
                return s.ToString();
            }
     
            /// <summary>
            /// 判断文件流是否为UTF8字符集
            /// </summary>
            /// <param name="sbInputStream">文件流</param>
            /// <returns>判断结果</returns>
            private static bool IsUTF8(FileStream sbInputStream)
            {
                int i;
                byte cOctets;  // octets to go in this UTF-8 encoded character 
                byte chr;
                bool bAllAscii = true;
                long iLen = sbInputStream.Length;
     
                cOctets = 0;
                for (i = 0; i < iLen; i++)
                {
                    chr = (byte)sbInputStream.ReadByte();
     
                    if ((chr & 0x80) != 0) bAllAscii = false;
     
                    if (cOctets == 0)
                    {
                        if (chr >= 0x80)
                        {
                            do
                            {
                                chr <<= 1;
                                cOctets++;
                            }
                            while ((chr & 0x80) != 0);
     
                            cOctets--;
                            if (cOctets == 0)
                                return false;
                        }
                    }
                    else
                    {
                        if ((chr & 0xC0) != 0x80)
                            return false;
     
                        cOctets--;
                    }
                }
     
                if (cOctets > 0)
                    return false;
     
                if (bAllAscii)
                    return false;
     
                return true;
            }
    C# code?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
      //数据库
        public class GF_DA
        {
            /// <summary>
            /// 执行SQL语句 sConnStr 连接字符串,sql执行的sql命令 返回第一行第一列
            /// </summary>
            /// <param name="sConnStr"></param>
            /// <param name="sql"></param>
            /// <returns></returns>
            public static object ExecSQL(string sConnStr, string sql)
            {
                using (SqlConnection conn = new SqlConnection(sConnStr))
                {
                    using (SqlCommand cmd = new SqlCommand())
                    {
                        try
                        {
                            conn.Open();
                            cmd.Connection = conn;
                            cmd.CommandText = sql;
                            return cmd.ExecuteScalar();
                        }
                        catch
                        {
                            return null;
                        }
                    }
     
                }
            }
     
            /// <summary>
            /// 执行SQL数组  
            /// </summary>
            /// <param name="sConnStr"></param>
            /// <param name="alSql"></param>
            /// <param name="iLen"></param>
            public static void ExecSQL(string sConnStr, ArrayList alSql, int iLen)
            {
                using (SqlConnection conn = new SqlConnection(sConnStr))
                {
                    using (SqlCommand cmd = new SqlCommand())
                    {
                        try
                        {
                            conn.Open();
                            cmd.Connection = conn;
                            for (int i = 0; i < alSql.Count; i++)
                            {
                                cmd.CommandText = alSql[i].ToString();
                                cmd.ExecuteNonQuery();
                                 
                            }
                        }
                        catch
                        {
     
                        }
                    }
     
                }
            }
     
            /// <summary>
            /// 填充数据 返回DataTable
            /// </summary>
            /// <param name="sConnStr"></param>
            /// <param name="sql"></param>
            /// <param name="sTableName"></param>
            /// <returns></returns>
            public static DataTable DataFill(string sConnStr, string sql, string sTableName)
            {
                using (SqlConnection conn = new SqlConnection(sConnStr))
                {
                    using (SqlCommand cmd = new SqlCommand())
                    {
                        DataSet ds = new DataSet();
                        try
                        {
                            conn.Open();
                            cmd.Connection = conn;
                            cmd.CommandText = sql;
                            SqlDataAdapter ap = new SqlDataAdapter(cmd);
                            ap.Fill(ds, sTableName);
                            return ds.Tables[0];
                        }
                        catch
                        {
                            return null;
                        }
                    }
     
     
                }
            }
        }

    转载地址:http://bbs.csdn.net/topics/360193753?page=1















    展开全文
  • Java基础33-其他流

    2019-02-23 15:08:21
    到目前为止,使用的字节流、字符流都是无缓冲输入、输出流,这就意味着,每次的读、写操作都会交个操作系统来处理。这样的做法可能会对系统的性能造成很大的...在实际编程的过程中,这些对象的引用还要传入装饰类...

    到目前为止,使用的字节流、字符流都是无缓冲输入、输出流,这就意味着,每次的读、写操作都会交个操作系统来处理。这样的做法可能会对系统的性能造成很大的影响,因为每次操作都可能引发磁盘硬件的读、写或网络的访问,这些磁盘硬件读、写和网络访问会占用大量系统资源,影响效率。

    1.缓冲流

    前面介绍的字节流和字符流,因为没有使用缓冲区等其他原因,一般不直接使用。在实际编程的过程中,这些对象的引用还要传入装饰类中去,动态地给这些对象增加额外的功能,形成新的对象,这些新的对象才是实际需要的字节流和字符流对象,这个过程同时也说明了装饰器模式是使用的,装饰类的使用如下所示:

    FIleInputStream 对象1 = new FileInputStream(地址);
    装饰器类 对象2 = new 装饰器类(类名1);

    缓冲流是一种装饰器类,目的是让原字节流、字符流新增缓冲的功能。以字符缓冲流为例进行说明,字符缓冲流从字符流中读取、写入字符,不立刻要求系统进行处理,而是缓冲部分字符,从而实现按规定字符数、按行等方式的高效读取、写入。缓冲区的大小可以指定(通过缓冲流构造方法指定),也可以使用默认的大小,多少情况下默认大小以够使用。

    通过一个输入字符流和输出字符流创建输入字符缓冲流和输出字符缓冲流的代码如下。

    BufferedReader 对象名 1= new BuffereReader(new FileReader(文件地址));
    BufferedWriter 对象名2 = new BuffereWriter(new FileWriter(文件地址));

    2.字节流转换为字符流

    案例代码如下:

    package cn.lanqiao01;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class Test {
    	public static void main(String[] args) throws IOException {
    		BufferedReader in = null;
    		try {
    			in = new BufferedReader(new InputStreamReader(System.in));
    			String s=in.readLine();
    		}finally {
    			if(in!=null) {
    				try {
    					in.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    	
    }

    3.数据流

    对于某问题:将一个 long 类型的数据写到文件中,有办法吗?

        转字符串 → 通过 getbytes() 写进去,费劲,而且在此过程中 long 类型的数需要不断地转换.

          现在,Java 中的数据流能够很好的解决这个问题(不需要转换,直接写进去)

    1. DataInputStream 与 DataOutputStream 分别继承自 InputStream、OutputStream, 它属于处理流,需要分别套接在 InputStream、OutputStream 类型的节点流上面.

    2. DataInputStream 与 DataOutputStream 提供了可以存取与机器无关的 java 原始类型数据(如:int, double 等)的方法.

    3. DataInputStream 与 DataOutputStream 的构造方法为:

      DataInputStream(InputStream in )

      DataOutputStream(OutputStram out)

    【注】UTF(Unicode 字符串):网络上经常使用;UTF-8 比 UTF-16 省空间.

    Demo_1:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    import java.io.*;

    class Test {

        public static void main(String[] args) {

            ByteArrayOutputStream baos = new ByteArrayOutputStream(); // 首先在内存上面分配一个字节数组,某根管道接上去(接在内存上面的一块内容上面)

            DataOutputStream dos = new DataOutputStream(baos); // baos管道不好用,外那再套接一根管道dos

            try {

                dos.writeDouble(Math.random());

                dos.writeBoolean(false);

                ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); // 通过baos的toByteArray()就能够拿到关于这个数组的引用

                System.out.println(bais.available()); // bais中有多少个字节可供读;

                DataInputStream dis = new DataInputStream(bais); // 从字节数组中读的时候,里面是什么(字符串吗?...不清楚),故需要再套接一层管道

                System.out.println(dis.readDouble()); // 先写先读

                System.out.println(dis.readBoolean());

                dos.close();

                baos.close();

                dis.close();

                bais.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

    运行结果:

    9
    0.1088353250890215
    false

     

     

     

     

     

    展开全文
  • 很感恩,能够在上帝奇妙地带领下,经过多方的资源整合后,可以从我手中完成一款对教会内部制作PPT过程中,引用圣经的这个小环节能够发挥一些小小的作用的小插件。因制作本插件时,也大量用到VSTO开发的一些技术,...
  • Bug集

    2016-05-10 14:50:00
     报错中 大量错误信息结尾.o后缀的 ,一般是引用头文件 import了 .m 文件 ##tableView  1>设置table view的行数时出错 6-04-15 20:33:01.728 lol可编辑[7016:239219] -[ViewController tableView:...
  • 11 强调文字12 添加删除线13 标题14 引用 2 代码格式化 21 行内代码21 区块代码 3 列表 31 无序列表32 有序列表33 列表嵌套34 多段列表 4 链接 41 行内式链接42 参考式链接43 页内导航 5 图片6 分割线7...
  • 前言 基本语法 1文本格式化 11 强调文字 12 添加删除线 13 标题 14 引用 2 代码格式化 21 行内代码 21 区块代码 ...33 列表嵌套 ...1.前言Markdown是一种轻级的标记语言,把作者从繁杂的排版工作中解放出来,
  • 使用xmlhttp.send()方法的参数来传递大容量的数据使用xmlhttp.send()方法的参数来传递大容量的数据Postedon2006-03-2715:33DoNet鸟阅读(448)评论(0)编辑收藏引用收藏至365Key所属分类:DoNet技术这个标题不知道怎么取...
  • Cortex-M系列:ARM架构与汇编指令集

    千次阅读 2020-02-05 00:29:35
    文中大量内容是引用的,请见谅。 文中比的比较仅到Armv8-M架构的Cortex-M33,没涉及后续新版本(也没法预计到)。 目录 1 ARM处理器分类 2 基于Thumb-2技术的Thumb®指令集 3 参考资料 1 ARM处理器分类 ARM的...
  • 引用本文: 杨震, 张东, 李洁, 张建雄. 工业互联网中的标识解析技术. 电信科学[J], 2017, 33(11): 134-140 doi:10.11959/j.issn.1000-0801.2017296 YANG Zhen, ZHANG Dong, LI Jie, ZHANG Jianxiong. Identifier ...
  • 2020-08-11

    2020-08-11 19:44:36
    引用记录:https://jingyan.baidu.com/article/c33e3f484ada64ea15cbb5ac.html Android线程优先级设置方法技巧  对于Android平台上的线程优先级设置来说可以处理很多并发线程的阻塞问题,比如很多无关紧要的...
  • sqlhelper用法

    2014-04-08 12:03:19
    (2012-07-12 23:29:33) 转载▼ Ⅰ.引言  使用该类目的就是让使用者更方便、更安全的对数据库的操作,既是除了在SQLHelper类以外的所有类将不用引用对数据库操作的任何类与语句,无须担心数据库的...
  • 疯狂内核之——进程管理子系统

    热门讨论 2011-05-30 23:31:24
    目录 1 进程的组织 5 ...4.11.1 引用计数器 231 4.11.2 大内核锁 231 4.11.3 内存描述符读/写信号 232 4.11.4 slab高速缓存链表的信号 233 4.11.5 索引节点的信号 233 4.12 内核同步与互斥的总结 233
  • 深入学习shell脚本艺术

    热门讨论 2011-02-22 04:01:01
    33. 杂项 33.1. 交互式和非交互式的shells和脚本 33.2. Shell 包装 33.3. 测试和比较: 另一种方法 33.4. 递归 33.5. 彩色脚本 33.6. 优化 33.7. 各种小技巧 33.8. 安全话题 33.8.1. 被感染的脚本 33.8....
  • 进一步阅读的参考资料 33 第三章 语言运行期的强化 34 一、本节内容 34 二、 表达式 34 二、函数对象包装器 37 三、右值引用 40 总结 48 第四章 对标准库的扩充:新增容器 49 一、本节内容 49 二、 和 49 ...
  • 4.2.2 字符串字面 125 4.2.3 给字符串使用基于范围的for循环 126 4.3 间接数据访问 128 4.3.1 指针的概念 128 4.3.2 声明指针 128 4.3.3 使用指针 129 4.3.4 初始化指针 130 4.3.5 指向char类型的指针 132 ...
  • 创建日志文件 11-33 监视磁盘空间 11-34 管理日志文件 11-34 周期性创建文件 11-34 根据要求创建文件 11-35 从不创建新文件 11-35 删除日志文件 11-35 记录到中央数据库 11-36 将报警日志文件手动导出为ODBC格式 11-...
  • 2 引用标准 7 3 定义和缩写 7 3.1 能量管理系统(EMS) 7 3.2 应用程序接口(API) 7 4 CIM规范 7 4.1 CIM建模表示法 7 4.2 CIM包 8 4.2.1 Core(核心包) 9 4.2.2 Topology(拓扑包) 10 4.2.3 Wires(电线包) 10 4.2.4 ...
  • Ruby编程语言

    2012-11-14 19:00:33
     4.1字面和关键字字面86  4.2变量引用87  4.3常量引用88  4.4方法调用89  4.5赋值92  4.6操作符100  第5章语句和控制结构117  5.1条件式118  5.2循环127  5.3迭代器和可枚举对象130  5.4代码块140  ...
  • 2. 规范性引用文件 6 3. 术语、定义和缩略语 6 4. 概述 7 4.1. 背景 7 4.2. 测试目的 8 4.3. 测试环境基本要求 9 4.3.1. 网络结构与规模 9 4.3.2. 测试区域 9 4.3.3. 业务模型 9 4.3.4. 设备要求 9 4.3.5. 终端要求 ...
  • 5.2.2 mscomm控件的引用 144 5.2.3 mscomm控件的常用属性 145 5.2.4 mscomm控件的事件 149 5.2.5 mscomm控件通信步骤 151 5.3 应用api函数 152 5.3.1 动态链接库与api函数 152 5.3.2 vb与动态...
  • 5.2.2 mscomm控件的引用 144 5.2.3 mscomm控件的常用属性 145 5.2.4 mscomm控件的事件 149 5.2.5 mscomm控件通信步骤 151 5.3 应用api函数 152 5.3.1 动态链接库与api函数 152 5.3.2 vb与动态...
  • Perl高效编程(第2版)

    2011-10-21 13:23:44
    条款61 别将匿名数组和列表直接搞混淆 条款62 通过匿名散列创建C风格的struct结构 条款63 小心循环数据结构 条款64 用map和grep操作复杂数据结构 第7章 CPAN 条款65 以非管理员权限安装CPAN模块 条款66 ...
  • 讨论课样题 1.下列页面置换算法说法正确的有(B)。...引用串长度为p,包含了n个不同的页号,无论用什么算法,缺页次数不会少于(C)。 A. m B.p C.n D. min(m, n) 解:缺页次数不会少于页数,因为要调入内存。
  • • sample07.htm 在同一个HTML文档中多次引用外部脚本文件 • sample08.htm 使用外部脚本文件和嵌入的JavaScript代码 • sample09.htm 边加载边解析的JavaScript代码 • sample10....
  • (2)他编著和主编的书发行超过4500万册,是读者最多的科技作家。我国平均每30人、知识分子每1.5人就拥有1本谭浩强教授编著的书。(3)他和别人合作编著的《BASIC语言》发行了1200万册,创科技书籍发行的世界...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 326
精华内容 130
关键字:

引用量33