Code Resource

SpringBoot2异常处理回滚事务详解(自动回滚/手动回滚/部分回滚）

2021-11-19T23:45:00.001-05:00

1 问题背景

有时候，我们总是需要再SpringBoot2中对一个Service方法做一个完整的事务，发现异常时，进行回滚，然后又能返回错误信息。

事务定义

事务，就是一组操作数据库的动作集合。事务是现代数据库理论中的核心概念之一。如果一组处理步骤或者全部发生或者一步也不执行，我们称该组处理步骤为一个事务。当所有的步骤像一个操作一样被完整地执行，我们称该事务被提交。由于其中的一部分或多步执行失败，导致没有步骤被提交，则事务必须回滚到最初的系统状态。

事务特点

1.原子性：一个事务中所有对数据库的操作是一个不可分割的操作序列，要么全做要么全不做

2.一致性：数据不会因为事务的执行而遭到破坏

3.隔离性：一个事物的执行，不受其他事务的干扰，即并发执行的事物之间互不干扰

4.持久性：一个事物一旦提交，它对数据库的改变就是永久的。

2 @Transactional 事务实现机制

Spring 为事务管理提供了丰富的功能支持。Spring 事务管理分为编码式和声明式的两种方式。

（1）编程式事务指的是通过编码方式实现事务；

（2）声明式事务基于 AOP,将具体业务逻辑与事务处理解耦。

声明式事务管理使业务代码逻辑不受污染, 因此在实际使用中声明式事务用的比较多。

声明式事务有两种方式：

（1）一种是在配置文件（xml）中做相关的事务规则声明，

（2）另一种是基于@Transactional 注解的方式。

注释配置是目前流行的使用方式，因此本文将着重介绍基于@Transactional 注解的事务管理。

在应用系统调用声明了 @Transactional 的目标方法时，Spring Framework 默认使用 AOP 代理，在代码运行时生成一个代理对象，根据 @Transactional 的属性配置信息，这个代理对象决定该声明 @Transactional 的目标方法是否由拦截器 TransactionInterceptor 来使用拦截，在 TransactionInterceptor 拦截时，会在目标方法开始执行之前创建并加入事务，并执行目标方法的逻辑, 最后根据执行情况是否出现异常，利用抽象事务管理器 AbstractPlatformTransactionManager 操作数据源 DataSource 提交或回滚事务。

Spring AOP 代理有 CglibAopProxy 和 JdkDynamicAopProxy 两种，以 CglibAopProxy 为例，对于 CglibAopProxy，需要调用其内部类的 DynamicAdvisedInterceptor 的 intercept 方法。对于 JdkDynamicAopProxy，需要调用其 invoke 方法。

开启事务

方式1：在 xml 配置中的事务配置信息

<tx:annotation-driven />

<bean id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

</bean>

方式2：使用@EnableTransactionManagement 注解也可以启用事务管理功能

3 场景

3.1 场景一：自动回滚（直接抛出，不try/catch）

@Override

@Transactional(rollbackFor = Exception.class)

public Object submitOrder() throws Exception {

success();

//假如exception这个操作数据库的方法会抛出异常，方法success()对数据库的操作会回滚。

exception();

return ApiReturnUtil.success();

}

3.2 场景二：手动回滚（进行try/catch，回滚并抛出）

@Override

@Transactional(rollbackFor = Exception.class)

public Object submitOrder (){

success();

try {

exception();

} catch (Exception e) {

e.printStackTrace();

//手工回滚异常

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

return ApiReturnUtil.error();

}

return ApiReturnUtil.success();

}

3.3 补充：回滚部分异常

使用Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint(); 设置回滚点。

使用TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);回滚到savePoint。

@Override

@Transactional(rollbackFor = Exception.class)

public Object submitOrder (){

success();

//只回滚以下异常，

Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();

try {

exception();

} catch (Exception e) {

e.printStackTrace();

//手工回滚异常

TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);

return ApiReturnUtil.error();

}

return ApiReturnUtil.success();

}

3.4 使用DataSourceTransactionManager

springboot 开启事务以及手动提交事务，可以在服务类上加上两个注解

@Autowired

DataSourceTransactionManager dataSourceTransactionManager;

@Autowired

TransactionDefinition transactionDefinition;

手动开启事务

TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition);

手动提交事务

dataSourceTransactionManager.commit(transactionStatus);//提交

手动回滚事务

dataSourceTransactionManager.rollback(transactionStatus);//最好是放在catch 里面,防止程序异常而事务一直卡在哪里未提交

4 spring boot controller设置 @Transactional 不回滚的解决办法

在spring boot 中，使用事务非常简单，直接在方法上面加入@Transactional 就可以实现，以下是我的做法

@GetMapping("delete")

@ResponseBody

@Transactional

public void delete(@RequestParam("id") int id) {

try {

//delete country

this.repository.delete(id);

if(id == 1){

throw Exception("测试事务");

}

//delete city

this.repository.deleteByCountryId(id);

}catch (Exception e){

logger.error("delete false:" + e.getMessage());

return new MessageBean(101,"delete false");

}

发现事务不回滚，即 this.repository.delete(id); 成功把数据删除了。

原因：

默认spring事务只在发生未被捕获的 RuntimeException 时才回滚。

spring aop 异常捕获原理：被拦截的方法需显式抛出异常，并不能经任何处理，这样aop代理才能捕获到方法的异常，才能进行回滚，默认情况下aop只捕获 RuntimeException 的异常，但可以通过配置来捕获特定的异常并回滚。

换句话说在service的方法中不使用try catch 或者在catch中最后加上throw new runtimeexcetpion（），这样程序异常时才能被aop捕获进而回滚。

解决方案：

方案1：例如service层处理事务，那么service中的方法中不做异常捕获，或者在catch语句中最后增加throw new RuntimeException()语句，以便让aop捕获异常再去回滚，并且在service上层（webservice客户端，view层action）要继续捕获这个异常并处理

方案2：在service层方法的catch语句中增加：TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();语句，手动回滚，这样上层就无需去处理异常

@GetMapping("delete")

@ResponseBody

@Transactional

public Object delete(@RequestParam("id") int id){

if (id < 1){

return new MessageBean(101,"parameter wrong: id = " + id) ;

}

try {

//delete country

this.countryRepository.delete(id);

//delete city

this.cityRepository.deleteByCountryId(id);

return new MessageBean(200,"delete success");

}catch (Exception e){

logger.error("delete false:" + e.getMessage());

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

return new MessageBean(101,"delete false");

}

5 避免 Spring 的 AOP 的自调用问题

在 Spring 的 AOP 代理下，只有目标方法由外部调用，目标方法才由 Spring 生成的代理对象来管理，这会造成自调用问题。若同一类中的其他没有@Transactional 注解的方法内部调用有@Transactional 注解的方法，有@Transactional 注解的方法的事务被忽略，不会发生回滚。见清单 5 举例代码展示。

清单 5.自调用问题举例

@Service

public class OrderService {

private void insert() {

insertOrder();

}

@Transactional

public void insertOrder() {

//insert log info

//insertOrder

//updateAccount

}

insertOrder 尽管有@Transactional 注解，但它被内部方法 insert()调用，事务被忽略，出现异常事务不会发生回滚。

这样一个错org.springframework.transaction.NoTransactionException: No transaction aspect-managed TransactionStatus in scope

比如例子:

下面我们来看两种写法，第一种

@Transactional

public UserEntity login1(UserEntity user) {

userDao.update(6);

if(userDao.update(6)){

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

}

return user;

}

第二种

public UserEntity login(UserEntity user) {

this.test();

return user;

}

@Transactional

public void test(){

userDao.update(6);

if(userDao.update(6)){

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

}

第一种写法的时候，回滚是起作用的.

第二种写法的时候就会报错，错误就是一开始提到的: org.springframework.transaction.NoTransactionException: No transaction aspect-managed TransactionStatus in scope

为什么会这样呢？

此错在没有Transaction无法回滚事务。自调用导致@Transactional 失效。

spring里事务是用注解配置的，当一个方法没有接口，单单只是一个方法不是服务时，事务的注解是不起作用的，需要回滚时就会报错。

出现这个问题的根本原因在于AOP的实现原理。由于@Transactional 的实现原理是AOP，AOP的实现原理是动态代理，换句话说，自调用时不存在代理对象的调用，这时不会产生我们注解@Transactional 配置的参数，自然无效了。

虽然可以直接从容器中获取代理对象，但这样有侵入之嫌，不推荐。

也是在此记录一笔：

事务必须用在服务上，且一个服务一个事务，不得嵌套。

sping的事务是通过注解配置上去的，而下面的那个方法并没有接口，在实现类里面只是一个简单的方法而已，对于事务的注解来说没有任何作用，所以在这个方法里面调用回滚的方法自然就报错了。

所以在以后的项目中如果你要使用事务，那么请记住，一个服务一个事务，一次请求一个事务，千万不要想着用调用方法，然后再一个方法上面加事务。你只能调用另外一个服务，在另外一个服务上面加事务。

解决方法：

1、可以在类服务上加事务：

@Transactional

public class MyTransactional {

public UserEntity login(UserEntity user) {

this.test();

return user;

}

//@Transactional 服务上加了@Transactional后这里可以不加

public void test(){

userDao.update(6);

if(userDao.update(6)){

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

}

2、使用AspectJ 取代 Spring AOP 代理

上面的两个问题@Transactional 注解只应用到 public 方法和自调用问题，是由于使用 Spring AOP 代理造成的。为解决这两个问题，使用 AspectJ 取代 Spring AOP 代理。

需要将下面的 AspectJ 信息添加到 xml 配置信息中。

清单 6. AspectJ 的 xml 配置信息

<tx:annotation-driven mode="aspectj" />

<bean id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

</bean>

</bean

class="org.springframework.transaction.aspectj.AnnotationTransactionAspect"

factory-method="aspectOf">

</bean>

同时在 Maven 的 pom 文件中加入 spring-aspects 和 aspectjrt 的 dependency 以及 aspectj-maven-plugin。

清单 7. AspectJ 的 pom 配置信息

<groupId>org.springframework</groupId>

<artifactId>spring-aspects</artifactId>

<version>4.3.2.RELEASE</version>

</dependency>

<groupId>org.aspectj</groupId>

<artifactId>aspectjrt</artifactId>

</dependency>

<groupId>org.codehaus.mojo</groupId>

<artifactId>aspectj-maven-plugin</artifactId>

<groupId>org.springframework</groupId>

<artifactId>spring-aspects</artifactId>

</aspectLibrary>

</aspectLibraries>

</configuration>

<goals>

<goal>compile</goal>

<goal>test-compile</goal>

</goals>

</execution>

</executions>

</plugin>

5 详细说明

5.1 事务管理方式

在Spring中，事务有两种实现方式，分别是编程式事务管理和声明式事务管理两种方式。

编程式事务管理：编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。

声明式事务管理：建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

声明式事务管理不需要入侵代码，通过@Transactional就可以进行事务操作，更快捷而且简单，推荐使用。

5.2 事务处理 @Transactional注解的使用

Spring团队的建议是你在具体的类（或类的方法）上使用 @Transactional 注解，而不要使用在类所要实现的任何接口上。你当然可以在接口上使用 @Transactional 注解，但是这将只能当你设置了基于接口的代理时它才生效。因为注解是不能继承的，这就意味着如果你正在使用基于类的代理时，那么事务的设置将不能被基于类的代理所识别，而且对象也将不会被事务代理所包装（将被确认为严重的）。因此，请接受Spring团队的建议并且在具体的类上使用 @Transactional 注解。

@Transactional 注解应该只被应用到 public 修饰的方法上。如果你在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解，它也不会报错，但是这个被注解的方法将不会展示已配置的事务设置。

Spring的AOP即声明式事务管理默认是针对unchecked exception回滚。也就是默认对RuntimeException()异常或是其子类进行事务回滚。checked异常,即Exception可try{}捕获的不会回滚，因此对于我们自定义异常，通过rollbackFor进行设定。

如果我们需要捕获异常后，同时进行回滚，通过TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();进行手动回滚操作。

使用Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint(); 设置回滚点，使用TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);回滚到savePoint。

5.3 事务提交方式

默认情况下，数据库处于自动提交模式。每一条语句处于一个单独的事务中，在这条语句执行完毕时，如果执行成功则隐式的提交事务，如果执行失败则隐式的回滚事务。

对于正常的事务管理，是一组相关的操作处于一个事务之中，因此必须关闭数据库的自动提交模式。不过，这个我们不用担心，spring会将底层连接的自动提交特性设置为false。也就是在使用spring进行事物管理的时候，spring会将是否自动提交设置为false，等价于JDBC中的 connection.setAutoCommit(false);，在执行完之后在进行提交，connection.commit(); 。

5.4 注解@Transactional常用配置

参数名称功能描述

readOnly 该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示可读写，默认值为false。例如：@Transactional(readOnly=true)

rollbackFor rollbackFor 该属性用于设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚。例如：指定单一异常类：@Transactional(rollbackFor=RuntimeException.class)指定多个异常类：@Transactional(rollbackFor={RuntimeException.class, Exception.class})

rollbackForClassName 该属性用于设置需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，则进行事务回滚。例如：指定单一异常类名称@Transactional(rollbackForClassName=”RuntimeException”)指定多个异常类名称：@Transactional(rollbackForClassName={“RuntimeException”,”Exception”})

noRollbackFor 该属性用于设置不需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，不进行事务回滚。例如：指定单一异常类：@Transactional(noRollbackFor=RuntimeException.class)指定多个异常类：@Transactional(noRollbackFor={RuntimeException.class, Exception.class})

noRollbackForClassName 该属性用于设置不需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，不进行事务回滚。例如：指定单一异常类名称：@Transactional(noRollbackForClassName=”RuntimeException”)指定多个异常类名称：@Transactional(noRollbackForClassName={“RuntimeException”,”Exception”})

propagation 该属性用于设置事务的传播行为。例如：@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)

isolation 该属性用于设置底层数据库的事务隔离级别，事务隔离级别用于处理多事务并发的情况，通常使用数据库的默认隔离级别即可，基本不需要进行设置

timeout 该属性用于设置事务的超时秒数，默认值为-1表示永不超时

事物超时设置: @Transactional(timeout=30) //默认是30秒

5.5 Propagation的属性（事务的传播行为）

例如：@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)

Propagation属性

含义

REQUIRED

默认值在有transaction状态下执行；如当前没有transaction，则创建新的transaction；

SUPPORTS

如当前有transaction，则在transaction状态下执行；如果当前没有transaction，在无transaction状态下执行；

MANDATORY

必须在有transaction状态下执行，如果当前没有transaction，则抛出异常IllegalTransactionStateException；

REQUIRES_NEW

创建新的transaction并执行；如果当前已有transaction，则将当前transaction挂起；

NOT_SUPPORTED

在无transaction状态下执行；如果当前已有transaction，则将当前transaction挂起；

NEVER

在无transaction状态下执行；如果当前已有transaction，则抛出异常IllegalTransactionStateException。

5.6 事务5种隔离级别

例如：@Transactional(isolation = Isolation.READ_COMMITTED)

隔离级别含义

DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.

另外四个与JDBC的隔离级别相对应；

READ_UNCOMMITTED 最低的隔离级别。事实上我们不应该称其为隔离级别，因为在事务完成前，其他事务可以看到该事务所修改的数据。而在其他事务提交前，该事务也可以看到其他事务所做的修改。可能导致脏，幻，不可重复读

READ_COMMITTED 大多数数据库的默认级别。在事务完成前，其他事务无法看到该事务所修改的数据。遗憾的是，在该事务提交后，你就可以查看其他事务插入或更新的数据。这意味着在事务的不同点上，如果其他事务修改了数据，你就会看到不同的数据。可防止脏读，但幻读和不可重复读仍可以发生。

REPEATABLE_READ 比ISOLATION_READ_COMMITTED更严格，该隔离级别确保如果在事务中查询了某个数据集，你至少还能再次查询到相同的数据集，即使其他事务修改了所查询的数据。然而如果其他事务插入了新数据，你就可以查询到该新插入的数据。可防止脏读，不可重复读，但幻读仍可能发生。

SERIALIZABLE 完全服从ACID的隔离级别，确保不发生脏读、不可重复读和幻影读。这在所有隔离级别中也是最慢的，因为它通常是通过完全锁定当前事务所涉及的数据表来完成的。代价最大、可靠性最高的隔离级别，所有的事务都是按顺序一个接一个地执行。避免所有不安全读取。

5.7 事务回滚规则

指示spring事务管理器回滚一个事务的推荐方法是在当前事务的上下文内抛出异常。spring事务管理器会捕捉任何未处理的异常，然后依据规则决定是否回滚抛出异常的事务。

默认配置下，spring只有在抛出的异常为运行时unchecked异常时才回滚该事务，也就是抛出的异常为RuntimeException的子类(Errors也会导致事务回滚)，而抛出checked异常则不会导致事务回滚。

可以明确的配置在抛出那些异常时回滚事务，包括checked异常。也可以明确定义那些异常抛出时不回滚事务。

5.8 事物注意事项

要根据实际的需求来决定是否要使用事物，最好是在编码之前就考虑好，不然到以后就难以维护；

如果使用了事物，请务必进行事物测试，因为很多情况下以为事物是生效的，但是实际上可能未生效！

事物@Transactional的使用要放再类的公共(public)方法中，需要注意的是在 protected、private 方法上使用 @Transactional 注解，它也不会报错(IDEA会有提示)，但事务无效。

事物@Transactional是不会对该方法里面的子方法生效！也就是你在公共方法A声明的事物@Transactional，但是在A方法中有个子方法B和C，其中方法B进行了数据操作，但是该异常被B自己处理了，这样的话事物是不会生效的！反之B方法声明的事物@Transactional，但是公共方法A却未声明事物的话，也是不会生效的！如果想事物生效，需要将子方法的事务控制交给调用的方法，在子方法中使用rollbackFor注解指定需要回滚的异常或者将异常抛出交给调用的方法处理。一句话就是在使用事物的时候子方法最好将异常抛出！

事物@Transactional由spring控制的时候，它会在抛出异常的时候进行回滚。如果自己使用catch捕获了处理了，是不生效的，如果想生效可以进行手动回滚或者在catch里面将异常抛出，比如throw new RuntimeException();。

@Transactional可以放在Controller下面直接起作用，看到网上好多同学说要放到@Component下面或者@Service下面，经过试验，可以不用放在这两个下面也起作用。

@Transactional引入包问题，她有两个包：import javax.transaction.Transactional; 和 import org.springframework.transaction.annotation.Transactional; 这两个都可以用，对比了一下他们两个的方法和属性，发现后面的比前面的强大。建议后后面的。

PlatformTransactionManager 这个接口中定义了三个方法 getTransaction创建事务，commit 提交事务，rollback 回滚事务。她的实现类是 AbstractPlatformTransactionManager这个。

5.9 事务并发会产生什么问题

术语含义

脏读 A事务读取到了B事务还未提交的数据，如果B未提交的事务回滚了，那么A事务读取的数据就是无效的，这就是数据脏读

不可重复读在同一个事务中，多次读取同一数据返回的结果不一致，这是由于读取事务在进行操作的过程中，如果出现更新事务，它必须等待更新事务执行成功提交完成后才能继续读取数据，这就导致读取事务在前后读取的数据不一致的状况出现

幻读 A事务读取了几行记录后，B事务插入了新数据，并且提交了插入操作，在后续操作中A事务就会多出几行原本不存在的数据，就像A事务出现幻觉，这就是幻读

1）第一类丢失更新：

在没有事务隔离的情况下，两个事务都同时更新一行数据，但是第二个事务却中途失败退出，导致对数据的两个修改都失效了。

例如：

张三的工资为5000，事务A中获取工资为5000，事务B获取工资为5000，汇入100，并提交数据库，工资变为5100，

随后

事务A发生异常，回滚了，恢复张三的工资为5000，这样就导致事务B的更新丢失了。

2）脏读：

脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。

例如：

　　张三的工资为5000,事务A中把他的工资改为8000,但事务A尚未提交。

　　与此同时，

　　事务B正在读取张三的工资，读取到张三的工资为8000。

　　随后，

　　事务A发生异常，而回滚了事务。张三的工资又回滚为5000。

　　最后，

　　事务B读取到的张三工资为8000的数据即为脏数据，事务B做了一次脏读。

3）不可重复读：

是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。

例如：

　　在事务A中，读取到张三的工资为5000，操作没有完成，事务还没提交。

　　与此同时，

　　事务B把张三的工资改为8000，并提交了事务。

　　随后，

　　在事务A中，再次读取张三的工资，此时工资变为8000。在一个事务中前后两次读取的结果并不致，导致了不可重复读。

4）第二类丢失更新：

不可重复读的特例。

有两个并发事务同时读取同一行数据，然后其中一个对它进行修改提交，而另一个也进行了修改提交。这就会造成第一次写操作失效。

例如：

在事务A中，读取到张三的存款为5000，操作没有完成，事务还没提交。

　　与此同时，

　　事务B，存储1000，把张三的存款改为6000，并提交了事务。

　　随后，

　　在事务A中，存储500，把张三的存款改为5500，并提交了事务，这样事务A的更新覆盖了事务B的更新。

5）幻读：

是指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。

例如：

　　目前工资为5000的员工有10人，事务A读取所有工资为5000的人数为10人。

　　此时，

　　事务B插入一条工资也为5000的记录。

　　这是，事务A再次读取工资为5000的员工，记录为11人。此时产生了幻读。

提醒：

不可重复读的重点是修改，同样的条件，你读取过的数据，再次读取出来发现值不一样了

幻读的重点在于新增或者删除，同样的条件，第 1 次和第 2 次读出来的记录数不一样

6 结语

由于本人才接触SprintBoot，文中如有没说清楚的地方，希望大家能在评论区指出，以帮助我将博文写得更好。

————————————————

原文链接：https://blog.csdn.net/zzhongcy/article/details/102893309

ServiceMix Process Examples

2013-12-28T21:39:00.000-05:00

1.HTTP-binding(ServiceMix)

1.4 各组件间传递消息流的过程如下：

1. HttpClient：Http客户端运行一个独立的Java客户端程序，通过其中的URLConnection类连接到http://localhost:8912，将request.xml文件发送到此端口。

2. HttpReceiver：在Http服务器上(Http server)，HttpReceiver通过监听http://localhost:8912端口，得到此消息。

3. HttpReceiver根据消息的destinationService(目标服务)属性中的信息，将此消息通过NMR发送给相应的stockQuote服务。

4. stockQuote再将此消息发送给另一个服务——soapEndpoint来处理。

5. soapEndpoint处理之后，将响应消息返回给stockQuote。

6. stockQuote通过NMR将此相应消息发送给httpReceiver。

7. httpReceiver将相应消息发送到http://localhost:8912端口。

8. HttpClient从端口读取该响应消息。

9. 最终响应消息在控制台输出。

2.Jms-binding (ServiceMix)

2.4消息流按以下方式通过各个组件：

JMSClient, 通过 ActiveMQConnectionFactory, 连接到一个叫"demo.org.servicemix.source"的主题并发送一个文本消息。
jencks (JCA资源适配器) 在端口61616上监听消息
inputReceiver 通过jencks订阅"demo.org.servicemix.source" 主题并接收JMS消息
inputReceiver规格化JMS消息并通过规格化消息路由器（NMR）把它发送到 outputSender
outputSender outputSender把规格化的消息marshal为一个JMS消息，并使用jmsTemplate在"demo.org.servicemix.result" 主题上发布消息。
jmsTemplate在"demo.org.servicemix.result" 主题上发布消息，使用jmsFactory获得一个到结果主题的连接。
JMSClient, "demo.org.servicemix.result," 主题的另一个订阅者接收这个消息。
响应在控制台上打印。

3.BPEL Example(ServiceMix)

3.5程序的逻辑流：

1. JMSClient，通过ActiveMQConnectionFactory连接到一个叫"demo.org.servicemix.source"的主题上，并发送一个包含message.soap file.的文本消息。

2. myComponent, "demo.org.servicemix.source,"主题的一个订阅者，接收这个消息。

3. myComponent 实现类，JmsServiceComponent,通过ServiceMix总线发送消息至PxeBpelEngine，执行它的onMessage()方法。destinationService属性定了了消息的目的地。注意：destinationService属性在文件servicemix.xml中。

4. PxeBpelEngine通过ServiceMix总线、NMR发送一个响应至myComponent 。

5. myComponent 使用 jmsTemplate bean 发布消息。.

6. jmsTemplate 使用 jmsFactory bean获得一个到和JMS 主题"demo.org.servicemix.source."相关的端口的连接。这个消息被发布在"demo.org.servicemix.source" 主题.

7. JMSClient, "demo.org.servicemix.source,"主题的订阅者，接收这个消息。

8. 响应在控制台上打印。

4.RSS-binding(ServiceMix)

5.File binding(ServiceMix)

5.4程序的逻辑流：

1. FilePoller 每1000ms检索收件箱目录一次寻找一个文件

2. 一旦在收件箱目录中找到一个文件，filePoller从workManager处获得一个线程。这个线程用来处理这个文件。

3. filePoller创建一个包含了将要被传输的文件的规格化的消息，它把这个规格化的消息发送到NMR。NMR把这个消息路由到fileSender组件。

4. fileSender把规格化的消息转换到一个文件并“发送”（放置）到发件箱目录。

文件传输过程中，日志信息被写到控制台。

6.Basic(ServiceMix)

6.4 消息流按以下方式通过各个组件：

1. Timer组件通过规格化消息路由（NMR）向inputSender发送一个消息。

2. inputsender把消息转换（marshals）为一个JMS消息，然后用jmsTemplate bean发布消息。

3. jmsTemplate用jmsFactorybean获得一个到和JMS 主题"demo.org.servicemix.source."相关的端口的连接。这个消息被发布在"demo.org.servicemix.source" 主题.

4. jencks (the JCA资源适配器)在端口61616上监听消息

5. inputReceiver通过jencks订阅"demo.org.servicemix.source" 主题并接收JMS消息

6. inputReceiver规格化JMS消息并通过NMR把它发送到outputSender

7. outputSender把规格化的消息marshal为一个JMS消息，并使用jmsTemplate在"demo.org.servicemix.result" 主题上发布消息。

8. jmsTemplate在"demo.org.servicemix.result" 主题上发布消息，使用jmsFactory获得一个到结果主题的连接。

9. Jencks在61616端口上监听消息。

10. jmsTrace订阅"demo.org.servicemix.result" 主题，并通过jencks接收JMS消息。

11. jmsTrace把JMS消息转换成规格化消息，并通过NMR把它发送到trace。

12. trace把规格化的消息转换成一个字符串，并在控制台上记录日志。

每5秒在控制台上写一遍日志，还有从trace组件而来的信息。注意，他日ggers&apos，属性值为“名字”“我的示例工作”“组”，“ServiceMix”用时间戳显示。

7.Quartz-binding(ServiceMix)

This article is from :

http://blog.csdn.net/juset/archive/2006/12/18/1447626.aspx

Set the context path of a web application in Tomcat 7.0

2013-10-10T23:38:00.003-04:00

Try to deploy a war package in Tomcat 7 with different web context path, at last it works with below steps:

1. Create context.xml file with your new context path name. For example: mynewpath.xml

Don't just use default file name context.xml as your web file name, otherwise the Tomcat will deploy a new app with \context . But you want \mynewpath . It is a tricky.

In file you need to add:

<?xml version="1.0" encoding="UTF-8"?>
<Context docBase="myapp.war"
reloadable="true" path="/mynewpath"/>

2. Put this mynewpath.xml in Tomcat\conf\Catalina\localhost.
3. Deploy your war file outside the webapp folder like below:

C:\apache-tomcat-7.0.42\myapp.war

That's it.

Run JSF 2.0 on Glassfish 2.1.1

2012-04-30T10:25:00.002-04:00

You can add JSF 2.0 and Unified EL (EL 2) magic to Glassfish V2.1.1 in 2 ways.

1) If you want to completly replace JSF 1.x with 2.x in your glassfish V2.1.1 installation

a) Remove existing jsf-impl.jar in ${com.sun.aas.installRoot}/lib
b) Add following JSF2 and unified EL jars. i.e. jsf-api-2.1.jar, jsf-impl-2.1.jar,el-api-2.1.jar, el-impl-2.1.jar in in ${com.sun.aas.installRoot}/lib.
c) Add or update classpath-prefix=”${com.sun.aas.installRoot}/lib/jsf-api.jar;${com.sun.aas.installRoot}/lib/jsf-imp.jar;${com.sun.aas.installRoot}/lib/el-api.jar;${com.sun.aas.installRoot}/lib/el-impl.jar” in ${com.sun.aas.installRoot}/domains//config/domain.xml under as an attribute.

2) If you want to keep JSF 1.x as the default implementation on your glassfish instance but want to implement JSF 2.x only on one of your applications

a) Add el-api-2.1.jar, el-impl-2.1.jar in ${com.sun.aas.installRoot}/lib.
b) Include jsf-api-2.1.jar, jsf-impl-2.1.jar in lib directory of your application war.
c) Add add sun-web.xml under /WEB-INF/ directory of your application war with following properties
mojarra2
d) Add or update classpath-prefix=”${com.sun.aas.installRoot}/lib/el-api.jar;${com.sun.aas.installRoot}/lib/el-impl.jar” in ${com.sun.aas.installRoot}/domains//config/domain.xml under as an attribute.
Hope this helps. Enjoy!!!
Note: (This does not work in Glassfish V2.0 or V2.1)

Original file:
http://ocpsoft.org/java/jsf2-java/jsf2-how-to-add-the-magic-of-el-el2-to-jsf/

Also there is another article show the way:

http://blog.eisele.net/2010/01/running-mojarra-202-on-glassfish-v211.html

Spring+Hibernate+JSF+Ajax4jsf+Acegi+jCaptcha 做登录模块

2012-04-28T01:03:00.002-04:00

带图片验证码的用户登录是一个系统中很常见的模块，在Java EE中有很多不同的实现，而开源世界中又给我们提供了很多优秀的框架，从而减少了我们的编码量，下面给大家简单介绍一下用 Spring+Hibernate+JSF+Ajax4jsf+Acegi+jCaptcha 如何构建一个登录模块：
    我使用这些框架的版本如下：
    Spring 2.0.1
    Hibernate 3.2
    JSF 1.2
    Acegi 1.0.5
    jCaptcha 1.0-RC6
    首先建表USERTEST，和ROLETEST，作为用户表和角色表
CREATE TABLE USERTEST
(
USERID    NUMBER                              NOT NULL,
USERNAME VARCHAR2(20 CHAR)                   NOT NULL,
PASSWORD VARCHAR2(100 CHAR)                  NOT NULL,
STATUS    NUMBER                              DEFAULT 1                     NOT NULL,
ROLEID    NUMBER                              NOT NULL
)
CREATE TABLE ROLETEST
(
ROLEID    NUMBER                              NOT NULL,
ROLENAME VARCHAR2(50 CHAR)                   NOT NULL,
ROLEDESC VARCHAR2(50 CHAR)
)
    同时给ROLETEST表添加一条记录：1    ROLE_USER    普通用户
    再给USERTEST表添加一条记录：1    admin    123    1    1
    对应的hbm.xml文件就相信大家都会写，如果用eclipse开发的话，可以使用HibernateSynchronizer插件，我使用的版本是3.1.9
    接下来就要给web.xml的配置一下了：
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="WebApp_ID" version="2.5">
<display-name>Demo</display-name>
<welcome-file-list>
  <welcome-file>index.html</welcome-file>
  <welcome-file>index.htm</welcome-file>
  <welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>
   /WEB-INF/classes/applicationContext.xml
  </param-value>
</context-param>
<context-param>
  <param-name>javax.faces.CONFIG_FILES</param-name>
  <param-value>/WEB-INF/faces-config.xml</param-value>
</context-param>
<listener>
  <listener-class>
   org.springframework.web.context.ContextLoaderListener
  </listener-class>
</listener>
<listener>
  <listener-class>
   org.acegisecurity.ui.session.HttpSessionEventPublisher
  </listener-class>
</listener>
<listener>
  <listener-class>
   com.sun.faces.config.ConfigureListener
  </listener-class>
</listener>
<filter>
  <filter-name>OpenSessionInView</filter-name>
  <filter-class>
   org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
  </filter-class>
  <init-param>
   <param-name>singleSession</param-name>
   <param-value>true</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>OpenSessionInView</filter-name>
  <url-pattern>*.jsf</url-pattern>
</filter-mapping>
<filter>
  <filter-name>Acegi Filter Chain Proxy</filter-name>
  <filter-class>
   org.acegisecurity.util.FilterToBeanProxy
  </filter-class>
  <init-param>
   <param-name>targetClass</param-name>
   <param-value>
    org.acegisecurity.util.FilterChainProxy
   </param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>Acegi Filter Chain Proxy</filter-name>
  <url-pattern>/*</url-pattern>
  <dispatcher>FORWARD</dispatcher>
  <dispatcher>REQUEST</dispatcher>
</filter-mapping>
<filter>
<display-name>Ajax4jsf Filter</display-name>
<filter-name>ajax4jsf</filter-name>
<filter-class>org.ajax4jsf.Filter</filter-class>
</filter>

<filter-mapping>
<filter-name>ajax4jsf</filter-name>
<servlet-name>Faces Servlet</servlet-name>
<dispatcher>REQUEST</dispatcher>
<dispatcher>FORWARD</dispatcher>
<dispatcher>INCLUDE</dispatcher>
</filter-mapping>

<servlet>
  <servlet-name>Faces Servlet</servlet-name>
  <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
  <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
  <servlet-name>Faces Servlet</servlet-name>
  <url-pattern>*.jsf</url-pattern>
</servlet-mapping>
</web-app>
    然后Spring的applicationContext.xml，在这里面你需要配置数据库连接、hibernate的各种策略、Acegi安全设置、jCaptcha设置等等：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.1.xsd">
<bean id="dataSource"
  class="org.apache.commons.dbcp.BasicDataSource">
  <property name="driverClassName">
   <value>oracle.jdbc.driver.OracleDriver</value>
  </property>
  <property name="url">
   <value>jdbc:oracle:thin:@10.10.10.10:1521:demo</value>
  </property>
  <property name="username">
   <value>demo</value>
  </property>
  <property name="password">
   <value>demo</value>
  </property>
</bean>
<bean id="sessionFactory"
  class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  <property name="dataSource">
   <ref bean="dataSource" />
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">
     org.hibernate.dialect.OracleDialect
    </prop>
    <prop key="hibernate.connection.pool_size">5</prop>
    <prop key="hibernate.show_sql">true</prop>
    <prop key="cache.provider_class">
     org.hibernate.cache.OSCacheProvider
    </prop>
    <prop key="cache.use_query_cache">true</prop>
    <prop key="cglib.use_reflection_optimizer">false</prop>
   </props>
  </property>
  <property name="mappingDirectoryLocations">
   <list>
    <value>classpath:/com/fifthlab/demo/pojo</value>
   </list>
  </property>
</bean>
<bean id="transactionManager"
  class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory" ref="sessionFactory" />
</bean>

<bean id="txProxyTemplate" abstract="true"
  class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <property name="transactionManager" ref="transactionManager" />
  <property name="transactionAttributes">
   <props>
    <prop key="save*">PROPAGATION_REQUIRED</prop>
    <prop key="add*">PROPAGATION_REQUIRED</prop>
    <prop key="delete*">PROPAGATION_REQUIRED</prop>
    <prop key="update*">PROPAGATION_REQUIRED</prop>
    <prop key="relation*">PROPAGATION_REQUIRED</prop>
    <prop key="disconnect*">PROPAGATION_REQUIRED</prop>
    <prop key="assign*">PROPAGATION_REQUIRED</prop>
    <prop key="unassign*">PROPAGATION_REQUIRED</prop>
    <prop key="*">PROPAGATION_SUPPORTS</prop>
   </props>
  </property>
</bean>



<bean id="filterChainProxy"
  class="org.acegisecurity.util.FilterChainProxy">
  <property name="filterInvocationDefinitionSource">
   <value>
    CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
    PATTERN_TYPE_APACHE_ANT
    /**/*.jsf=httpSessionContextIntegrationFilter,captchaValidationProcessingFilter,authenticationProcessingFilter,anonymousProcessingFilter,exceptionTranslationFilter,filterInvocationInterceptor
   </value>
  </property>
</bean>
<bean id="httpSessionContextIntegrationFilter"
  class="org.acegisecurity.context.HttpSessionContextIntegrationFilter">
  <property name="context">
   <value>
    com.fifthlab.demo.dao.authentication.FixedCaptchaSecurityContextImpl
   </value>
  </property>
</bean>
<bean id="authenticationManager"
  class="org.acegisecurity.providers.ProviderManager">
  <property name="providers">
   <list>
    <ref local="daoAuthenticationProvider" />
   </list>
  </property>
</bean>
<bean id="daoAuthenticationProvider"
  class="org.acegisecurity.providers.dao.DaoAuthenticationProvider">
  <property name="userDetailsService">
   <ref local="hibernate3Authentication" />
  </property>
</bean>
<bean id="loggerListener"
  class="org.acegisecurity.event.authentication.LoggerListener" />
<bean id="authenticationProcessingFilter"
  class="org.acegisecurity.ui.webapp.AuthenticationProcessingFilter">
  <property name="authenticationManager">
   <ref bean="authenticationManager" />
  </property>
  <property name="authenticationFailureUrl">
   <value>/login.jsf</value>
  </property>
  <property name="defaultTargetUrl">
   <value>/login.jsf</value>
  </property>
  <property name="filterProcessesUrl">
   <value>/j_acegi_security_check</value>
  </property>
</bean>
<bean id="exceptionTranslationFilter"
  class="org.acegisecurity.ui.ExceptionTranslationFilter">
  <property name="authenticationEntryPoint">
   <ref local="authenticationProcessingFilterEntryPoint" />
  </property>
</bean>
<bean id="authenticationProcessingFilterEntryPoint"
  class="org.acegisecurity.ui.webapp.AuthenticationProcessingFilterEntryPoint">
  <property name="loginFormUrl">
   <value>/login.jsf</value>
  </property>
  <property name="forceHttps">
   <value>false</value>
  </property>
</bean>
<bean id="filterInvocationInterceptor"
  class="org.acegisecurity.intercept.web.FilterSecurityInterceptor">
  <property name="authenticationManager">
   <ref bean="authenticationManager" />
  </property>
  <property name="accessDecisionManager">
   <ref local="httpRequestAccessDecisionManager" />
  </property>
  <property name="observeOncePerRequest">
   <value>true</value>
  </property>
  <property name="objectDefinitionSource">
   <value>
    CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
    PATTERN_TYPE_APACHE_ANT
    /login.jsp=ROLE_ANONYMOUS
    /success.jsp=ROLE_USER
   </value>
  </property>
</bean>

<bean id="hibernate3Authentication"
  class="com.fifthlab.demo.dao.authentication.Hibernate3Authentication">
  <property name="sessionFactory">
   <ref local="sessionFactory" />
  </property>
</bean>
<bean id="anonymousProcessingFilter"
  class="org.acegisecurity.providers.anonymous.AnonymousProcessingFilter">
  <property name="key">
   <value>foobar</value>
  </property>
  <property name="userAttribute">
   <value>anonymousUser,ROLE_ANONYMOUS</value>
  </property>
</bean>
<bean id="httpRequestAccessDecisionManager"
  class="org.acegisecurity.vote.AffirmativeBased">
  <property name="allowIfAllAbstainDecisions">
   <value>false</value>
  </property>
  <property name="decisionVoters">
   <list>
    <ref bean="roleVoter" />
   </list>
  </property>
</bean>
<bean id="roleVoter" class="org.acegisecurity.vote.RoleVoter" />

<bean id="captchaValidationProcessingFilter"
  class="org.acegisecurity.captcha.CaptchaValidationProcessingFilter">
  <property name="captchaService">
   <ref bean="captchaService" />
  </property>
  <property name="captchaValidationParameter">
   <value>j_captcha_response</value>
  </property>
</bean>
<bean id="captchaService"
  class="com.fifthlab.demo.dao.authentication.JCaptchaServiceProxyImpl">
  <property name="jcaptchaService" ref="jcaptchaService" />
</bean>
<bean id="jcaptchaService"
  class="com.octo.captcha.service.image.DefaultManageableImageCaptchaService" />

</beans>
    先解释一下上面applicationContext.xml中红色的部分是jCaptcha的一个filter，必须放在第二个位置，后面的是 acegi的filter，也就是说，要先验证图片验证码是否正确，再让acegi来验证用户名和密码。蓝色的部分是需要写的几个代码，其中有一个修复 bug的地方，如果不添加那个bean，在运行的时候就会报Cast转型的错误。下面列一下蓝色部分的代码：
FixedCaptchaSecurityContextImpl：
import org.acegisecurity.captcha.CaptchaSecurityContextImpl;
public class FixedCaptchaSecurityContextImpl extends CaptchaSecurityContextImpl {
public int hashCode() {
  if (getAuthentication() == null) {
   return (int) System.currentTimeMillis();
  } else {
   return this.getAuthentication().hashCode();
  }
}
}
Hibernate3Authentication：
import java.util.ArrayList;
import java.util.List;
import org.acegisecurity.GrantedAuthority;
import org.acegisecurity.GrantedAuthorityImpl;
import org.acegisecurity.userdetails.UserDetails;
import org.acegisecurity.userdetails.UserDetailsService;
import org.acegisecurity.userdetails.UsernameNotFoundException;
import org.hibernate.Criteria;
import org.hibernate.criterion.Expression;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.fifthlab.demo.pojo.Roletest;
import com.fifthlab.demo.pojo.Usertest;
public class Hibernate3Authentication extends HibernateDaoSupport implements UserDetailsService {
public UserDetails loadUserByUsername(final String username)
{
  Criteria criteria = getHibernateTemplate().getSessionFactory().getCurrentSession().createCriteria(Usertest.class);
  criteria.add(Expression.eq(Usertest.PROP_USERNAME, username));
  List users = criteria.list();
  if (users.size() == 0)
  {
   throw new UsernameNotFoundException("User not found");
  }
  Usertest user = (Usertest) users.get(0);
  // get User roles of this user
  List<Roletest> userRoles = new ArrayList<Roletest>();
  userRoles.add(user.getRoletest());
  GrantedAuthority[] dbAuths = new GrantedAuthority[userRoles.size()];
  if (userRoles.size() == 0)
  {
   throw new UsernameNotFoundException("User has no GrantedAuthority");
  }
  // grant authority to user
  String roleName = null;
  Roletest role = null;
  for (int i = 0; i < userRoles.size(); i++)
  {
   role = (Roletest) userRoles.get(i);
   if (null != role)
   {
    roleName = role.getRolename();
    dbAuths[i] = new GrantedAuthorityImpl(roleName);
   }
  }

  user.setAuthorities(dbAuths);

  return user;
}
}
JCaptchaServiceProxyImpl：
import org.acegisecurity.captcha.CaptchaServiceProxy;
import com.octo.captcha.service.image.ImageCaptchaService;
import com.octo.captcha.service.CaptchaServiceException;
public class JCaptchaServiceProxyImpl implements CaptchaServiceProxy {

    private ImageCaptchaService jcaptchaService;

    public boolean validateReponseForId(String id, Object response) {

      try {
     boolean result = jcaptchaService.validateResponseForID(id, response);
       //System.out.println("id:"+id+"\nresponse:"+response+"\nresult:"+result);
     return result;

      } catch (CaptchaServiceException cse) {
        //fixes known bug in JCaptcha
     cse.printStackTrace();
        return false;
      }
    }

    public void setJcaptchaService(ImageCaptchaService jcaptchaService) {
      this.jcaptchaService = jcaptchaService;
    }
}
    接下来是简单的登录页面login.jsp和登录成功后的跳转页面success.jsp：
login.jsp：
<%@ page language="Java" contentType="text/html;charset=utf-8"%>
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="https://ajax4jsf.dev.java.net/ajax" prefix="a4j"%>
<f:view>
<html>
<head>
<title>hello</title>
</head>
<META HTTP-EQUIV="PRAGMA" CONTENT="NO-CACHE">
<META HTTP-EQUIV="Pragma" CONTENT="no-cache">
<META HTTP-EQUIV="Expires" CONTENT="Expires">
<body>
<h:form id="form1">
  <h:panelGrid columns="1">
   <h:panelGroup>
    <h:outputLabel value="username:" for="username" />
    <h:inputText id="username" value="#{loginBean.userName}" />
   </h:panelGroup>
   <h:panelGroup>
    <h:outputLabel value="password:" for="password" />
    <h:inputSecret id="password" value="#{loginBean.password}" />
   </h:panelGroup>
   <h:panelGroup>
    <h:outputLabel value="verifying code:" for="verifyingCode" />
    <h:inputText id="verifyingCode" value="#{loginBean.verifyingCode}" />
    <a4j:mediaOutput element="img" cacheable="false" session="false"
        createContent="#{captchaImageBean.paint}" id="showPic"
        mimeType="image/jpeg" />
    <a4j:commandLink reRender="showPic" requestDelay="40" >
     <h:outputText value="refresh" />
    </a4j:commandLink>   </h:panelGroup>
   <h:panelGroup>
    <h:commandButton id="commandButton1" value="Submit"
     action="#{loginBean.authenticate}" />
   </h:panelGroup>
  </h:panelGrid>
</h:form>
</body>
</html>
</f:view>
    其中红色部分是应用了Ajax4jsf这个框架的两个标签，<a4j:mediaOutput> 是表示输出一个媒体，这里我选择的是输出图片，它会异步的产生图片，而不必和页面载入时同步取图片。而<a4j:commandLink reRender="showPic"> 则是在看不清图片的情况下通过异步的方式刷新上面那个<a4j:mediaOutput>的图片。
    success.jsp的页面很简单，就是显示一个“Welcome here”的字样，因此不列出来了。
    然后我们看一下页面中用到的backing bean的代码：
LoginBean：
import javax.faces.context.FacesContext;
import javax.servlet.http.HttpSession;
import org.acegisecurity.Authentication;
import org.acegisecurity.AuthenticationException;
import org.acegisecurity.AuthenticationManager;
import org.acegisecurity.context.SecurityContext;
import org.acegisecurity.context.SecurityContextHolder;
import org.acegisecurity.providers.UsernamePasswordAuthenticationToken;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.fifthlab.demo.dao.authentication.JCaptchaServiceProxyImpl;
public class LoginBean extends HibernateDaoSupport {
private static final long serialVersionUID = 1L;
private String userName;
private String password;
private String verifyingCode;
private AuthenticationManager authenticationManager;
private JCaptchaServiceProxyImpl captchaService;
/**
* @return 返回用户输入的验证码
*/
public String getVerifyingCode()
{
  return this.verifyingCode;
}

/**
* @param verifyingCode 设置图片验证码
*/
public void setVerifyingCode(String verifyingCode)
{
  this.verifyingCode = verifyingCode;
}

/**
* @return 返回captchaService来验证图片验证码
*/
public JCaptchaServiceProxyImpl getCaptchaService()
{
  return this.captchaService;
}

/**
* @param captchaService 设置图片验证码服务
*/
public void setCaptchaService(JCaptchaServiceProxyImpl captchaService)
{
  this.captchaService = captchaService;
}

/**
* @return 返回密码
*/
public String getPassword()
{
  return password;
}
/**
* @param password 设置密码
*
*/
public void setPassword(String password)
{
  this.password = password;
}
/**
* @return 返回用户名
*/
public String getUserName()
{
  return userName;
}
/**
* @param userName 设置用户名
*
*/
public void setUserName(String userName)
{
  this.userName = userName;
}
/**
* @return 返回验证管理器
*/
public AuthenticationManager getAuthenticationManager()
{
  return authenticationManager;
}
/**
* @param authenticationManager 设置验证管理器
*
*/
public void setAuthenticationManager(AuthenticationManager authenticationManager)
{
  this.authenticationManager = authenticationManager;
}

public String authenticate()
{
  try
  {
   String sessionid = ((HttpSession)FacesContext.getCurrentInstance()
           .getExternalContext()
           .getSession(false)).getId();
   boolean captchaResult = getCaptchaService().validateReponseForId(sessionid, getVerifyingCode());//验证图片验证码
     UsernamePasswordAuthenticationToken authReq = new UsernamePasswordAuthenticationToken(
     getUserName(), getPassword());
   //验证用户名和密码
   Authentication auth = getAuthenticationManager().authenticate(authReq);
   String result = "failure";
   if(auth.isAuthenticated() == true && captchaResult)
   {//如果图片验证码和帐户全部验证通过
    result = "succeed";
    //把验证信息保存的上下文中
    SecurityContext secCtx = SecurityContextHolder.getContext();
    secCtx.setAuthentication(auth);
   }

   return result;
  }
  catch(AuthenticationException e)
  {
   e.printStackTrace();
   return "failure";
  }
}
}
CaptchaImageBean:
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import javax.faces.context.FacesContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import com.octo.captcha.service.image.ImageCaptchaService;
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;
public class CaptchaImageBean {
static final long serialVersionUID = 1L;
private ImageCaptchaService jcaptchaService;

public void setJcaptchaService(ImageCaptchaService jcaptchaService) {
  this.jcaptchaService = jcaptchaService;
}

public void paint(OutputStream out, Object data) throws IOException
{
  byte[] captchaChallengeAsJpeg = null;
  ByteArrayOutputStream jpegOutputStream = new ByteArrayOutputStream();

  HttpServletRequest request = (HttpServletRequest)FacesContext.getCurrentInstance()
        .getExternalContext().getRequest();

  String captchaId = ((HttpSession)FacesContext.getCurrentInstance()
    .getExternalContext()
    .getSession(false)).getId();

  BufferedImage challenge = jcaptchaService.getImageChallengeForID(
    captchaId, request.getLocale());
  JPEGImageEncoder jpegEncoder = JPEGCodec.createJPEGEncoder(jpegOutputStream);
  jpegEncoder.encode(challenge);
  captchaChallengeAsJpeg = jpegOutputStream.toByteArray();

  jpegOutputStream.close();
  out.write(captchaChallengeAsJpeg);
  out.flush();
  out.close();
}
}
    最后当然是配置faces-config.xml了，里面配置了和Spring的整合、导航、managed bean等等：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE faces-config PUBLIC "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN" "http://java.sun.com/dtd/web-facesconfig_1_1.dtd">
<faces-config>
<application>
  <variable-resolver>
   org.springframework.web.jsf.DelegatingVariableResolver
  </variable-resolver>
</application>
<managed-bean>
  <managed-bean-name>loginBean</managed-bean-name>
  <managed-bean-class>com.fifthlab.demo.backingbean.LoginBean</managed-bean-class>
  <managed-bean-scope>request</managed-bean-scope>
  <managed-property>
   <property-name>authenticationManager</property-name>
   <value>#{authenticationManager}</value>
  </managed-property>
  <managed-property>
   <property-name>captchaService</property-name>
   <value>#{captchaService}</value>
  </managed-property>
</managed-bean>

<managed-bean>
  <managed-bean-name>captchaImageBean</managed-bean-name>
  <managed-bean-class>com.fifthlab.demo.backingbean.CaptchaImageBean</managed-bean-class>
  <managed-bean-scope>request</managed-bean-scope>
  <managed-property>
   <property-name>jcaptchaService</property-name>
   <value>#{jcaptchaService}</value>
  </managed-property>
</managed-bean>

<navigation-rule>
  <from-view-id>/login.jsp</from-view-id>
  <navigation-case>
   <from-outcome>succeed</from-outcome>
   <to-view-id>/success.jsp</to-view-id>
  </navigation-case>
  <navigation-case>
   <from-outcome>failure</from-outcome>
   <to-view-id>/login.jsp</to-view-id>
  </navigation-case>
</navigation-rule>
</faces-config>

大功告成！让我们来看一下演示吧

填好帐户和验证码后，点击Submit，如果失败则还是该页不变，如果成功则跳转到：

需要的各种lib列表如下图：

原文：http://farmerinchina.blog.sohu.com/70466803.html

Deploy own version JSF 2.0 on JBoss 6

2012-04-27T12:43:00.000-04:00

1. Put your own jsf jar files in the WEB-INF/lib like WEB-INF/lib/jsf2.0.6
2. Add below context parameters in web.xml

<context-param>

<param-name>org.jboss.jbossfaces.WAR_BUNDLES_JSF_IMPL</param-name>

<param-value>true</param-value>

</context-param>

3. Add Listener for JBoss to avoid "Could not find Factory:javax.faces.context.FacesContextFactory" excption if it is necessary.

<listener-class>com.sun.faces.config.ConfigureListener</listener-class>

</listener>

自製手機APP的網站

2012-02-01T00:43:00.000-05:00

1.Myappbuilder

2.Appbreeder

3.Swebapps

4.Appmakr

5.Mobileroadie

6.Isites

7.Motherapp

8.mobbase

9.Biznessapps

http://ebookapp.com
http://gamesalad.com/

另有幾篇重要教學：

6 Ways To Build An iPhone App Without Knowing Anything

How to Make an iPhone App

2011年最火爆的8大Web开发工具

2012-01-31T01:58:00.001-05:00

2011年最火爆的8大Web开发工具提到，jQuery和jQuery Mobile，CSS3 PIE，Bootstrap，LESS，Chrome开发人员工具等。一下是全部内容，

2011年最火爆的8大Web开发工具 TechFrom2011总结系列

2011年最火爆的8大Web开发工具：
Web应用开发和部署工具，Bootstrap

Twitter 于8月份推出了一个名为Bootstrap的开发工具包，将Web应用开发与部署变得更为简单快捷。Bootstrap包是一个简单的程序库，同时提供优雅的HTML和CSS规范。Bootstrap使用了一些最新的Web浏览器技术，向开发者提供时尚的排版、样式、按钮、表格、网格、导航等服务，而且占用资源很小，用gzip压缩后只有6K左右。
jQuery和jQuery Mobile，JavaScript代码工具

jQuery是一款免费且开放源代码的JavaScript代码库，而jQuery Mobile是jQuery在手机和平板上的版本。

jquery.jpg

jQuery Mobile不仅能给主流移动平台带来jQuery核心库，还能发布一个完整统一的jQuery移动UI框架，支持全球主流的手机、平板、电子阅读器、台式电脑等平台。据微软关于jQuery的调查显示，jQuery在受访网站中的使用率已从2010年12月的27%上升到2011年12月的42%。
CSS代码工具，CSS3 PIE

CSS3 PIE，全称是 Progressive Internet Explorer，可以让IE6至IE8的所有版本实现大多数的CSS3修饰特性，如圆角、阴影、渐变等等。通过这个工具CSS3 PIE，开发者可以在线修改想要的效果，并即时生成css代码。
开发管理工具，LESS，免费开源

LESS是一个CSS开发管理的强大工具，拓展了CSS的变量、运算符、include、嵌套规则等语法。

less.jpg

LESS从Ruby的LESS library衍生而来，免费开源，实现了和CSS的无缝结合。此外，LESS可以配置成自动最小化所生成的CSS文件，不仅可以节省带宽，还可以改善最终用户的体验。
Chrome开发人员工具

火狐即将死亡的预言或许被夸大其词了，但可以肯定的是Chrome正在侵蚀越来越大的市场份额，其中最主要的一个原因是Web开发人员喜欢Chrome捆绑自带的开发人员工具。

Chrome开发人员工具主要基于WebKit网络检查器（开放源代码WebKit项目的一部分），可让Web开发人员随时随地对网页的CSS、HTML和JavaScript进行实时编辑、调试以及监控。

Chrome开发人员工具不仅能帮助诊断、修复在网页加载、脚本执行以及页面呈现中出现的问题，还可帮助最大限度地了解网页或网络应用程序对CPU以及内存的使用情况。
基于浏览器的Web网络开发IDE工具，SourceKit 和 Ace

网络开发工具中文本编辑工具最受欢迎的是 Vim，但是基于web浏览器的网络IDE开发工具是 Ace，和基于 Ace 构建的SourceKit，之前的名字是 “Bespin” 和 “Skywriter” 。
PhoneGap，基于html5 的开源移动开发框架

之前在基于html5的跨平台手机应用,移动开发开源框架PhoneGap 和跨平台手机应用,移动开发开源框架PhoneGap,基于html5,已支持 facebook登陆中，介绍过移动开发 html5 开源技术框架，其母公司 Nitobi Software> 已经被Adobe公司收购。

另外，还有更多的移动和网络应用开发 10大优秀开发框架推荐，和全功能框架平台 Strobe，基于html5的全功能应用开发平台 Strobe,由前苹果核心员工和技术大牛联合创建。

本文科技源TechFrom地址：: http://www.techfrom.com/20315.html

Install and remove APK Files on Android Device Emulator (Windows)

2011-08-21T21:45:00.000-04:00

Install APK

1. Download android SDK.
2. Go to $SDK_ROOT/tools or $SDK_ROOT/platform-tools directory and execute the file ‘emulator.exe’. You might need to also include android virtual device (AVD) to command line execution for example,

./emulator -avd TestDevice
3. Save/copy the APK file directly in the $SDK_ROOT/tools or $SDK_ROOT/platform-tools directory.
4. Goto Shell/Terminal/CommandPrompt, adb install fileName.apk (You will need to shell/terminal/cmd sessions live)

or ./adb install fileName.apk
5.If there is ‘Path not found’ error then you need to add $SDK_ROOT/tools directory to your system PATH settings correctly.

Remove APK

1.Click on menu and then select settings icon >> Click on applications tab>>Go to Manage applications
2. Find the application which you want to remove and uninstall.

Some exceptions we will get and how to resolve when we upgrade the application from java 1.4 to 1.6

2011-08-19T17:15:00.000-04:00

This file will be keep on updating.

1.java.lang.IllegalAccessError: class javax.activation.SecuritySupport12 cannot access its superclass javax.activation.SecuritySupport

This issue will happen when we are using the old activation.jar with mail.jar. solution is delete the activation.jar. Sometimes if we are using weblogic.jar, there is a subdirectory javax.activation also need to be deleted.

Run RichFace 4.0 on GlassFish 3.1 get warning This page calls for XML namespace http://richfaces.org/a4j declared with prefix a4j but no taglibrary exists for that namespace

2011-08-11T16:02:00.000-04:00

If you get "This page calls for XML namespace http://richfaces.org/a4j declared with prefix a4j but no taglibrary exists for that namespace" error when running RichFace 4.0 on GlassFish 3.1 with Eclipse, it is always because you didn't deploy the RichFace jar lib to GlassFish path. Try to export below jar files with deploy package

cssparser-0.9.5.jar,
guava-r08.jar,
richfaces-components-api-4.0.0.Final.jar,
richfaces-components-api-4.0.0.Final.jar,
richfaces-components-ui-4.0.0.Final.jar,
richfaces-core-api-4.0.0.Final.jar,
richfaces-core-impl-4.0.0.Final.jar,
sac-1.3.jar

1. Goto project properties
2. Click Deployment Assembly
3. Add above jar files

Done.

Upgrade web from struts 1.3 to jsf 2.0

2011-08-09T14:05:00.001-04:00

1. Change the tile of web.xml from

<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>

to:
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

2. Add <jsp-config> before <taglib> to match the new structure of 2.5

<jsp-config>
<taglib>
<taglib-uri>/WEB-INF/struts-bean.tld</taglib-uri>
<taglib-location>/WEB-INF/tld/struts/struts-bean.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/WEB-INF/struts-html.tld</taglib-uri>
<taglib-location>/WEB-INF/tld/struts/struts-html.tld</taglib-location>
</taglib>
</jsp-config>

3. Add context-param

<context-param>
<description>
Tell the runtime where we are in the project development
lifecycle. Valid values are:
Development, UnitTest, SystemTest, or Production.
The runtime will display helpful hints to correct common mistakes
when the value is Development.
</description>
<param-name>javax.faces.PROJECT_STAGE</param-name>
<param-value>Development</param-value>
</context-param>

4. Add Faces Servlet

<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.jsf</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>/faces/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.xhtml</url-pattern>
</servlet-mapping>

5. Add a blank faces-config.xml in WEB-INF

<?xml version="1.0" encoding='UTF-8'?>
<faces-config xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd"
version="2.0">
</faces-config>

6. Add new jar lib of jstl 1.2 and jsf 2.0.x

jstl-api-1.2.jar
jsf-api.jar
jsf-impl.jar

Problem
In JSF 2.0 web application, during server initialization, it hits following warning message
WARNING: JSF1063: WARNING! Setting non-serializable attribute value into HttpSession (key: userBean, value class: com.jsfcompref.model.UserBean).

UserBean
package com.mkyong;

@ManagedBean(name="user")
@SessionScoped
public class UserBean{

//...
}

The “UserBean” is not serializable, Simply make this bean implement java.io.Serializable interface.

package com.mkyong;

import java.io.Serializable;

@ManagedBean(name="user")
@SessionScoped
public class UserBean implements Serializable{

//...
}

JSF 2 getting issue in Tomcat 7

2011-08-09T11:55:00.000-04:00

There is an JSF 2.1 bug which cause Tomcat 7 problem. You will get below error if you are using JSF 2.1 under Tocmcat 7.

java.lang.InstantiationException: com.sun.faces.application.ServletContextSensitiveSingletonStore at java.lang.Class.newInstance0(Class.java:340) at java.lang.Class.newInstance(Class.java:308) at org.apache.catalina.core.DefaultInstanceManager.newInstance(DefaultInstanceManager.java:118) at org.apache.catalina.core.StandardContext.listenerStart(StandardContext.java:4268) at org.apache.catalina.core.StandardContext.startInternal(StandardContext.java:4771) at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:138) at org.apache.catalina.core.ContainerBase.addChildInternal(ContainerBase.java:785) at org.apache.catalina.core.ContainerBase.addChild(ContainerBase.java:763) at org.apache.catalina.core.StandardHost.addChild(StandardHost.java:558) at org.apache.catalina.startup.HostConfig.deployDescriptor(HostConfig.java:674) at org.apache.catalina.startup.HostConfig.deployDescriptors(HostConfig.java:599) at org.apache.catalina.startup.HostConfig.deployApps(HostConfig.java:538) at org.apache.catalina.startup.HostConfig.start(HostConfig.java:1390) at org.apache.catalina.startup.HostConfig.lifecycleEvent(HostConfig.java:355) at org.apache.catalina.util.LifecycleSupport.fireLifecycleEvent(LifecycleSupport.java:119) at org.apache.catalina.util.LifecycleBase.fireLifecycleEvent(LifecycleBase.java:89) at org.apache.catalina.util.LifecycleBase.setState(LifecycleBase.java:312) at org.apache.catalina.util.LifecycleBase.setState(LifecycleBase.java:292) at org.apache.catalina.core.ContainerBase.startInternal(ContainerBase.java:998) at org.apache.catalina.core.StandardHost.startInternal(StandardHost.java:772) at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:138) at org.apache.catalina.core.ContainerBase.startInternal(ContainerBase.java:990) at org.apache.catalina.core.StandardEngine.startInternal(StandardEngine.java:275) at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:138) at org.apache.catalina.core.StandardService.startInternal(StandardService.java:424) at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:138) at org.apache.catalina.core.StandardServer.startInternal(StandardServer.java:648) at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:138) at org.apache.catalina.startup.Catalina.start(Catalina.java:576) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:597) at org.apache.catalina.startup.Bootstrap.start(Bootstrap.java:288) at org.apache.catalina.startup.Bootstrap.main(Bootstrap.java:415)

To fix this you must switch back to JSF 2.0.X stable version.

C#文件操作大全

2011-06-24T00:03:00.000-04:00

1.创建文件夹
//using System.IO;
Directory.CreateDirectory(%%1);
2.创建文件
//using System.IO;
File.Create(%%1);
3.删除文件
//using System.IO;
File.Delete(%%1);
4.删除文件夹
//using System.IO;
Directory.Delete(%%1);
5.删除一个目录下所有的文件夹
//using System.IO;
foreach (string dirStr in Directory.GetDirectories(%%1))
{
DirectoryInfo dir = new DirectoryInfo(dirStr);
ArrayList folders=new ArrayList();
FileSystemInfo[] fileArr = dir.GetFileSystemInfos();
for (int i = 0; i < folders.Count; i++)
{
FileInfo f = folders[i] as FileInfo;
if (f == null)
{
DirectoryInfo d = folders[i] as DirectoryInfo;
d.Delete();
}
}
}
6.清空文件夹
//using System.IO;
Directory.Delete(%%1,true);
Directory.CreateDirectory(%%1);
7.读取文件
//using System.IO;
StreamReader s = File.OpenText(%%1);
string %%2 = null;
while ((%%2 = s.ReadLine()) != null){
%%3
}
s.Close();
8.写入文件
//using System.IO;
FileInfo f = new FileInfo(%%1);
StreamWriter w = f.CreateText();
w.WriteLine(%%2);
w.Close();
9.写入随机文件
//using System.IO;
byte[] dataArray = new byte[100000];//new Random().NextBytes(dataArray);
using(FileStream FileStream = new FileStream(%%1, FileMode.Create)){
// Write the data to the file, byte by byte.
for(int i = 0; i < dataArray.Length; i++){
FileStream.WriteByte(dataArray[i]);
}
// Set the stream position to the beginning of the file.
FileStream.Seek(0, SeekOrigin.Begin);
// Read and verify the data.
for(int i = 0; i < FileStream.Length; i++){
if(dataArray[i] != FileStream.ReadByte()){
//写入数据错误
return;
}
}
//"数据流"+FileStream.Name+"已验证"
}
10.读取文件属性
//using System.IO;
FileInfo f = new FileInfo(%%1);//f.CreationTime,f.FullName
if((f.Attributes & FileAttributes.ReadOnly) != 0){
%%2
}
else{
%%3
}
11.写入属性
//using System.IO;
FileInfo f = new FileInfo(%%1);
//设置只读
f.Attributes = myFile.Attributes | FileAttributes.ReadOnly;
//设置可写
f.Attributes = myFile.Attributes & ~FileAttributes.ReadOnly;
12.枚举一个文件夹中的所有文件夹
//using System.IO;
foreach (string %%2 in Directory.GetDirectories(%%1)){
%%3
}
/*
DirectoryInfo dir = new DirectoryInfo(%%1);
FileInfo[] files = dir.GetFiles("*.*");
foreach(FileInfo %%2 in files){
%%3
}
*/
13.复制文件夹
/*
using System.IO;
using System.Collections;
*/
string path = (%%2.LastIndexOf("\\") == %%2.Length - 1) ? %%2 : %%2+"\\";
string parent = Path.GetDirectoryName(%%1);
Directory.CreateDirectory(path + Path.GetFileName(%%1));
DirectoryInfo dir = new DirectoryInfo((%%1.LastIndexOf("\\") == %%1.Length - 1) ? %%1 : %%1 + "\\");
FileSystemInfo[] fileArr = dir.GetFileSystemInfos();
Queue Folders = new Queue(dir.GetFileSystemInfos());
while (Folders.Count>0)
{
FileSystemInfo tmp = Folders.Dequeue();
FileInfo f = tmp as FileInfo;
if (f == null)
{
DirectoryInfo d = tmp as DirectoryInfo;
Directory.CreateDirectory(d.FullName.Replace((parent.LastIndexOf("\\") == parent.Length - 1) ? parent : parent + "\\", path));
foreach (FileSystemInfo fi in d.GetFileSystemInfos())
{
Folders.Enqueue(fi);
}
}
else
{
f.CopyTo(f.FullName.Replace(parent, path));
}
}
14.复制目录下所有的文件夹到另一个文件夹下
/*
using System.IO;
using System.Collections;
*/
DirectoryInfo d = new DirectoryInfo(%%1);
foreach (DirectoryInfo dirs in d.GetDirectories())
{
Queue al = new Queue(dirs.GetFileSystemInfos());
while (al.Count > 0)
{
FileSystemInfo temp = al.Dequeue();
FileInfo file = temp as FileInfo;
if (file == null)
{
DirectoryInfo directory = temp as DirectoryInfo;
Directory.CreateDirectory(path + directory.Name);
foreach (FileSystemInfo fsi in directory.GetFileSystemInfos())
al.Enqueue(fsi);
}
else
File.Copy(file.FullName, path + file.Name);
}
}
15.移动文件夹
/*
using System.IO;
using System.Collections;
*/
string filename = Path.GetFileName(%%1);
string path=(%%2.LastIndexOf("\\") == %%2.Length - 1) ? %%2 : %%2 + "\\";
if (Path.GetPathRoot(%%1) == Path.GetPathRoot(%%2))
Directory.Move(%%1, path + filename);
else
{
string parent = Path.GetDirectoryName(%%1);
Directory.CreateDirectory(path + Path.GetFileName(%%1));
DirectoryInfo dir = new DirectoryInfo((%%1.LastIndexOf("\\") == %%1.Length - 1) ? %%1 : %%1 + "\\");
FileSystemInfo[] fileArr = dir.GetFileSystemInfos();
Queue Folders = new Queue(dir.GetFileSystemInfos());
while (Folders.Count > 0)
{
FileSystemInfo tmp = Folders.Dequeue();
FileInfo f = tmp as FileInfo;
if (f == null)
{
DirectoryInfo d = tmp as DirectoryInfo;
DirectoryInfo dpath = new DirectoryInfo(d.FullName.Replace((parent.LastIndexOf("\\") == parent.Length - 1) ? parent : parent + "\\", path));
dpath.Create();
foreach (FileSystemInfo fi in d.GetFileSystemInfos())
{
Folders.Enqueue(fi);
}
}
else
{
f.MoveTo(f.FullName.Replace(parent, path));
}
}
Directory.Delete(%%1, true);
}
16.移动目录下所有的文件夹到另一个目录下
/*
using System.IO;
using System.Collections;
*/
string filename = Path.GetFileName(%%1);
if (Path.GetPathRoot(%%1) == Path.GetPathRoot(%%2))
foreach (string dir in Directory.GetDirectories(%%1))
Directory.Move(dir, Path.Combine(%%2,filename));
else
{
foreach (string dir2 in Directory.GetDirectories(%%1))
{
string parent = Path.GetDirectoryName(dir2);
Directory.CreateDirectory(Path.Combine(%%2, Path.GetFileName(dir2)));
string dir = (dir2.LastIndexOf("\\") == dir2.Length - 1) ? dir2 : dir2 + "\\";
DirectoryInfo dirdir = new DirectoryInfo(dir);
FileSystemInfo[] fileArr = dirdir.GetFileSystemInfos();
Queue Folders = new Queue(dirdir.GetFileSystemInfos());
while (Folders.Count > 0)
{
FileSystemInfo tmp = Folders.Dequeue();
FileInfo f = tmp as FileInfo;
if (f == null)
{
DirectoryInfo d = tmp as DirectoryInfo;
DirectoryInfo dpath = new DirectoryInfo(d.FullName.Replace((parent.LastIndexOf("\\") == parent.Length - 1) ? parent : parent + "\\", %%2));
dpath.Create();
foreach (FileSystemInfo fi in d.GetFileSystemInfos())
{
Folders.Enqueue(fi);
}
}
else
{
f.MoveTo(f.FullName.Replace(parent, %%2));
}
}
dirdir.Delete(true);
}
}
17.以一个文件夹的框架在另一个目录创建文件夹和空文件
/*
using System.IO;
using System.Collections;
*/
bool b=false;
string path = (%%2.LastIndexOf("\\") == %%2.Length - 1) ? %%2 : %%2 + "\\";
string parent = Path.GetDirectoryName(%%1);
Directory.CreateDirectory(path + Path.GetFileName(%%1));
DirectoryInfo dir = new DirectoryInfo((%%1.LastIndexOf("\\") == %%1.Length - 1) ? %%1 : %%1 + "\\");
FileSystemInfo[] fileArr = dir.GetFileSystemInfos();
Queue Folders = new Queue(dir.GetFileSystemInfos());
while (Folders.Count > 0)
{
FileSystemInfo tmp = Folders.Dequeue();
FileInfo f = tmp as FileInfo;
if (f == null)
{
DirectoryInfo d = tmp as DirectoryInfo;
Directory.CreateDirectory(d.FullName.Replace((parent.LastIndexOf("\\") == parent.Length - 1) ? parent : parent + "\\", path));
foreach (FileSystemInfo fi in d.GetFileSystemInfos())
{
Folders.Enqueue(fi);
}
}
else
{
if(b) File.Create(f.FullName.Replace(parent, path));
}
}
18.复制文件
//using System.IO;
File.Copy(%%1,%%2);
19.复制一个文件夹下所有的文件到另一个目录
//using System.IO;
foreach (string fileStr in Directory.GetFiles(%%1))
File.Copy((%%1.LastIndexOf("\\") == %%1.Length - 1) ? %%1 +Path.GetFileName(fileStr): %%1 + "\\"+Path.GetFileName(fileStr),(%%2.LastIndexOf("\\") == %%2.Length - 1) ? %%2 +Path.GetFileName(fileStr): %%2 + "\\"+Path.GetFileName(fileStr));
20.提取扩展名
//using System.IO;
string %%2=Path.GetExtension(%%1);
21.提取文件名
//using System.IO;
string %%2=Path.GetFileName(%%1);
22.提取文件路径
//using System.IO;
string %%2=Path.GetDirectoryName(%%1);
23.替换扩展名
//using System.IO;
File.ChangeExtension(%%1,%%2);
24.追加路径
//using System.IO;
string %%3=Path.Combine(%%1,%%2);
25.移动文件
//using System.IO;
File.Move(%%1,%%2+"\\"+file.getname(%%1));
26.移动一个文件夹下所有文件到另一个目录
foreach (string fileStr in Directory.GetFiles(%%1))
File.Move((%%1.LastIndexOf("\\") == %%1.Length - 1) ? %%1 +Path.GetFileName(fileStr): %%1 + "\\"+Path.GetFileName(fileStr),(%%2.LastIndexOf("\\") == %%2.Length - 1) ? %%2 +Path.GetFileName(fileStr): %%2 + "\\"+Path.GetFileName(fileStr));
27.指定目录下搜索文件
/*
using System.Text;
using System.IO;
*/
string fileName=%%1;
string dirName=%%2;
DirectoryInfo dirc=new DirectoryInfo(dirName);
foreach(FileInfo file in dirc.GetFiles()) {
if(file.Name.IndexOf(fileName)>-1)
return file.FullName;
}
foreach(DirectoryInfo dir in dirc.GetDirectories()) {
return GetFile(fileName,dir.FullName);
}
return "找不到指定的文件";
}
28.打开对话框
OpenFileDialog penFileDialog=new OpenFileDialog();
openFileDialog.InitialDirectory=\"c:\\\\\";//注意这里写路径时要用c:\\\\而不是c:\\
openFileDialog.Filter=\"文本文件|*.*|C#文件|*.cs|所有文件|*.*\";
openFileDialog.RestoreDirectory=true;
openFileDialog.FilterIndex=1;
if (openFileDialog.ShowDialog()==DialogResult.OK) {
fName=openFileDialog.FileName;
File fileOpen=new File(fName);
isFileHaveName=true;
%%1=fileOpen.ReadFile();
%%1.AppendText(\"\");
}
29.文件分割
//using System.IO;
FileStream fsr = new FileStream(%%1, FileMode.Open, FileAccess.Read);
byte[] btArr = new byte[fsr.Length];
fsr.Read(btArr, 0, btArr.Length);
fsr.Close();
string strFileName=%%1.Substring(%%1.LastIndexOf("\\")+1);
FileStream fsw = new FileStream(%%2 + strFileName + "1", FileMode.Create, FileAccess.Write);
fsw.Write(btArr, 0, btArr.Length/2);
fsw.Close();
fsw = new FileStream(%%2 + strFileName + "2", FileMode.Create, FileAccess.Write);
fsw.Write(btArr, btArr.Length/2, btArr.Length-btArr.Length/2);
fsw.Close();
30.文件合并
//using System.IO;
string strFileName = %%1.Substring(%%1.LastIndexOf("\\") + 1);
FileStream fsr1 = new FileStream(%%2 + strFileName + "1", FileMode.Open, FileAccess.Read);
FileStream fsr2 = new FileStream(%%2 + strFileName + "2", FileMode.Open, FileAccess.Read);
byte[] btArr = new byte[fsr1.Length+fsr2.Length];
fsr1.Read(btArr, 0, Convert.ToInt32(fsr1.Length));
fsr2.Read(btArr, Convert.ToInt32(fsr1.Length), Convert.ToInt32(fsr2.Length));
fsr1.Close();fsr2.Close();
FileStream fsw = new FileStream(%%2 + strFileName, FileMode.Create, FileAccess.Write);
fsw.Write(btArr, 0, btArr.Length);
fsw.Close();
31.文件简单加密
//using System.IO;
//读文件
FileStream fsr = new FileStream(%%1, FileMode.Open, FileAccess.Read);
byte[] btArr = new byte[fsr.Length];
fsr.Read(btArr, 0, btArr.Length);
fsr.Close();
for (int i = 0; i < btArr.Length; i++){ //加密
int ibt = btArr[i];
ibt += 100;
ibt %= 256;
btArr[i] = Convert.ToByte(ibt);
}
//写文件
string strFileName = Path.GetExtension(%%1);
FileStream fsw = new FileStream(%%2+"/" + "enc_" + strFileName, FileMode.Create, FileAccess.Write);
fsw.Write(btArr, 0, btArr.Length);
fsw.Close();
32.文件简单解密
//using System.IO;
FileStream fsr = new FileStream(%%1, FileMode.Open, FileAccess.Read);
byte[] btArr = new byte[fsr.Length];
fsr.Read(btArr, 0, btArr.Length);
fsr.Close();
for (int i = 0; i < btArr.Length; i++){　//解密
int ibt = btArr[i];
ibt -= 100;
ibt += 256;
ibt %= 256;
btArr[i] = Convert.ToByte(ibt);
}
//写文件
string strFileName = Path.GetExtension(%%1);
FileStream fsw = new FileStream(%%2 +"/" + strFileName, FileMode.Create, FileAccess.Write);
fsw.Write(btArr, 0, btArr.Length);
fsw.Close();
33.读取ini文件属性
//using System.Runtime.InteropServices;
//[DllImport("kernel32")]//返回取得字符串缓冲区的长度
//private static extern long GetPrivateProfileString(string section,string key, string def,StringBuilder retVal,int size,string filePath);
string Section=%%1;
string Key=%%2;
string NoText=%%3;
string iniFilePath="Setup.ini";
string %%4=String.Empty;
if(File.Exists(iniFilePath)){
StringBuilder temp = new StringBuilder(1024);
GetPrivateProfileString(Section,Key,NoText,temp,1024,iniFilePath);
%%4=temp.ToString();
}
34.合并一个目录下所有的文件
//using System.IO;
FileStream fsw = new FileStream(%%2, FileMode.Create, FileAccess.Write);
foreach (string fileStr in Directory.GetFiles(%%1))
{
FileStream fsr1 = new FileStream(fileStr, FileMode.Open, FileAccess.Read);
byte[] btArr = new byte[fsr1.Length];
fsr1.Read(btArr, 0, Convert.ToInt32(fsr1.Length));
fsr1.Close();
fsw.Write(btArr, 0, btArr.Length);
}
fsw.Close();
35.写入ini文件属性
//using System.Runtime.InteropServices;
//[DllImport("kernel32")]//返回0表示失败，非0为成功
//private static extern long WritePrivateProfileString(string section,string key, string val,string filePath);
string Section=%%1;
string Key=%%2;
string Value=%%3;
string iniFilePath="Setup.ini";
bool %%4=false;
if(File.Exists(iniFilePath))
{
long pStation = WritePrivateProfileString(Section,Key,Value,iniFilePath);
if(OpStation == 0)
{
%%4=false;
}
else
{
%%4=true;
}
}
36.获得当前路径
string %%1=Environment.CurrentDirectory;
37.读取XML数据库
//using System.Xml;
XmlDocument doc=new XmlDocument();
doc.Load(%%1);
string %%9;
XmlElement xe=doc.GetElementById(%%7);
XmlNodeList elemList=xe.ChildNodes;
foreach(XmlNode elem in elemList)
{
if(elem.NodeType==%%8)
{
%%9=elem.Value;
break;
}
}
38.写入XML数据库
//using System.Xml;
XmlDocument doc=new XmlDocument();
doc.Load(%%1);
XmlNode root=doc.DocumentElement;
XmlElement book=doc.CreateElement(%%3);
XmlElement book=doc.CreateElement(%%5);
XmlElement port=doc.CreateElement(%%6);
book.SetAttribute(%%4,root.ChildNodes.Count.ToString());
author.InnerText=%%8;
book.appendChild(author);
book.appendChild(port);
root.appendChild(book);
doc.Save(%%1);
39.ZIP压缩文件
/*
using System.IO;
using System.IO.Compression;
*/
FileStream infile;
try
{
// Open the file as a FileStream object.
infile = new FileStream(%%1, FileMode.Open, FileAccess.Read, FileShare.Read);
byte[] buffer = new byte[infile.Length];
// Read the file to ensure it is readable.
int count = infile.Read(buffer, 0, buffer.Length);
if (count != buffer.Length)
{
infile.Close();
//Test Failed: Unable to read data from file
return;
}
infile.Close();
MemoryStream ms = new MemoryStream();
// Use the newly created memory stream for the compressed data.
DeflateStream compressedzipStream = new DeflateStream(ms, CompressionMode.Compress, true);
//Compression
compressedzipStream.Write(buffer, 0, buffer.Length);
// Close the stream.
compressedzipStream.Close();
//Original size: {0}, Compressed size: {1}", buffer.Length, ms.Length);
FileInfo f = new FileInfo(%%2);
StreamWriter w = f.CreateText();
w.Write(buffer,0,ms.Length);
w.Close();
} // end try
catch (InvalidDataException)
{
//Error: The file being read contains invalid data.
} catch (FileNotFoundException)
{
//Error:The file specified was not found.
} catch (ArgumentException)
{
//Error: path is a zero-length string, contains only white space, or contains one or more invalid characters
} catch (PathTooLongException)
{
//Error: The specified path, file name, or both exceed the system-defined maximum length. For example, on Windows-based
platforms, paths must be less than 248 characters, and file names must be less than 260 characters.
} catch (DirectoryNotFoundException)
{
//Error: The specified path is invalid, such as being on an unmapped drive.
} catch (IOException)
{
//Error: An I/O error occurred while opening the file.
} catch (UnauthorizedAccessException)
{
//Error: path specified a file that is read-only, the path is a directory, or caller does not have the required
permissions.
} catch (IndexOutOfRangeException)
{
//Error: You must provide parameters for MyGZIP.
}
40.ZIP解压缩
/*
using System.IO;
using System.IO.Compression;
*/
FileStream infile;
try
{
// Open the file as a FileStream object.
infile = new FileStream(%%1, FileMode.Open, FileAccess.Read, FileShare.Read);
byte[] buffer = new byte[infile.Length];
// Read the file to ensure it is readable.
int count = infile.Read(buffer, 0, buffer.Length);
if (count != buffer.Length)
{
infile.Close();
//Test Failed: Unable to read data from file
return;
}
infile.Close();
MemoryStream ms = new MemoryStream();
// ms.Position = 0;
DeflateStream zipStream = new DeflateStream(ms, CompressionMode.Decompress);
//Decompression
byte[] decompressedBuffer = new byte[buffer.Length *2];
zipStream.Close();
FileInfo f = new FileInfo(%%2);
StreamWriter w = f.CreateText();
w.Write(decompressedBuffer);
w.Close();
} // end try
catch (InvalidDataException)
{
//Error: The file being read contains invalid data.
}
catch (FileNotFoundException)
{
//Error:The file specified was not found.
}
catch (ArgumentException)
{
//Error: path is a zero-length string, contains only white space, or contains one or more invalid characters
}
catch (PathTooLongException)
{
//Error: The specified path, file name, or both exceed the system-defined maximum length. For example, on Windows-based
platforms, paths must be less than 248 characters, and file names must be less than 260 characters.
}
catch (DirectoryNotFoundException)
{
//Error: The specified path is invalid, such as being on an unmapped drive.
}
catch (IOException)
{
//Error: An I/O error occurred while opening the file.
}
catch (UnauthorizedAccessException)
{
//Error: path specified a file that is read-only, the path is a directory, or caller does not have the required
permissions.
}
catch (IndexOutOfRangeException)
{
//Error: You must provide parameters for MyGZIP.
}
41.获得应用程序完整路径
string %%1=Application.ExecutablePath;
42.ZIP压缩文件夹
/*
using System.IO;
using System.IO.Compression;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
*/
private void CreateCompressFile(Stream source, string destinationName)
{
using (Stream destination = new FileStream(destinationName, FileMode.Create, FileAccess.Write))
{
using (GZipStream utput = new GZipStream(destination, CompressionMode.Compress))
{
byte[] bytes = new byte[4096];
int n;
while ((n = source.Read(bytes, 0, bytes.Length)) != 0)
{
output.Write(bytes, 0, n);
}
}
}
}
ArrayList list = new ArrayList();
foreach (string f in Directory.GetFiles(%%1))
{
byte[] destBuffer = File.ReadAllBytes(f);
SerializeFileInfo sfi = new SerializeFileInfo(f, destBuffer);
list.Add(sfi);
}
IFormatter formatter = new BinaryFormatter();
using (Stream s = new MemoryStream())
{
formatter.Serialize(s, list);
s.Position = 0;
CreateCompressFile(s, %%2);
}
[Serializable]
class SerializeFileInfo
{
public SerializeFileInfo(string name, byte[] buffer)
{
fileName = name;
fileBuffer = buffer;
}
string fileName;
public string FileName
{
get
{
return fileName;
}
}
byte[] fileBuffer;
public byte[] FileBuffer
{
get
{
return fileBuffer;
}
}
}
43.递归删除目录下的文件
//using System.IO;
DirectoryInfo DInfo=new DirectoryInfo(%%1);
FileSystemInfo[] FSInfo=DInfo.GetFileSystemInfos();
for(int i=0;i{
FileInfo FInfo=new FileInfo(%%1+FSInfo[i].ToString());
FInfo.Delete();
}
44.验证DTD
/*
using System.Xml;
using System.Xml.Schema;
*/
XmlReaderSettings settings = new XmlReaderSettings();
settings.ProhibitDtd = false;
settings.ValidationType = ValidationType.DTD;
settings.ValidationEventHandler += new ValidationEventHandler(ValidationCallBack);
// Create the XmlReader object.
XmlReader reader = XmlReader.Create("my book.xml", settings);
// Parse the file.
while (reader.Read());
// Display any validation errors.
private static void ValidationCallBack(object sender, ValidationEventArgs e)
{
Console.WriteLine("Validation Error: {0}", e.Message);
}
45.Schema 验证
/*
using System.Xml;
using System.Xml.Schema;
*/
Boolean m_success;
XmlValidatingReader reader = null;
XmlSchemaCollection myschema = new XmlSchemaCollection();
ValidationEventHandler eventHandler = new ValidationEventHandler(ShowCompileErrors);
try
{
//Create the XML fragment to be parsed.
String xmlFrag = "" +
"Herman" +
"Melville" +
"";
//Create the XmlParserContext.
XmlParserContext context = new XmlParserContext(null, null, "", XmlSpace.None);
//Implement the reader.
reader = new XmlValidatingReader(xmlFrag, XmlNodeType.Element, context);
//Add the schema.
myschema.Add("urn:bookstore-schema", "c:\\Books.xsd");
//Set the schema type and add the schema to the reader.
reader.ValidationType = ValidationType.Schema;
reader.Schemas.Add(myschema);
while (reader.Read())
{
}
Console.WriteLine("Completed validating xmlfragment");
}
catch (XmlException XmlExp)
{
Console.WriteLine(XmlExp.Message);
}
catch(XmlSchemaException XmlSchExp)
{
Console.WriteLine(XmlSchExp.Message);
}
catch(Exception GenExp)
{
Console.WriteLine(GenExp.Message);
}
finally
{
Console.Read();
}
public static void ShowCompileErrors(object sender, ValidationEventArgs args)
{
Console.WriteLine("Validation Error: {0}", args.Message);
}
46.Grep
/*
using System.Collections;
using System.Text.RegularExpressions;
using System.IO;
using System.Security;
using CommandLine.Utility;
*/
//Traditionally grep stands for "Global Regular Expression Print".
//Global means that an entire file is searched.
//Regular Expression means that a regular expression string is used to establish a search pattern.
//Print means that the command will display its findings.
//Simply put, grep searches an entire file for the pattern you want and displays its findings.
//
//The use syntax is different from the traditional Unix syntax, I prefer a syntax similar to
//csc, the C# compiler.
//
// grep [/h|/H] - Usage Help
//
// grep [/c] [/i] [/l] [/n] [/r] /E:reg_exp /F:files
//
// /c - print a count of matching lines for each input file;
// /i - ignore case in pattern;
// /l - print just files (scanning will stop on first match);
// /n - prefix each line of output with line number;
// /r - recursive search in subdirectories;
//
// /E:reg_exp - the Regular Expression used as search pattern. The Regular Expression can be delimited by
// quotes like "..." and '...' if you want to include in it leading or trailing blanks;
//
// /F:files - the list of input files. The files can be separated by commas as in /F:file1,file2,file3
//and wildcards can be used for their specification as in /F:*file?.txt;
//
//Example:
//
// grep /c /n /r /E:" C Sharp " /F:*.cs
//Option Flags
private bool m_bRecursive;
private bool m_bIgnoreCase;
private bool m_bJustFiles;
private bool m_bLineNumbers;
private bool m_bCountLines;
private string m_strRegEx;
private string m_strFiles;
//ArrayList keeping the Files
private ArrayList m_arrFiles = new ArrayList();
//Properties
public bool Recursive
{
get { return m_bRecursive; }
set { m_bRecursive = value; }
}
public bool IgnoreCase
{
get { return m_bIgnoreCase; }
set { m_bIgnoreCase = value; }
}
public bool JustFiles
{
get { return m_bJustFiles; }
set { m_bJustFiles = value; }
}
public bool LineNumbers
{
get { return m_bLineNumbers; }
set { m_bLineNumbers = value; }
}
public bool CountLines
{
get { return m_bCountLines; }
set { m_bCountLines = value; }
}
public string RegEx
{
get { return m_strRegEx; }
set { m_strRegEx = value; }
}
public string Files
{
get { return m_strFiles; }
set { m_strFiles = value; }
}
//Build the list of Files
private void GetFiles(String strDir, String strExt, bool bRecursive)
{
//search pattern can include the wild characters '*' and '?'
string[] fileList = Directory.GetFiles(strDir, strExt);
for(int i=0; i{
if(File.Exists(fileList[i]))
m_arrFiles.Add(fileList[i]);
}
if(bRecursive==true)
{
//Get recursively from subdirectories
string[] dirList = Directory.GetDirectories(strDir);
for(int i=0; i{
GetFiles(dirList[i], strExt, true);
}
}
}
//Search Function
public void Search()
{
String strDir = Environment.CurrentDirectory;
//First empty the list
m_arrFiles.Clear();
//Create recursively a list with all the files complying with the criteria
String[] astrFiles = m_strFiles.Split(new Char[] {','});
for(int i=0; i{
//Eliminate white spaces
astrFiles[i] = astrFiles[i].Trim();
GetFiles(strDir, astrFiles[i], m_bRecursive);
}
//Now all the Files are in the ArrayList, open each one
//iteratively and look for the search string
String strResults = "Grep Results:\r\n\r\n";
String strLine;
int iLine, iCount;
bool bEmpty = true;
IEnumerator enm = m_arrFiles.GetEnumerator();
while(enm.MoveNext())
{
try
{
StreamReader sr = File.OpenText((string)enm.Current);
iLine = 0;
iCount = 0;
bool bFirst = true;
while((strLine = sr.ReadLine()) != null)
{
iLine++;
//Using Regular Expressions as a real Grep
Match mtch;
if(m_bIgnoreCase == true)
mtch = Regex.Match(strLine, m_strRegEx, RegexOptions.IgnoreCase);
else
mtch = Regex.Match(strLine, m_strRegEx);
if(mtch.Success == true)
{
bEmpty = false;
iCount++;
if(bFirst == true)
{
if(m_bJustFiles == true)
{
strResults += (string)enm.Current + "\r\n";
break;
}
else
strResults += (string)enm.Current + ":\r\n";
bFirst = false;
}
//Add the Line to Results string
if(m_bLineNumbers == true)
strResults += " " + iLine + ": " + strLine + "\r\n";
else
strResults += " " + strLine + "\r\n";
}
}
sr.Close();
if(bFirst == false)
{
if(m_bCountLines == true)
strResults += " " + iCount + " Lines Matched\r\n";
strResults += "\r\n";
}
}
catch(SecurityException)
{
strResults += "\r\n" + (string)enm.Current + ": Security Exception\r\n\r\n";
}
catch(FileNotFoundException)
{
strResults += "\r\n" + (string)enm.Current + ": File Not Found Exception\r\n";
}
}
if(bEmpty == true)
Console.WriteLine("No matches found!");
else
Console.WriteLine(strResults);
}
//Print Help
private static void PrintHelp()
{
Console.WriteLine("Usage: grep [/h|/H]");
Console.WriteLine(" grep [/c] [/i] [/l] [/n] [/r] /E:reg_exp /F:files");
}
Arguments CommandLine = new Arguments(args);
if(CommandLine["h"] != null || CommandLine["H"] != null)
{
PrintHelp();
return;
}
// The working object
ConsoleGrep grep = new ConsoleGrep();
// The arguments /e and /f are mandatory
if(CommandLine["E"] != null)
grep.RegEx = (string)CommandLine["E"];
else
{
Console.WriteLine("Error: No Regular Expression specified!");
Console.WriteLine();
PrintHelp();
return;
}
if(CommandLine["F"] != null)
grep.Files = (string)CommandLine["F"];
else
{
Console.WriteLine("Error: No Search Files specified!");
Console.WriteLine();
PrintHelp();
return;
}
grep.Recursive = (CommandLine["r"] != null);
grep.IgnoreCase = (CommandLine["i"] != null);
grep.JustFiles = (CommandLine["l"] != null);
if(grep.JustFiles == true)
grep.LineNumbers = false;
else
grep.LineNumbers = (CommandLine["n"] != null);
if(grep.JustFiles == true)
grep.CountLines = false;
else
grep.CountLines = (CommandLine["c"] != null);
// Do the search
grep.Search();
47.直接创建多级目录
//using System.IO;
DirectoryInfo di=new DirectoryInfo(%%1);
di.CreateSubdirectory(%%2);
48.批量重命名
//using System.IO;
string strOldFileName; string strNewFileName; string strOldPart =this.textBox1.Text.Trim();//重命名文件前的文件名等待替换字符串
string strNewPart = this.textBox2.Text.Trim();//重命名文件后的文件名替换字符串
string strNewFilePath;
string strFileFolder; //原始图片目录
int TotalFiles = 0; DateTime StartTime = DateTime.Now; //获取开始时间
FolderBrowserDialog f1 = new FolderBrowserDialog(); //打开选择目录对话框
if (f1.ShowDialog() == DialogResult.OK) {
strFileFolder = f1.SelectedPath;
DirectoryInfo di = new DirectoryInfo(strFileFolder);
FileInfo[] filelist = di.GetFiles("*.*");
int i = 0;
foreach (FileInfo fi in filelist) {
strOldFileName = fi.Name;
strNewFileName = fi.Name.Replace(strOldPart, strNewPart);
strNewFilePath = @strFileFolder + "\\" + strNewFileName;
filelist[i].MoveTo(@strNewFilePath); TotalFiles += 1;
this.listBox1.Items.Add("文件名：" + strOldFileName + "已重命名为" + strNewFileName);
i += 1;
}
}
DateTime EndTime = DateTime.Now;//获取结束时间
TimeSpan ts = EndTime - StartTime; this.listBox1.Items.Add("总耗时：" + ts.Hours.ToString() + "时" +ts.Minutes.ToString() + "分" + ts.Seconds.ToString() + "秒");
49.文本查找替换
/*
using System.Text;
using System.Text.RegularExpressions;
using System.IO;
*/
if (args.Length == 3)
{
ReplaceFiles(args[0],args[1],args[2],null);
}
if (args.Length == 4)
{
if (args[3].Contains("v"))
{
ReplaceVariable(args[0], args[1], args[2], args[3]);
}
else
{
ReplaceFiles(args[0], args[1], args[2], args[3]);
}
}
/**////

/// 替换环境变量中某个变量的文本值。可以是系统变量，用户变量，临时变量。替换时会覆盖原始值。小心使用
///

///
///
///
///
public static void ReplaceVariable(string variable, string search, string replace, string options)
{
string variable=%%1;
string search=%%2;
string replace=%%3;
string text=Environment.GetEnvironmentVariable(variable);
System.Windows.Forms.MessageBox.Show(text);
text=ReplaceText(text, search, replace, options);
Environment.SetEnvironmentVariable(variable, text);
text = Environment.GetEnvironmentVariable(variable);
System.Windows.Forms.MessageBox.Show(text);
}

/**////

/// 批量替换文件文本
///

///
public static void ReplaceFiles(string path,string search, string replace, string options)
{
string path=%%1;
string search=%%2;
string replace=%%3;
string[] fs;
if(File.Exists(path)){
ReplaceFile(path, search, replace, options);
return;
}
if (Directory.Exists(path))
{
fs = Directory.GetFiles(path);
foreach (string f in fs)
{
ReplaceFile(f, search, replace, options);
}
return;
}
int i=path.LastIndexOf("\");
if(i<0)i=path.LastIndexOf("/");
string d, searchfile;
if (i > -1)
{
d = path.Substring(0, i + 1);
searchfile = path.Substring(d.Length);
}
else
{
d = System.Environment.CurrentDirectory;
searchfile = path;
}
searchfile = searchfile.Replace(".", @".");
searchfile = searchfile.Replace("?", @"[^.]?");
searchfile = searchfile.Replace("*", @"[^.]*");
//System.Windows.Forms.MessageBox.Show(d); System.Windows.Forms.MessageBox.Show(searchfile);
if (!Directory.Exists(d)) return;
fs = Directory.GetFiles(d);
foreach (string f in fs)
{
if(System.Text.RegularExpressions.Regex.IsMatch(f,searchfile))
ReplaceFile(f, search, replace, options);
}
}

/**////

/// 替换单个文本文件中的文本
///

///
///
///
///
///
public static bool ReplaceFile(string filename, string search, string replace,string options)
{
string path=%%1;
string search=%%2;
string replace=%%3;
FileStream fs = File.OpenRead(filename);
//判断文件是文本文件还二进制文件。该方法似乎不科学
byte b;
for (long i = 0; i < fs.Length; i++)
{
b = (byte)fs.ReadByte();
if (b == 0)
{
System.Windows.Forms.MessageBox.Show("非文本文件");
return false;//有此字节则表示改文件不是文本文件。就不用替换了
}
}
//判断文本文件编码规则。
byte[] bytes = new byte[2];
Encoding coding=Encoding.Default;
if (fs.Read(bytes, 0, 2) > 2)
{
if (bytes == new byte[2] { 0xFF, 0xFE }) coding = Encoding.Unicode;
if (bytes == new byte[2] { 0xFE, 0xFF }) coding = Encoding.BigEndianUnicode;
if (bytes == new byte[2] { 0xEF, 0xBB }) coding = Encoding.UTF8;
}
fs.Close();
//替换数据
string text=File.ReadAllText(filename, coding);
text=ReplaceText(text,search, replace, options);
File.WriteAllText(filename, text, coding);
return true;
}
/**////

/// 替换文本
///

///
///
///
///
///
public static string ReplaceText(string text, string search, string replace, string options)
{
RegexOptions ps = RegexOptions.None;
if (options == null) //纯文本替换
{
search = search.Replace(".", @".");
search = search.Replace("?", @"?");
search = search.Replace("*", @"*");
search = search.Replace("(", @"(");
search = search.Replace(")", @")");
search = search.Replace("[", @"[");
search = search.Replace("[", @"[");
search = search.Replace("[", @"[");
search = search.Replace("{", @"{");
search = search.Replace("}", @"}");
ops |= RegexOptions.IgnoreCase;
}
else
{
if(options.Contains("I"))ops |= RegexOptions.IgnoreCase;
}
text = Regex.Replace(text, search, replace, ops);
return text;
}
50.文件关联
//using Microsoft.Win32;
string keyName;
string keyValue;
keyName = %%1; //"WPCFile"
keyValue = %%2; //"资源包文件"
RegistryKey isExCommand = null;
bool isCreateRegistry = true;
try
{
/// 检查文件关联是否创建
isExCommand = Registry.ClassesRoot.OpenSubKey(keyName);
if (isExCommand == null)
{
isCreateRegistry = true;
}
else
{
if (isExCommand.GetValue("Create").ToString() == Application.ExecutablePath.ToString())
{
isCreateRegistry = false;
}
else
{
Registry.ClassesRoot.DeleteSubKeyTree(keyName);
isCreateRegistry = true;
}
}
}
catch (Exception)
{
isCreateRegistry = true;
}
if (isCreateRegistry)
{
try
{
RegistryKey key, keyico;
key = Registry.ClassesRoot.CreateSubKey(keyName);
key.SetValue("Create", Application.ExecutablePath.ToString());
keyico = key.CreateSubKey("DefaultIcon");
keyico.SetValue("", Application.ExecutablePath + ",0");
key.SetValue("", keyValue);
key = key.CreateSubKey("Shell");
key = key.CreateSubKey("Open");
key = key.CreateSubKey("Command");
key.SetValue("", "\"" + Application.ExecutablePath.ToString() + "\" \"%1\"");
keyName = %%3; //".wpc"
keyValue = %%1;
key = Registry.ClassesRoot.CreateSubKey(keyName);
key.SetValue("", keyValue);
}
catch (Exception)
{
}
}
51.操作Excel文件
//using Excel;
private static string Connstring ;//连接字符串
Workbook myBook = null;
Worksheet mySheet=null;
Excel.ApplicationClass ExlApp = new ApplicationClass();
ExlApp.Visible =true;
object Missiong = System.Reflection.Missing.Value;
string reqpath = this.Request.PhysicalPath;
int pos = reqpath.LastIndexOf("\\");
reqpath = reqpath.Substring(0,pos);
ExlApp.Workbooks.Open(%%1,oMissiong, oMissiong, oMissiong,oMissiong, oMissiong, oMissiong,
oMissiong,oMissiong,oMissiong, oMissiong, oMissiong, oMissiong);//, oMissiong);//, oMissiong); // reqpath + "\\scxx.xls"
myBook = ExlApp.Workbooks[1];
mySheet = (Worksheet)myBook.Worksheets[1];
Excel.Range rg;
string mySelectQuery = %%2; //"SELECT dh, qy,zb FROM SCXXB"
using(SqlConnection myConnection = new SqlConnection(Connstring)){
SqlCommand myCommand = new SqlCommand(mySelectQuery,myConnection);
myConnection.Open();
SqlDataReader myReader;
myReader = myCommand.ExecuteReader();
// Always call Read before accessing data.
int recount=0;
while (myReader.Read())
{
recount=recount+1;
}
myReader.Close();
myConnection.Close();
int gho=3;
for(int i = 1; i < recount ; i ++)
{
rg = mySheet.get_Range("A" + gho.ToString(), "C" + ( gho ).ToString());
rg.Copy(oMissiong);
rg.Insert(XlInsertShiftDirection.xlShiftDown);
}
//从数据表中取数据
mySelectQuery = %%2; //"SELECT dh, qy,zb FROM SCXXB ORDER BY qy,zb";
myConnection = new SqlConnection(Connstring);
myCommand = new SqlCommand(mySelectQuery,myConnection);
myConnection.Open();
myReader = myCommand.ExecuteReader();
int Curhs = gho ;
while (myReader.Read())
{
mySheet.Cells[Curhs,1] =myReader["qy"].ToString() ;
mySheet.Cells[Curhs,2] =myReader["zb"].ToString() ;
mySheet.Cells[Curhs,3] =myReader["dh"].ToString() ;
Curhs ++;
}
myReader.Close();
//合并最后一页
MergeCell(ref mySheet,3 , recount ,"A"); //调用函数实现A列合并
MergeCell(ref mySheet,3 , recount ,"B"); //调用函数实现A列合并
myBook.SaveAs(%%1, oMissiong,oMissiong, oMissiong,oMissiong,oMissiong,Excel.XlSaveAsAccessMode.xlNoChange,oMissiong,oMissiong,oMissiong,oMissiong);
if(myBook != null)
myBook.Close(true, %%1, true);
if(mySheet != null)
System.Runtime.InteropServices.Marshal.ReleaseComObject (mySheet);
mySheet = null;
if(myBook != null)
System.Runtime.InteropServices.Marshal.ReleaseComObject (myBook);
myBook = null;
if(ExlApp != null)
{
ExlApp.Quit();
System.Runtime.InteropServices.Marshal.ReleaseComObject ((object)ExlApp);
ExlApp = null;
}
GC.Collect();
/// 合并单元格
private void MergeCell(ref Worksheet mySheet, int startLine,int RecCount, string Col)
{
string qy1 = mySheet.get_Range(Col + startLine.ToString(), Col + startLine.ToString()).Text.ToString();
Excel.Range rg1,rg ;
int ms1, me1;
string strtemp = "";
int ntemp = 0;
me1 = startLine;
for (int i=1; i<=RecCount; i++)
{
ntemp = startLine + i;
rg = mySheet.get_Range(Col+ ntemp.ToString(), Col+ ntemp.ToString());
strtemp = rg.Text.ToString().Trim();
if (qy1.Trim() != strtemp.Trim())
{
ms1 = me1;
me1 = i + startLine - 1;
//合并
if (me1-ms1>0)
{
rg1 = mySheet.get_Range(Col + ms1.ToString(), Col + me1.ToString());
rg1.ClearContents();
rg1.MergeCells = true;
if(Col == "A")
mySheet.Cells[ms1,1] = qy1;
else if (Col == "B")
mySheet.Cells[ms1,2] = qy1;
}
me1 += 1;
strtemp = mySheet.get_Range(Col + me1.ToString(), Col + me1.ToString()).Text.ToString();
if(strtemp.Trim() != "")
qy1 = strtemp;
}
}
}
52.设置JDK环境变量
/*
JAVA_HOME=C:\j2sdk1.4.2_04
CLASSPATH=.;C:\j2sdk1.4.2_04\lib\tools.jar;C:\j2sdk1.4.2_04\lib\dt.jar;C:\j2sdk1.4.2_04
path=C:\j2sdk1.4.2_04\bin;
*/
//using Microsoft.Win32;
int isFileNum=0;
int i=0;
Environment.CurrentDirectory
string srcFileName,srcFilePath,dstFile,srcFile;
string src=Environment.CurrentDirectory+"\\*.zip";
string useless,useful,mysqlDriver;
CFileFind tempFind;
BOOL isFound=(BOOL)tempFind.FindFile(src);
RegistryKey rkLocalM = Registry.CurrentUser; //Registry.ClassesRoot, Registry.LocalMachine, Registry.Users, Registry.CurrentConfig
const string strSubKey = "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\RunMRU";
RegistryKey rkSub = rkLocalM.CreateSubKey( strSubKey );
rkSub.SetValue("a","winword -q\\1");
rkSub.SetValue("MRUList","azyxwvutsrqponmlkjihgfedcb");
rkSub.SetValue("b","cmd /k\\1");
rkSub.SetValue("c","iexplore -k\\1");
rkSub.SetValue("d","iexpress\\1");
rkSub.SetValue("e","mmc\\1");
rkSub.SetValue("f","msconfig\\1");
rkSub.SetValue("g","regedit\\1");
rkSub.SetValue("h","regedt32\\1");
rkSub.SetValue("i","Regsvr32 /u wmpshell.dll\\1");
rkSub.SetValue("j","sfc /scannow\\1");
rkSub.SetValue("k","shutdown -s -f -t 600\\1");
rkSub.SetValue("l","shutdown -a\\1");
rkSub.SetValue("m","C:\\TurboC\\BIN\\TC.EXE\\1");
rkSub.SetValue("n","services.msc\\1");
rkSub.SetValue("o","gpedit.msc\\1");
rkSub.SetValue("p","fsmgmt.msc\\1");
rkSub.SetValue("q","diskmgmt.msc\\1");
rkSub.SetValue("r","dfrg.msc\\1");
rkSub.SetValue("s","devmgmt.msc\\1");
rkSub.SetValue("t","compmgmt.msc\\1");
rkSub.SetValue("u","ciadv.msc\\1");
rkSub.SetValue("v","C:\\MATLAB701\\bin\\win32\\MATLAB.exe -nosplash -nojvm\\1");
rkSub.SetValue("w","C:\\MATLAB701\\bin\\win32\\MATLAB.exe -nosplash\\1");
rkSub.SetValue("x","C:\\Program Files\\Kingsoft\\PowerWord 2005\\XDICT.EXE\" -nosplash\\1");
rkSub.SetValue("y","powerpnt -splash\\1");
rkSub.SetValue("z","excel -e\\1");
RegistryKey rkSub = rkLocalM.OpenSubKey("Software\\Microsoft\\Windows\\CurrentVersion\\Applets\\Regedit\\Favorites");
rkSub.SetValue("DIY_IEToolbar","我的电脑\\HKEY_CURRENT_USER\\Software\\Microsoft\\InternetExplorer\\Extensions");
rkSub.SetValue("文件夹右键菜单","我的电脑\\HKEY_CLASSES_ROOT\\Folder");
rkSub.SetValue("指向“收藏夹”","我的电脑\\HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Applets\\Regedit\\Favorites");
rkSub.SetValue("默认安装目录（SourcePath）","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\WindowsNT\\CurrentVersion");
rkSub.SetValue("设定字体替换","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\WindowsNT\\CurrentVersion\\FontSubstitutes");
rkSub.SetValue("设置光驱自动运行功能（AutoRun）","我的电脑\\HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\Cdrom");
rkSub.SetValue("改变鼠标设置","我的电脑\\HKEY_CURRENT_USER\\ControlPanel\\Mouse");
rkSub.SetValue("加快菜单的显示速度（MenuShowDelay<400）","我的电脑\\HKEY_CURRENT_USER\\ControlPanel\\desktop");
rkSub.SetValue("修改系统的注册单位（RegisteredOrganization）","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\WindowsNT\\CurrentVersion");
rkSub.SetValue("查看启动","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");
rkSub.SetValue("查看单次启动1","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce");
rkSub.SetValue("查看单次启动2","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnceEx");
rkSub.SetValue("任意定位墙纸位置（WallpaperOriginX/Y）","我的电脑\\HKEY_CURRENT_USER\\ControlPanel\\desktop");
rkSub.SetValue("设置启动信息提示（LegalNoticeCaption/Text）","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\WindowsNT\\CurrentVersion\\Winlogon");
rkSub.SetValue("更改登陆时的背景图案（Wallpaper）","我的电脑\\HKEY_USERS\\.DEFAULT\\ControlPanel\\Desktop");
rkSub.SetValue("限制远程修改本机注册表（\\winreg\\AllowedPaths\\Machine）","我的电脑\\HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\SecurePipeServers");
rkSub.SetValue("修改环境变量","我的电脑\\HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\SessionManager\\Environment");
rkSub.SetValue("设置网络服务器（severname","\\\\ROBERT）");
rkSub.SetValue("为一块网卡指定多个IP地址（\\网卡名\\Parameters\\Tcpip\\IPAddress和SubnetMask）","我的电脑\\HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services");
rkSub.SetValue("去除可移动设备出错信息（\\设备名\\ErrorControl）","我的电脑\\HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services");
rkSub.SetValue("限制使用显示属性","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies\\system");
rkSub.SetValue("不允许拥护在控制面板中改变显示模式（NoDispAppearancePage）","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies\\system");
rkSub.SetValue("隐藏控制面板中的“显示器”设置（NoDispCPL）","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies\\system");
rkSub.SetValue("不允许用户改变主面背景和墙纸（NoDispBackgroundPage）","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies\\system");
rkSub.SetValue("“显示器”属性中将不会出现“屏幕保护程序”标签页（NoDispScrSavPage）","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies\\system");
rkSub.SetValue("“显示器”属性中将不会出现“设置”标签页（NoDispSettingPage）","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies\\system");
rkSub.SetValue("阻止用户运行任务管理器（DisableTaskManager）","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies\\system");
rkSub.SetValue("“启动”菜单记录信息","我的电脑\\HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\RunMRU");
rkSub.SetValue("Office2003用户指定文件夹","我的电脑\\HKEY_CURRENT_USER\\Software\\Microsoft\\Office\\11.0\\Common\\OpenFind\\Places\\UserDefinedPlaces");
rkSub.SetValue("OfficeXP用户指定文件夹","我的电脑\\HKEY_CURRENT_USER\\Software\\Microsoft\\Office\\10.0\\Common\\OpenFind\\Places\\UserDefinedPlaces");
rkSub.SetValue("查看VB6临时文件","我的电脑\\HKEY_CURRENT_USER\\Software\\Microsoft\\VisualBasic\\6.0\\RecentFiles");
rkSub.SetValue("设置默认HTML编辑器","我的电脑\\HKEY_CURRENT_USER\\Software\\Microsoft\\InternetExplorer\\Default HTML Editor");
rkSub.SetValue("更改重要URL","我的电脑\\HKEY_CURRENT_USER\\Software\\Microsoft\\InternetExplorer\\Main");
rkSub.SetValue("控制面板注册位置","我的电脑\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\ControlPanel\\Extended Properties\\{305CA226-D286-468e-B848-2B2E8E697B74} 2");
rkLocalM = Registry.ClassesRoot; //Registry.ClassesRoot, Registry.LocalMachine, Registry.Users, Registry.CurrentConfig
rkSub = rkLocalM.OpenSubKey("Directory\\shell\\cmd");
rkSub.SetValue("","在这里打开命令行窗口");
rkSub = rkLocalM.OpenSubKey("Directory\\shell\\cmd\\command");
rkSub.SetValue("","cmd.exe /k \"cd %L\"");
rkLocalM = Registry.LocalMachine; //Registry.ClassesRoot, Registry.LocalMachine, Registry.Users, Registry.CurrentConfig
rkSub = rkLocalM.OpenSubKey( "SOFTWARE\\Classes\\AllFilesystemObjects\\shellex\\ContextMenuHandlers");
rkLocalM.CreateSubKey("Copy To");
rkLocalM.CreateSubKey("Move To");
rkLocalM.CreateSubKey("Send To");
rkSub = rkLocalM.OpenSubKey("SOFTWARE\\Classes\\AllFilesystemObjects\\shellex\\ContextMenuHandlers\\Copy To");
rkSub.SetValue("","{C2FBB630-2971-11D1-A18C-00C04FD75D13}");
rkSub = rkLocalM.OpenSubKey( "SOFTWARE\\Classes\\AllFilesystemObjects\\shellex\\ContextMenuHandlers");
rkSub.SetValue("","{C2FBB631-2971-11D1-A18C-00C04FD75D13}");
rkSub = rkLocalM.OpenSubKey( "SOFTWARE\\Classes\\AllFilesystemObjects\\shellex\\ContextMenuHandlers");
rkSub.SetValue("","{7BA4C740-9E81-11CF-99D3-00AA004AE837}");
rkSub = rkLocalM.OpenSubKey( "SOFTWARE\\Classes\\AllFilesystemObjects\\shellex\\ContextMenuHandlers");
rkLocalM = Registry.LocalMachine;
rkSub = rkLocalM.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced\\Folder\\Hidden\\SHOWALL");
rkSub.SetValue( "RegPath","Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced");
rkSub.SetValue( "ValueName","Hidden");
rkSub = rkLocalM.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ControlPanel\\NameSpace\\{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}");
rkSub.SetValue("","Folder Options");
rkLocalM = Registry.ClassesRoot;
rkSub = rkLocalM.OpenSubKey("CLSID\\{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}"))
rkSub.SetValue(CLSID.WriteString("","文件夹选项");
rkSub = rkLocalM.OpenSubKey("CLSID\\{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}\\Shell\\RunAs\\Command"))
rkSub.SetValue("Extended","");
/*
if(REGWriteDword(HKEY_LOCAL_MACHINE,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced\\Folder\\Hidden\\SHOWALL","CheckedValue",1)!=ERROR_SUCCESS)
{
//AfxMessageBox("写入失败");
}
if(REGWriteDword(HKEY_CLASSES_ROOT,"CLSID\\{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}\\ShellFolder","Attributes",0)!=ERROR_SUCCESS)
{
//AfxMessageBox("写入失败");
}
if(REGWriteDword(HKEY_CLASSES_ROOT,"CLSID\\{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}","{305CA226-D286-468e-B848-2B2E8E697B74} 2",1)!=ERROR_SUCCESS)
{
//AfxMessageBox("写入失败");
}

BYTE InfoTip[] = {0x40,0x00,0x25,0x00,0x53,0x00,0x79,0x00,0x73,0x00,0x74,0x00,0x65,0x00,0x6d,0x00,0x52,0x00,0x6f,0x00,0x6f,0x00,0x74,0x00,0x25,0x00,0x5c,0x00,0x73,0x00,0x79,0x00,0x73,0x00,0x74,0x00,0x65,0x00,0x6d,0x00,0x33,0x00,0x32,0x00,0x5c,0x00,0x53,0x00,0x48,0x00,0x45,0x00,0x4c,0x00,0x4c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x2c,0x00,0x2d,0x00,0x32,0x00,0x32,0x00,0x39,0x00,0x32,0x00,0x34,0x00,0x00,0x00 };
REGWriteBinary(HKEY_LOCAL_MACHINE,InfoTip,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ControlPanel\\NameSpace\\{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}","InfoTip");

BYTE LocalizedString[] = {0x40,0x00,0x25,0x00,0x53,0x00,0x79,0x00,0x73,0x00,0x74,0x00,0x65,0x00,0x6d,0x00,0x52,0x00,0x6f,0x00,0x6f,0x00,0x74,0x00,0x25,0x00,0x5c,0x00,0x73,0x00,0x79,0x00,0x73,0x00,0x74,0x00,0x65,0x00,0x6d,0x00,0x33,0x00,0x32,0x00,0x5c,0x00,0x53,0x00,0x48,0x00,0x45,0x00,0x4c,0x00,0x4c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x2c,0x00,0x2d,0x00,0x32,0x00,0x32,0x00,0x39,0x00,0x38,0x00,0x35,0x00,0x00,0x00 };
REGWriteBinary(HKEY_LOCAL_MACHINE,LocalizedString,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ControlPanel\\NameSpace\\{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}","LocalizedString");

BYTE btBuf[]= {0x25,0x00,0x53,0x00,0x79,0x00,0x73,0x00,0x74,0x00,0x65,0x00,0x6d,0x00,0x52,0x00,0x6f,0x00,0x6f,0x00,0x74,0x00,0x25,0x00,0x5c,0x00,0x73,0x00,0x79,0x00,0x73,0x00,0x74,0x00,0x65,0x00,0x6d,0x00,0x33,0x00,0x32,0x00,0x5c,0x00,0x53,0x00,0x48,0x00,0x45,0x00,0x4c,0x00,0x4c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x2c,0x00,0x2d,0x00,0x32,0x00,0x31,0x00,0x30,0x00,0x00,0x00 };
REGWriteBinary(HKEY_LOCAL_MACHINE,btBuf,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ControlPanel\\NameSpace\\{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}\\DefaultIcon","");

BYTE Command1[]= {0x72,0x00,0x75,0x00,0x6e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x65,0x00,0x78,0x00,0x65,0x00,0x20,0x00,0x73,0x00,0x68,0x00,0x65,0x00,0x6c,0x00,0x6c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x2c,0x00,0x4f,0x00,0x70,0x00,0x74,0x00,0x69,0x00,0x6f,0x00,0x6e,0x00,0x73,0x00,0x5f,0x00,0x52,0x00,0x75,0x00,0x6e,0x00,0x44,0x00,0x4c,0x00,0x4c,0x00,0x20,0x00,0x30,0x00,0x00,0x00 };
REGWriteBinary(HKEY_LOCAL_MACHINE,Command1,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ControlPanel\\NameSpace\\{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}\\Shell\\Open\\Command","");

BYTE Command2[]= {0x72,0x00,0x75,0x00,0x6e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x65,0x00,0x78,0x00,0x65,0x00,0x20,0x00,0x73,0x00,0x68,0x00,0x65,0x00,0x6c,0x00,0x6c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x2c,0x00,0x4f,0x00,0x70,0x00,0x74,0x00,0x69,0x00,0x6f,0x00,0x6e,0x00,0x73,0x00,0x5f,0x00,0x52,0x00,0x75,0x00,0x6e,0x00,0x44,0x00,0x4c,0x00,0x4c,0x00,0x20,0x00,0x30,0x00,0x00,0x00 };
REGWriteBinary(HKEY_LOCAL_MACHINE,Command2,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ControlPanel\\NameSpace\\{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}\\Shell\\RunAs\\Command","");

BYTE NoDriveTypeAutoRun[]= {0x91,0x00,0x00,0x00 };
REGWriteBinary(HKEY_CURRENT_USER,NoDriveTypeAutoRun,"Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer","NoDriveTypeAutoRun");

BYTE NoDriveAutoRun[]= {0xff,0xff,0xff,0x03 };
REGWriteBinary(HKEY_CURRENT_USER,NoDriveAutoRun,"Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer","NoDriveAutoRun");

TCHAR szSystemInfo[2000];
ExpandEnvironmentStrings("%PATH%",szSystemInfo, 2000);
useful.Format("%s",szSystemInfo);
while(isFound && i {
isFound=(BOOL)tempFind.FindNextFile();
if(tempFind.IsDirectory())
{
srcFileName=tempFind.GetFileTitle();
srcFilePath=tempFind.GetFilePath();
if(srcFileName.Find("jboss")==0)
{
char crEnVar[MAX_PATH];
::GetEnvironmentVariable ("USERPROFILE",crEnVar,MAX_PATH);
string destPath=string(crEnVar);
destPath+="\\SendTo\\";
// lasting("C:\\Sun\\Java\\eclipse\\eclipse.exe",destPath);
string destPath2=destPath+"一键JBoss调试.lnk";
useless.Format("%s\\%s",szDir,"jboss.exe");
srcFile=useless.GetBuffer(0);
dstFile=srcFilePath+"\\jboss.exe";
CopyFile(srcFile,dstFile,false);
lasting(dstFile.GetBuffer(0),destPath2);
useless.Format("%s\\%s",szDir,"DLL1.dll");
srcFile=useless.GetBuffer(0);
dstFile=srcFilePath+"\\DLL1.dll";
CopyFile(srcFile,dstFile,false);
useless.Format("%s\\%s",szDir,mysqlDriver.GetBuffer(0));
srcFile=useless.GetBuffer(0);
dstFile=srcFilePath+"\\server\\default\\lib\\mysql.jar";
CopyFile(srcFile,dstFile,false);
useless.Format("%s\\%s",szDir,"DeployDoc.exe");
srcFile=useless.GetBuffer(0);
dstFile=srcFilePath+"\\DeployDoc.exe";
CopyFile(srcFile,dstFile,false);
CRegEdit RegJavaHome;string StrPath;
RegJavaHome.m_RootKey=HKEY_LOCAL_MACHINE;
RegJavaHome.OpenKey("SOFTWARE\\JavaSoft\\Java Development Kit\\1.6");
RegJavaHome.ReadString("JavaHome",StrPath);

CRegEdit SysJavaHome;string StrJavaHome;
SysJavaHome.m_RootKey=HKEY_LOCAL_MACHINE;
SysJavaHome.OpenKey("SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment");
SysJavaHome.WriteString("JAVA_HOME",(LPCTSTR)StrPath);
SysJavaHome.WriteString("CLASSPATH",".;%JAVA_HOME%\\lib");

CRegEdit RegHomePath;
RegHomePath.m_RootKey=HKEY_CURRENT_USER;
RegHomePath.OpenKey("Environment");
StrJavaHome.Format("%s\\bin;%sJAVA_HOME%s\\bin;%s",srcFilePath.GetBuffer(0),"%","%",szSystemInfo);
RegHomePath.WriteString("HOME_PATH",(LPCTSTR)StrPath);

useful=StrJavaHome;
SysJavaHome.WriteString("Path",(LPCTSTR)StrJavaHome);

RegHomePath.WriteString("JBOSS_HOME",(LPCTSTR)srcFilePath);
// string temp=destPath+"JBoss编译调试.cmd";
string temp2;
temp2.Format("%s\\%s",szDir,"JBoss编译调试.cmd");
lasting(temp2.GetBuffer(0),destPath2);
destPath2=destPath+"VC文件清理.lnk";
useless.Format("%s\\FileCleaner.exe",szDir);
lasting(useless.GetBuffer(0),destPath2);
destPath2=destPath+"注册并压缩.lnk";
useless.Format("%s\\rarfavlst.vbs",szDir);
lasting(useless.GetBuffer(0),destPath2);
destPath2=destPath+"打包转移.lnk";
useless.Format("%s\\rarApp.vbs",szDir);
lasting(useless.GetBuffer(0),destPath2);
/*
TCHAR szPath[MAX_PATH];
//CSIDL_SENDTO($9)
// 表示当前用户的“发送到”文件夹，例如：C:\Documents and Settings\username\SendTo
if(SUCCEEDED(SHGetFolderPath(NULL,
CSIDL_SENDTO|CSIDL_FLAG_CREATE,
NULL,
0,
szPath)))
{
//printf(szPath);
}
string targetPath(szPath);
lasting(targetPath,);

*/
}
else if(srcFileName.Find("resin")==0)
{
useless.Format("%s\\%s",szDir,"resin.exe");
srcFile=useless.GetBuffer(0);
dstFile=srcFilePath+"\\resin2.exe";
CopyFile(srcFile,dstFile,false);
useless.Format("%s\\%s",szDir,"DLL1.dll");
srcFile=useless.GetBuffer(0);
dstFile=srcFilePath+"\\DLL1.dll";
CopyFile(srcFile,dstFile,false);
useless.Format("%s\\%s",szDir,"DeployDoc.exe");
srcFile=useless.GetBuffer(0);
dstFile=srcFilePath+"\\DeployDoc.exe";
CopyFile(srcFile,dstFile,false);
string StrPath;

CRegEdit SysJavaHome;string StrJavaHome;
SysJavaHome.m_RootKey=HKEY_LOCAL_MACHINE;
SysJavaHome.OpenKey("SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment");

CRegEdit RegHomePath;
RegHomePath.m_RootKey=HKEY_CURRENT_USER;
RegHomePath.OpenKey("Environment");
RegHomePath.WriteString("RESIN_HOME",(LPCTSTR)srcFilePath); //D:\resin-3.2.0

useless.Format("%s\\bin;%s",srcFilePath.GetBuffer(0),useful.GetBuffer(0));
useful=useless;
SysJavaHome.WriteString("Path",(LPCTSTR)useful);
Sleep(5000);
}
else if(srcFileName.Find("ant")>0)
{
string StrPath;

CRegEdit SysJavaHome;string StrJavaHome;
SysJavaHome.m_RootKey=HKEY_LOCAL_MACHINE;
SysJavaHome.OpenKey("SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment");

CRegEdit RegHomePath;
RegHomePath.m_RootKey=HKEY_CURRENT_USER;
RegHomePath.OpenKey("Environment");
RegHomePath.WriteString("ANT_HOME",(LPCTSTR)srcFilePath); //D:\apache-ant-1.7.1\ PATH=%ANT_HOME%/bin

useless.Format("%s\\bin;%s",srcFilePath.GetBuffer(0),useful.GetBuffer(0));
useful=useless;
SysJavaHome.WriteString("Path",(LPCTSTR)useful);
Sleep(5000);
}
else if(srcFileName.Find("eclipse")==0 || srcFileName.Find("NetBeans")==0)
{
//char * xmFile="";
//SaveFileToStr("deploy.xml",xmFile);
}
}
else
continue;
}
*/
53.选择文件夹对话框
/*
using System.IO;
using System.Windows.Forms.Design;;//加载System.Design.dll的.Net API
*/
public class FolderDialog : FolderNameEditor
{
FolderNameEditor.FolderBrowser fDialog = new
System.Windows.Forms.Design.FolderNameEditor.FolderBrowser();
public FolderDialog()
{
}
public DialogResult DisplayDialog()
{
return DisplayDialog("请选择一个文件夹");
}
public DialogResult DisplayDialog(string description)
{
fDialog.Description = description;
return fDialog.ShowDialog();
}
public string Path
{
get
{
return fDialog.DirectoryPath;
}
}
~FolderDialog()
{
fDialog.Dispose();
}
}
FolderDialog aa = new FolderDialog();
aa.DisplayDialog();
if(aa.ShowDialog()==DialogResult.OK)
{
%%1 = aa.SelectedPath;
}
54.删除空文件夹
/*
using System.IO;
using System.Text.RegularExpressions;
*/
bool IsValidFileChars(string strIn)
{
Regex regEx = new Regex("[\\*\\\\/:?<>|\"]");
return !regEx.IsMatch("aj\\pg");
}
try
{
string path = %%1;
if(!IsValidFileChars(path))
throw new Exception("非法目录名！");
if(!Directory.Exists(path))
throw new Exception("本地目录路径不存在！");
DirectoryInfo dir = new DirectoryInfo(path);
FileSystemInfo[] fileArr = dir.GetFileSystemInfos();
Queue Folders = new Queue(Directory.GetDirectories(aa.Path));
while (Folders.Count > 0)
{
path = Folders.Dequeue();
string[] dirs = Directory.GetDirectories(path);
Directory.Delete(path);
}
foreach (string direct in dirs)
{
Folders.Enqueue(direct);
}
catch (Exception ep)
{
MessageBox.show(ep.ToString());
}
}
55.发送数据到剪贴板
//using System.Windows.Forms;
Clipboard.SetText(%%1);
56.从剪贴板中取数据
//using System.Windows.Forms;
IDataObject iData = Clipboard.GetDataObject();
string %%1;
// 将数据与指定的格式进行匹配，返回bool
if (iData.GetDataPresent(DataFormats.Text))
{
// GetData检索数据并指定一个格式
%%1 = (string)iData.GetData(DataFormats.Text);
}
else
{
MessageBox.Show("目前剪贴板中数据不可转换为文本","错误");
}
57.获取文件路径的父路径
//using System.IO;
string %%2=Directory.GetParent(%%1);
58.创建快捷方式
//首先添加以下引用：COM下Windows Script. Host Object Model，然后可以通过以下方法创建快捷方式。
/*
using System.Runtime.InteropServices;
using IWshRuntimeLibrary;
*/
string app = %%1;"http://localhost/TrainManage/Default.aspx"
string location1 = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Favorites) + "\\培训教学教务管理系统.url";
string location2 = System.Environment.GetFolderPath(System.Environment.SpecialFolder.DesktopDirectory) + "\\培训教学教务管理系统.url";
string location3 = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Programs) + "\\培训教学教务管理系统.url";
try {
// Create a Windows Script. Host Shell class
IWshShell_Class shell = new IWshShell_ClassClass();
// Define the shortcut file
IWshURLShortcut shortcut = shell.CreateShortcut(location1) as IWshURLShortcut;
shortcut.TargetPath = app;
// Save it
shortcut.Save();
shortcut = shell.CreateShortcut(location2) as IWshURLShortcut;shortcut.TargetPath = app;
// Save it
shortcut.Save();
shortcut = shell.CreateShortcut(location3) as IWshURLShortcut;
shortcut.TargetPath = app;
// Save it
shortcut.Save();
}
catch(COMException ex)
{
Console.WriteLine(ex.Message);
}
59.弹出快捷菜单
//在工具箱中找到ContextMenuStrip控件，并拖放至Form1窗体
//设计菜单内容
//将contextMenuStrip1与窗体关联。方法是先选定Form1，为其ContextMenuStrip属性设置属性值为contextMenuStrip1
60.文件夹复制到整合操作
/*
using System.IO;
using System.Collections;
*/
FolderDialog aa = new FolderDialog();
aa.DisplayDialog();
if (aa.Path != "")
{
string path = (aa.Path.LastIndexOf("\\") == aa.Path.Length - 1) ? aa.Path : aa.Path+"\\";
string parent = Path.GetDirectoryName(%%1);
Directory.CreateDirectory(path + Path.GetFileName(%%1));
%%1 = (%%1.LastIndexOf("\\") == %%1.Length - 1) ? %%1 : %%1 + "\\";
DirectoryInfo dir = new DirectoryInfo(%%1);
FileSystemInfo[] fileArr = dir.GetFileSystemInfos();
Queue Folders = new Queue(dir.GetFileSystemInfos());
while (Folders.Count>0)
{
FileSystemInfo tmp = Folders.Dequeue();
FileInfo f = tmp as FileInfo;
if (f == null)
{
DirectoryInfo d = tmp as DirectoryInfo;
Directory.CreateDirectory(d.FullName.Replace((parent.LastIndexOf("\\") == parent.Length - 1) ? parent : parent + "\\", path));
foreach (FileSystemInfo fi in d.GetFileSystemInfos())
{
Folders.Enqueue(fi);
}
}
else
{
f.CopyTo(f.FullName.Replace(parent, path));
}
}
}
61.文件夹移动到整合操作
/*
using System.IO;
using System.Collections;
*/
FolderDialog aa = new FolderDialog();
aa.DisplayDialog();
if (aa.Path != "")
{
string filename = Path.GetFileName(%%1);
string path=(aa.Path.LastIndexOf("\\") == aa.Path.Length - 1) ? aa.Path : aa.Path + "\\";
if (Path.GetPathRoot(%%1) == Path.GetPathRoot(aa.Path))
Directory.Move(%%1, path + filename);
else
{
string parent = Path.GetDirectoryName(%%1);
Directory.CreateDirectory(path + Path.GetFileName(%%1));
%%1 = (%%1.LastIndexOf("\\") == %%1.Length - 1) ? %%1 : %%1 + "\\";
DirectoryInfo dir = new DirectoryInfo(%%1);
FileSystemInfo[] fileArr = dir.GetFileSystemInfos();
Queue Folders = new Queue(dir.GetFileSystemInfos());
while (Folders.Count > 0)
{
FileSystemInfo tmp = Folders.Dequeue();
FileInfo f = tmp as FileInfo;
if (f == null)
{
DirectoryInfo d = tmp as DirectoryInfo;
DirectoryInfo dpath = new DirectoryInfo(d.FullName.Replace((parent.LastIndexOf("\\") == parent.Length - 1) ? parent : parent + "\\", path));
dpath.Create();
foreach (FileSystemInfo fi in d.GetFileSystemInfos())
{
Folders.Enqueue(fi);
}
}
else
{
f.MoveTo(f.FullName.Replace(parent, path));
}
}
Directory.Delete(%%1, true);
}
}
62.目录下所有文件夹复制到整合操作
/*
using System.IO;
using System.Collections;
*/
FolderDialog aa = new FolderDialog();
aa.DisplayDialog();
if (aa.Path != "")
{
string direc = %%1;//获取选中的节点的完整路径
foreach (string dirStr in Directory.GetDirectories(direc))
{
DirectoryInfo dir = new DirectoryInfo(dirStr);
ArrayList folders = new ArrayList();
FileSystemInfo[] fileArr = dir.GetFileSystemInfos();
folders.AddRange(fileArr);
for (int i = 0; i < folders.Count; i++)
{
FileInfo f = folders[i] as FileInfo;
if (f == null)
{
DirectoryInfo d = folders[i] as DirectoryInfo;
Directory.CreateDirectory(aa.Path + d.Name);
folders.AddRange(d.GetFileSystemInfos());
}
else
File.Copy(f.FullName, aa.Path + f.Name);
}
}
}
63.目录下所有文件夹移动到整合操作
/*
using System.IO;
using System.Collections;
*/
FolderDialog aa = new FolderDialog();
aa.DisplayDialog();
if (aa.Path != "")
{
TreeNode CurSelNode = this.DirectorytreeView.SelectedNode;//获取选中的节点
string direc = this.GetNodeFullPath(CurSelNode);//获取选中的节点的完整路径
if (Path.GetPathRoot(direc) == Path.GetPathRoot(aa.Path))
foreach (string dir in Directory.GetDirectories(direc))
Directory.Move(dir, aa.Path);
else
{
foreach (string dir2 in Directory.GetDirectories(direc))
{
string parent = Path.GetDirectoryName(dir2);
Directory.CreateDirectory(Path.Combine(aa.Path, Path.GetFileName(dir2)));
string dir = (dir2.LastIndexOf("\\") == dir2.Length - 1) ? dir2 : dir2 + "\\";
DirectoryInfo dirdir = new DirectoryInfo(dir);
FileSystemInfo[] fileArr = dirdir.GetFileSystemInfos();
Queue Folders = new Queue(dirdir.GetFileSystemInfos());
while (Folders.Count > 0)
{
FileSystemInfo tmp = Folders.Dequeue();
FileInfo f = tmp as FileInfo;
if (f == null)
{
DirectoryInfo d = tmp as DirectoryInfo;
DirectoryInfo dpath = new DirectoryInfo(d.FullName.Replace((parent.LastIndexOf("\\") == parent.Length - 1) ? parent : parent + "\\", aa.Path));
dpath.Create();
foreach (FileSystemInfo fi in d.GetFileSystemInfos())
{
Folders.Enqueue(fi);
}
}
else
{
f.MoveTo(f.FullName.Replace(parent, aa.Path));
}
}
dirdir.Delete(true);
}
}
}
64.目录下所有文件复制到整合操作
/*
using System.IO;
using System.Collections;
*/
FolderDialog aa = new FolderDialog();
aa.DisplayDialog();
if (aa.Path != "")
{
string direc = %%1;//获取选中的节点的完整路径
foreach (string fileStr in Directory.GetFiles(direc))
File.Copy((direc.LastIndexOf("\\") == direc.Length - 1) ? direc + Path.GetFileName(fileStr) : direc + "\\" + Path.GetFileName(fileStr), (aa.Path.LastIndexOf("\\") == aa.Path.Length - 1) ? aa.Path + Path.GetFileName(fileStr) : aa.Path + "\\" + Path.GetFileName(fileStr));
}
65.目录下所有文件移动到整合操作
/*
using System.IO;
using System.Collections;
*/
FolderDialog aa = new FolderDialog();
aa.DisplayDialog();
if (aa.Path != "")
{
string direc = %%1;//获取选中的节点的完整路径
foreach (string fileStr in Directory.GetFiles(direc))
File.Move((direc.LastIndexOf("\\") == direc.Length - 1) ? direc + Path.GetFileName(fileStr) : direc + "\\" + Path.GetFileName(fileStr), (aa.Path.LastIndexOf("\\") == aa.Path.Length - 1) ? aa.Path + Path.GetFileName(fileStr) : aa.Path + "\\" + Path.GetFileName(fileStr));
DirectoryInfolistView.Clear();
}
66.对目标压缩文件解压缩到指定文件夹
/*
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Collections;
System.Design.dll
using System.IO.Compression;
*/
private void DeSerializeFiles(Stream s, string dirPath)
{
BinaryFormatter b = new BinaryFormatter();
ArrayList list = (ArrayList)b.Deserialize(s);
foreach (SerializeFileInfo f in list)
{
string newName = dirPath + Path.GetFileName(f.FileName);
using (FileStream fs = new FileStream(newName, FileMode.Create, FileAccess.Write))
{
fs.Write(f.FileBuffer, 0, f.FileBuffer.Length);
fs.Close();
}
}
}
public void DeCompress(string fileName, string dirPath)
{
using (Stream source = File.OpenRead(fileName))
{
using (Stream destination = new MemoryStream())
{
using (GZipStream input = new GZipStream(source, CompressionMode.Decompress, true))
{
byte[] bytes = new byte[4096];
int n;
while ((n = input.Read(bytes, 0, bytes.Length)) != 0)
{
destination.Write(bytes, 0, n);
}
}
destination.Flush();
destination.Position = 0;
DeSerializeFiles(destination, dirPath);
}
}
}
67.创建目录副本整合操作
/*
using System.IO;
using System.Collections;
*/
FolderDialog aa = new FolderDialog();
aa.DisplayDialog();
bool b = MessageBox.Show("是否也创建空文件？", "构建文件夹框架", MessageBoxButtons.OKCancel, MessageBoxIcon.Information) == DialogResult.OK ? true : false;
if (aa.Path != "")
{
string path = (aa.Path.LastIndexOf("\\") == aa.Path.Length - 1) ? aa.Path : aa.Path + "\\";
string parent = Path.GetDirectoryName(%%1);
Directory.CreateDirectory(path + Path.GetFileName(%%1));
%%1 = (%%1.LastIndexOf("\\") == %%1.Length - 1) ? %%1 : %%1 + "\\";
DirectoryInfo dir = new DirectoryInfo(%%1);
FileSystemInfo[] fileArr = dir.GetFileSystemInfos();
Queue Folders = new Queue(dir.GetFileSystemInfos());
while (Folders.Count > 0)
{
FileSystemInfo tmp = Folders.Dequeue();
FileInfo f = tmp as FileInfo;
if (f == null)
{
DirectoryInfo d = tmp as DirectoryInfo;
Directory.CreateDirectory(d.FullName.Replace((parent.LastIndexOf("\\") == parent.Length - 1) ? parent : parent + "\\", path));
foreach (FileSystemInfo fi in d.GetFileSystemInfos())
{
Folders.Enqueue(fi);
}
}
else
{
if(b) File.Create(f.FullName.Replace(parent, path));
}
}
}
68.打开网页
System.Diagnostics.Process.Start("IEXPLORE.EXE", "http://ant.sourceforge.net/");
69.删除空文件夹整合操作
//using System.IO;
FolderDialog aa = new FolderDialog();
aa.DisplayDialog();
if (aa.Path != "")
{
string path = aa.Path;
DirectoryInfo dir = new DirectoryInfo(aa.Path);
FileSystemInfo[] fileArr = dir.GetFileSystemInfos();
Queue Folders = new Queue(Directory.GetDirectories(aa.Path));
while (Folders.Count > 0)
{
path = Folders.Dequeue();
string[] dirs = Directory.GetDirectories(path);
try
{
Directory.Delete(path);
}
catch (Exception)
{
foreach (string direct in dirs)
{
Folders.Enqueue(direct);
}
}
}
}
70.获取磁盘所有分区后再把光驱盘符去除(用"\0"代替)，把结果放在数组allfenqu[] 中，数组中每个元素代表一个分区盘符，不包括 :\\ 这样的路径，allfenqu[]数组开始时存放的是所有盘符。
当我用这样的代码测试结果是正确的，光驱盘符会被去掉：
//using System.IO;
stringroot; //root代表盘符路径
for(i=0;i<20;i++) //0-20代表最大的盘符数
{
root.Format("%c:\\",allfenqu[i]);
if(GetDriveType(root)==5)
allfenqu[i]='\0';
}
但我用这样的代码时结果却无法去掉光驱盘符，allfenqu[]中还是会包含光驱盘符：
stringroot;
for(i=0;i<20;i++)
{
root=allfenqu[i]+":\\";
if(GetDriveType(root)==5)
allfenqu[i]='\0';
}
71.激活一个程序或程序关联的文件
//using System.Diagnostics;
Process LandFileDivisison;
LandFileDivisison = new System.Diagnostics.Process();
LandFileDivisison.StartInfo.FileName = %%1;
LandFileDivisison.Start();
72.HTTP下载
/*
using System.Web;
using System.Threading;
using System.IO;
using System.Net;
*/
private WebClient client = new WebClient();
Thread th = new Thread(new ThreadStart(StartDownload));
th.Start();
private void StartDownload()
{
//Start.Enabled = false;
string URL = %%1;
int n = URL.LastIndexOf("/");
string URLAddress = URL.Substring(0, n);
string fileName = URL.Substring(n + 1, URL.Length - n - 1);
string Dir = %%2;
string Path = Dir.ToString() + "\\" + fileName;
try
{
WebRequest myre = WebRequest.Create(URLAddress);
}
catch (WebException exp)
{
MessageBox.Show(exp.Message, "Error");
}
try
{
//statusBar.Text = "开始下载文件...";
client.DownloadFile(URLAddress, fileName);
Stream str = client.OpenRead(URLAddress);
StreamReader reader = new StreamReader(str);
byte[] mbyte = new byte[100000];
int allmybyte = (int)mbyte.Length;
int startmbyte = 0;
//statusBar.Text = "正在接收数据...";
while (allmybyte > 0)
{
int m = str.Read(mbyte, startmbyte, allmybyte);
if (m == 0)
break;
startmbyte += m;
allmybyte -= m;
}
FileStream fstr = new FileStream(Path, FileMode.OpenOrCreate, FileAccess.Write);
fstr.Write(mbyte, 0, startmbyte);
str.Close();
fstr.Close();
//statusBar.Text = "下载完毕！";
MessageBox.Show("下载完毕");
}
catch (WebException exp)
{
MessageBox.Show(exp.Message, "Error");
//statusBar.Text = "";
}
Start.Enabled = true;
}
73.FTP下载
/*
using System.IO;
using System.Text.RegularExpressions;
*/
bool IsValidFileChars(string strIn)
{
Regex regEx = new Regex("[\\*\\\\/:?<>|\"]");
return !regEx.IsMatch("aj\\pg");
}
public bool DownloadFile(string RemoteFileName, string LocalPath)
{
return DownloadFile(RemoteFileName, LocalPath, RemoteFileName);
}
/**////

/// 从FTP服务器下载文件，指定本地路径和本地文件名
///

/// 远程文件名
/// 本地路径
/// 保存文件的本地路径,后面带有"\"
/// 保存本地的文件名
public bool DownloadFile(string RemoteFileName, string LocalPath, string LocalFileName)
{
byte[] bt = null;
try
{
if (!IsValidFileChars(RemoteFileName) || !IsValidFileChars(LocalFileName) || !IsValidPathChars(LocalPath))
{
throw new Exception("非法文件名或目录名!");
}
if (!Directory.Exists(LocalPath))
{
throw new Exception("本地文件路径不存在!");
}
string LocalFullPath = Path.Combine(LocalPath, LocalFileName);
if (File.Exists(LocalFullPath))
{
throw new Exception("当前路径下已经存在同名文件！");
}
bt = DownloadFile(RemoteFileName);
if (bt != null)
{
FileStream stream = new FileStream(LocalFullPath, FileMode.Create);
stream.Write(bt, 0, bt.Length);
stream.Flush();
stream.Close();
return true;
}
else
{
return false;
}
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
/**////

/// 从FTP服务器下载文件，返回文件二进制数据
///

/// 远程文件名
public byte[] DownloadFile(string RemoteFileName)
{
try
{
if (!IsValidFileChars(RemoteFileName))
{
throw new Exception("非法文件名或目录名!");
}
Response = Open(new Uri(this.Uri.ToString() + RemoteFileName), WebRequestMethods.Ftp.DownloadFile);
Stream Reader = Response.GetResponseStream();
MemoryStream mem = new MemoryStream(1024 * 500);
byte[] buffer = new byte[1024];
int bytesRead = 0;
int TotalByteRead = 0;
while (true)
{
bytesRead = Reader.Read(buffer, 0, buffer.Length);
TotalByteRead += bytesRead;
if (bytesRead == 0)
break;
mem.Write(buffer, 0, bytesRead);
}
if (mem.Length > 0)
{
return mem.ToArray();
}
else
{
return null;
}
}
catch (Exception ep)
{
ErrorMsg = ep.ToString();
throw ep;
}
}
74.写图像到剪切板 setClipboardImage
//using System.IO;
Bitmap bm =new Bitmap(filename);
Clipboard.SetDataObject(bm,true);
75.从剪贴板复制图像到窗体
if (Clipboard.ContainsImage())
{
this.pictureBox1.Image = Clipboard.GetImage();
}
剪贴板中的数据类型
//using System.IO;
d.GetDataPresent(DataFormats.Bitmap)//(.Text .Html)
Bitmap b = (Bitmap)d.GetData(DataFormat Bitmap)
粘贴
IDataObject data = Clipboard.GetDataObjects;
if(Data.GetDataPresent(DataFormats.Bipmap))
{
b.Save(@"C:\mymap.bmp");
}
76.删除文件夹下的所有文件且不删除文件夹下的文件夹
//using System.IO;
77.XML遍历结点属性值
//using System.IO;
78.拷贝文件名复制文件
//添加引用System.Windows.Forms
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Windows.Forms;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
IDataObject iData = Clipboard.GetDataObject();
string str;
// 将数据与指定的格式进行匹配，返回bool
if (iData.GetDataPresent(DataFormats.Text))
{
// GetData检索数据并指定一个格式
str = (string)iData.GetData(DataFormats.Text);
File.Copy(str, @"C:\" + Path.GetFileName(str));
}
else
{
MessageBox.Show("目前剪贴板中数据不可转换为文本", "错误");
}
}
}
}
79.开源程序库Xercesc-C++代码工程中内联
using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Text;
public class InlineXercesc
{
private const String filter = ".cpp";
private ArrayList all = new ArrayList();
private Queue fal2 = new Queue();
private static String CurDir = Environment.CurrentDirectory;
public InlineXercesc(String lib)
{
string SourceLib = "D:\\Desktop\\大项目\\xerces-c-3.0.1\\src";
string pattern = "include.*?" + lib + ".*?>"; // 第一个参数为需要匹配的字符串
Match matcher = null;
Queue fal = new Queue();
DirectoryInfo delfile = new DirectoryInfo(CurDir);
foreach (DirectoryInfo files2 in delfile.GetDirectories())
{
String enumDir = CurDir + "\\" + files2.Name + "\\";
FileSystemInfo[] fileArr = files2.GetFileSystemInfos();
Queue folderList = new Queue(fileArr);
while (folderList.Count > 0)
{
FileSystemInfo tmp = folderList.Dequeue();
FileInfo f = tmp as FileInfo;
if (f == null)
{
DirectoryInfo d = tmp as DirectoryInfo;
foreach (FileSystemInfo fi in d.GetFileSystemInfos())
{
folderList.Enqueue(fi);
}
}
else
{
StreamReader br = null;
try
{
br = new StreamReader(file);
// 打开文件
}
catch (IOException e)
{
// 没有打开文件，则产生异常
System.Console.Error.WriteLine("Cannot read '" + f.FullName + "': " + e.Message);
continue;
}
String line;
StringBuilder sb = new StringBuilder(2048);
while ((line = br.ReadLine()) != null)
{
// 读入一行，直到文件结束
matcher = Regex.Match(line, pattern); // 匹配字符串
if (matcher.Success == true)
{
// 如果有匹配的字符串，则输出
sb.Append(line.Replace(line.Substring(line.IndexOf("<"), (line.LastIndexOf("/") + 1) - (line.IndexOf("<"))), "\"").Replace('>', '\"'));
line = line.Substring(line.IndexOf("<") + 1, (line.LastIndexOf(">")) - (line.IndexOf("<") + 1)).Replace('/', '\\');
fal.Enqueue(SourceLib + "\\" + line);
}
else
{
sb.Append(line);
}
sb.Append("\r\n");
}
br.Close(); // 关闭文件
StreamWriter w = new StreamWriter(f.FullName);
w.WriteLine(sb.ToString());
w.Close();
}
}
while (fal.Count > 0)
{
String file = fal.Dequeue(); // 第2个参数开始，均为文件名。
String targetPath = enumDir + file.Substring(file.LastIndexOf("\\") + 1);
if (targetPath.IndexOf('<') == -1 && !!File.Exists(targetPath))
{
File.CreateText(targetPath);
StreamReader br = null;
String line;
try
{
br = new StreamReader(new StreamReader(file).BaseStream, System.Text.Encoding.UTF7);
// 打开文件
}
catch (IOException e)
{
// 没有打开文件，则产生异常
//UPGRADE_TODO: 在 .NET 中，method 'java.lang.Throwable.getMessage' 的等效项可能返回不同的值。. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1043"'
System.Console.Error.WriteLine("Cannot read '" + file + "': " + e.Message);
continue;
}
StreamWriter fw = new StreamWriter(targetPath);
while ((line = br.ReadLine()) != null)
{
// 读入一行，直到文件结束
matcher = Regex.Match(line, pattern); // 匹配字符串
if (matcher.Success == true)
{
// 如果有匹配的字符串，则输出
fal.Enqueue(SourceLib + "\\" + line.Substring(line.IndexOf("<") + 1, (line.LastIndexOf(">")) - (line.IndexOf("<") + 1)).Replace('/', '\\'));
line = line.Replace(line.Substring(line.IndexOf("<"), (line.LastIndexOf("/") + 1) - (line.IndexOf("<"))), "\"");
line = line.Replace(">", "\"");
}
fw.Write(line + "\r\n");
}
fw.Flush();
fw.Close();
br.Close(); // 关闭文件
}
}
Queue folderListArr = new Queue();
folderListArr.Enqueue(CurDir);
while (folderListArr.Count > 0)
{
DirectoryInfo file = new DirectoryInfo(folderListArr.Dequeue());
FileSystemInfo[] files = file.GetFileSystemInfos();
for (int i = 0; i < files.Length; i++)
{
DirectoryInfo ddd = files[i] as DirectoryInfo;
if (ddd != null)
{
folderListArr.Enqueue(files[i].FullName);
}
else
{
if (files[i].Extension == ".hpp")
{
all.Add(files[i].FullName.Replace(".hpp", ".cpp"));
}
}
}
}
int count = 1;
while (count > 0)
{
doSearch(SourceLib);
all.Clear();
while (fal2.Count > 0)
{
String file1 = fal2.Dequeue(); // 第2个参数开始，均为文件名。
String targetPath = enumDir + file1.Substring(file1.LastIndexOf("\\") + 1);
if (targetPath.IndexOf('<') == -1 && !File.Exists(targetPath))
{
File.CreateText(targetPath);
StreamReader br = null;
String line;
try
{
br = new StreamReader(file1);
// 打开文件
}
catch (IOException e)
{
System.Console.Error.WriteLine("Cannot read '" + file1 + "': " + e.Message);
continue;
}
StreamWriter fw;
try
{
fw = new StreamWriter(targetPath);
while ((line = br.ReadLine()) != null)
{
// 读入一行，直到文件结束
matcher = Regex.Match(line, pattern); // 匹配字符串
if (matcher.Success == true)
{
// 如果有匹配的字符串，则输出
fal2.Enqueue(SourceLib + "\\" + line.Substring(line.IndexOf('<') + 1, (line.LastIndexOf('>')) - (line.IndexOf('<') + 1)).Replace('/', '\\'));
all.Add(fal2.Peek().Replace(".hpp", ".cpp"));
line = line.Replace(line.Substring(line.IndexOf('<'), (line.LastIndexOf('/') + 1) - (line.IndexOf('<'))), "\"");
line = line.Replace('>', '\"');
}
fw.Write(line + "\r\n");
}
fw.Flush();
fw.Close();
br.Close(); // 关闭文件
}
catch (IOException e)
{
Console.Error.WriteLine(e.StackTrace);
}
}
}
count = all.Count;
}
}
}
private void doSearch(string path)
{
DirectoryInfo filepath = new DirectoryInfo(path);
if (filepath.Exists)
{
FileSystemInfo[] fileArray = filepath.GetFileSystemInfos();
foreach (FileSystemInfo f in fileArray)
{
DirectoryInfo dd = f as DirectoryInfo;
if (dd != null)
{
doSearch(f.FullName);
}
else
{
FileInfo ff = f as FileInfo;
if (f.Name.IndexOf(filter) > -1)
{
foreach (string file in all)
{
if (file.IndexOf('<') == -1 && Path.GetFileName(file) == f.Name)
{
fal2.Enqueue(f.FullName);
}
}
}
}
}
}
}
static void Main(String[] args)
{
new InlineXercesc("xercesc");
FileInfo f = new FileInfo(CurDir + "\\DetailCpp.cmd");
StreamWriter w = f.CreateText();
w.WriteLine("copy StdAfx.cpp+*.c+*.cpp " + CurDir
+ "\\StdAfx.cpp&& del *.c && del *.cpp");
w.Close();
}
}
80.提取包含头文件列表
//InlineExt.cs
using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Text;
public class InlineExt
{
private System.String CurDir = Environment.CurrentDirectory;
public InlineExt()
{
string pattern = "include.*?\".*?.hpp\""; // 第一个参数为需要匹配的字符串
Match matcher = null;
FileInfo delfile = new System.IO.FileInfo(CurDir);
FileInfo[] files2 = SupportClass.FileSupport.GetFiles(delfile);
for (int l = 0; l < files2.Length; l++)
{
if (Directory.Exists(files2[l].FullName))
{
Queue ts = new Queue();
FileInfo file = new FileInfo(Path.Combine(files2[l].FullName , "StdAfx.cpp"));
StreamReader br = null;
StreamWriter fw = null;
String line;
try
{
br = new StreamReader(new StreamReader(file.FullName, System.Text.Encoding.Default).BaseStream, new System.IO.StreamReader(file.FullName, System.Text.Encoding.Default).CurrentEncoding); // 打开文件
while ((line = br.ReadLine()) != null)
{
matcher = Regex.Match(line, pattern); // 匹配字符串
if (matcher.Success == true)
{
// 如果有匹配的字符串，则输出
ts.Enqueue(line.Substring(line.IndexOf('\"') + 1, (line.LastIndexOf('\"')) - (line.IndexOf('\"') + 1)));
}
}
FileInfo file2 = new FileInfo(Path.Combine(files2[l].FullName , "ReadMe.txt"));
if (File.Exists(file2.FullName))
{
fw = new StreamWriter(file2.FullName, false, System.Text.Encoding.GetEncoding("GB2312")); //System.Text.Encoding.Default
foreach(string it in ts)
{
fw.Write("#include \"" + it + "\"\r\n");
}
}
}
catch (IOException e)
{
// 没有打开文件，则产生异常
Console.Error.WriteLine("Cannot read '" + file + "': " + e.Message);
continue;
}
finally
{
try
{
if (br != null)
br.Close();
if (fw != null)
fw.Close();
}
catch (IOException e)
{
Console.WriteLine(e.StackTrace);
}
}
}
}
}
public static void Main(System.String[] args)
{
new InlineExt();
}
}
//SupportClass.cs
using System;
///

/// Contains conversion support elements such as classes, interfaces and static methods.
///

public class SupportClass
{
///

/// Writes the exception stack trace to the received stream
///

/// Exception to obtain information from
/// Output sream used to write to
public static void WriteStackTrace(System.Exception throwable, System.IO.TextWriter stream)
{
stream.Write(throwable.StackTrace);
stream.Flush();
}
/*******************************/
///

/// Represents the methods to support some operations over files.
///

public class FileSupport
{
///

/// Creates a new empty file with the specified pathname.
///

/// The abstract pathname of the file
/// True if the file does not exist and was succesfully created
public static bool CreateNewFile(System.IO.FileInfo path)
{
if (path.Exists)
{
return false;
}
else
{
System.IO.FileStream createdFile = path.Create();
createdFile.Close();
return true;
}
}
///

/// Compares the specified object with the specified path
///

/// An abstract pathname to compare with
/// An object to compare with the given pathname
/// A value indicating a lexicographically comparison of the parameters
public static int CompareTo(System.IO.FileInfo path, System.Object file)
{
if( file is System.IO.FileInfo )
{
System.IO.FileInfo fileInfo = (System.IO.FileInfo)file;
return path.FullName.CompareTo( fileInfo.FullName );
}
else
{
throw new System.InvalidCastException();
}
}
///

/// Returns an array of abstract pathnames representing the files and directories of the specified path.
///

/// The abstract pathname to list it childs.
/// An array of abstract pathnames childs of the path specified or null if the path is not a directory
public static System.IO.FileInfo[] GetFiles(System.IO.FileInfo path)
{
if ( (path.Attributes & System.IO.FileAttributes.Directory) > 0 )
{
String[] fullpathnames = System.IO.Directory.GetFileSystemEntries(path.FullName);
System.IO.FileInfo[] result = new System.IO.FileInfo[fullpathnames.Length];
for(int i = 0; i < result.Length ; i++)
result[i] = new System.IO.FileInfo(fullpathnames[i]);
return result;
}
else return null;
}
///

/// Creates an instance of System.Uri class with the pech specified
///

/// The abstract path name to create the Uri
/// A System.Uri instance constructed with the specified path
public static System.Uri ToUri(System.IO.FileInfo path)
{
System.UriBuilder uri = new System.UriBuilder();
uri.Path = path.FullName;
uri.Host = String.Empty;
uri.Scheme = System.Uri.UriSchemeFile;
return uri.Uri;
}
///

/// Returns true if the file specified by the pathname is a hidden file.
///

/// The abstract pathname of the file to test
/// True if the file is hidden, false otherwise
public static bool IsHidden(System.IO.FileInfo file)
{
return ((file.Attributes & System.IO.FileAttributes.Hidden) > 0);
}
///

/// Sets the read-only property of the file to true.
///

/// The abstract path name of the file to modify
public static bool SetReadOnly(System.IO.FileInfo file)
{
try
{
file.Attributes = file.Attributes | System.IO.FileAttributes.ReadOnly;
return true;
}
catch (System.Exception exception)
{
String exceptionMessage = exception.Message;
return false;
}
}
///

/// Sets the last modified time of the specified file with the specified value.
///

/// The file to change it last-modified time
/// Total number of miliseconds since January 1, 1970 (new last-modified time)
/// True if the operation succeeded, false otherwise
public static bool SetLastModified(System.IO.FileInfo file, long date)
{
try
{
long valueConstant = (new System.DateTime(1969, 12, 31, 18, 0, 0)).Ticks;
file.LastWriteTime = new System.DateTime( (date * 10000L) + valueConstant );
return true;
}
catch (System.Exception exception)
{
String exceptionMessage = exception.Message;
return false;
}
}
}
}
81.剪贴扳转换成打印字符
//using System.Windows.Forms;
IDataObject iData = Clipboard.GetDataObject();
string str;
// 将数据与指定的格式进行匹配，返回bool
if (iData.GetDataPresent(DataFormats.Text))
{
// GetData检索数据并指定一个格式
str = (string)iData.GetData(DataFormats.Text);
string[] arr = str.Split("\r\n".ToCharArray());
StringBuilder sb = new StringBuilder(1024);
sb.Append("System.out.println(\"@echooff\");\r\n");
foreach (string s in arr)
{
if (s.Trim()!="")
{
sb.Append("System.out.println(\"ECHO " + s.Replace("^", "^^").Replace("&", "^&").Replace(":", "^:").Replace(">", "^>").Replace("<", "^<").Replace("|", "^|").Replace("\"", "^\"").Replace(@"\", @"\\").Replace("\"", "\\\"") + "\");");
sb.Append("\r\n");
}
}
Clipboard.SetText(sb.ToString());
}
else
{
MessageBox.Show("目前剪贴板中数据不可转换为文本", "错误");
}
82.把JButton或JTree组件写到一个流中
83.注册全局热键
注册全局热键要用到Windows的API方法RegisterHotKey和UnregisterHotKey。
一、声明注册热键方法 [DllImport("user32.dll")]
private static extern int RegisterHotKey(IntPtr hwnd, int id, int fsModifiers, int vk);
[DllImport("user32.dll")]
private static extern int UnregisterHotKey(IntPtr hwnd, int id);
int Space = 32; //热键ID
private const int WM_HOTKEY = 0x312; //窗口消息-热键
private const int WM_CREATE = 0x1; //窗口消息-创建
private const int WM_DESTROY = 0x2; //窗口消息-销毁
private const int MOD_ALT = 0x1; //ALT
private const int MOD_CONTROL = 0x2; //CTRL
private const int MOD_SHIFT = 0x4; //SHIFT
private const int VK_SPACE = 0x20; //SPACE
二、注册热键方法 ///

/// 注册热键
///

/// 窗口句柄
/// 热键ID
/// 组合键
/// 热键
private void RegKey(IntPtr hwnd, int hotKey_id, int fsModifiers, int vk)
{
bool result;
if (RegisterHotKey(hwnd,hotKey_id,fsModifiers,vk) == 0)
{
result = false;
}
else
{
result = true;
}
if (!result)
{
MessageBox.Show("注册热键失败！");
}
}
///

/// 注销热键
///

/// 窗口句柄
/// 热键ID
private void UnRegKey(IntPtr hwnd, int hotKey_id)
{
UnregisterHotKey(hwnd,hotKey_id);
}
三、重写WndProc方法，实现注册 protected override void WndProc(ref Message m)
{
base.WndProc(ref m);
switch(m.Msg)
{
case WM_HOTKEY: //窗口消息-热键
switch(m.WParam.ToInt32())
{
case 32: //热键ID
MessageBox.Show("Hot Key : Ctrl + Alt + Shift + Space");
break;
default:
break;
}
break;
case WM_CREATE: //窗口消息-创建
RegKey(Handle,Space,MOD_ALT | MOD_CONTROL | MOD_SHIFT,VK_SPACE); //注册热键
break;
case WM_DESTROY: //窗口消息-销毁
UnRegKey(Handle,Space); //销毁热键
break;
default:
break;
}
}
附：虚拟键值表
{ Virtual Keys, Standard Set }
{$EXTERNALSYM VK_LBUTTON}
VK_LBUTTON = 1;
{$EXTERNALSYM VK_RBUTTON}
VK_RBUTTON = 2;
{$EXTERNALSYM VK_CANCEL}
VK_CANCEL = 3;
{$EXTERNALSYM VK_MBUTTON}
VK_MBUTTON = 4; { NOT contiguous with L & RBUTTON }
{$EXTERNALSYM VK_BACK}
VK_BACK = 8;
{$EXTERNALSYM VK_TAB}
VK_TAB = 9;
{$EXTERNALSYM VK_CLEAR}
VK_CLEAR = 12;
{$EXTERNALSYM VK_RETURN}
VK_RETURN = 13;
{$EXTERNALSYM VK_SHIFT}
VK_SHIFT = $10;
{$EXTERNALSYM VK_CONTROL}
VK_CONTROL = 17;
{$EXTERNALSYM VK_MENU}
VK_MENU = 18;
{$EXTERNALSYM VK_PAUSE}
VK_PAUSE = 19;
{$EXTERNALSYM VK_CAPITAL}
VK_CAPITAL = 20;
{$EXTERNALSYM VK_KANA }
VK_KANA = 21;
{$EXTERNALSYM VK_HANGUL }
VK_HANGUL = 21;
{$EXTERNALSYM VK_JUNJA }
VK_JUNJA = 23;
{$EXTERNALSYM VK_FINAL }
VK_FINAL = 24;
{$EXTERNALSYM VK_HANJA }
VK_HANJA = 25;
{$EXTERNALSYM VK_KANJI }
VK_KANJI = 25;
{$EXTERNALSYM VK_CONVERT }
VK_CONVERT = 28;
{$EXTERNALSYM VK_NONCONVERT }
VK_NONCONVERT = 29;
{$EXTERNALSYM VK_ACCEPT }
VK_ACCEPT = 30;
{$EXTERNALSYM VK_MODECHANGE }
VK_MODECHANGE = 31;
{$EXTERNALSYM VK_ESCAPE}
VK_ESCAPE = 27;
{$EXTERNALSYM VK_SPACE}
VK_SPACE = $20;
{$EXTERNALSYM VK_PRIOR}
VK_PRIOR = 33;
{$EXTERNALSYM VK_NEXT}
VK_NEXT = 34;
{$EXTERNALSYM VK_END}
VK_END = 35;
{$EXTERNALSYM VK_HOME}
VK_HOME = 36;
{$EXTERNALSYM VK_LEFT}
VK_LEFT = 37;
{$EXTERNALSYM VK_UP}
VK_UP = 38;
{$EXTERNALSYM VK_RIGHT}
VK_RIGHT = 39;
{$EXTERNALSYM VK_DOWN}
VK_DOWN = 40;
{$EXTERNALSYM VK_SELECT}
VK_SELECT = 41;
{$EXTERNALSYM VK_PRINT}
VK_PRINT = 42;
{$EXTERNALSYM VK_EXECUTE}
VK_EXECUTE = 43;
{$EXTERNALSYM VK_SNAPSHOT}
VK_SNAPSHOT = 44;
{$EXTERNALSYM VK_INSERT}
VK_INSERT = 45;
{$EXTERNALSYM VK_DELETE}
VK_DELETE = 46;
{$EXTERNALSYM VK_HELP}
VK_HELP = 47;
{ VK_0 thru VK_9 are the same as ASCII '0' thru '9' ($30 - $39) }
{ VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' ($41 - $5A) }
{$EXTERNALSYM VK_LWIN}
VK_LWIN = 91;
{$EXTERNALSYM VK_RWIN}
VK_RWIN = 92;
{$EXTERNALSYM VK_APPS}
VK_APPS = 93;
{$EXTERNALSYM VK_NUMPAD0}
VK_NUMPAD0 = 96;
{$EXTERNALSYM VK_NUMPAD1}
VK_NUMPAD1 = 97;
{$EXTERNALSYM VK_NUMPAD2}
VK_NUMPAD2 = 98;
{$EXTERNALSYM VK_NUMPAD3}
VK_NUMPAD3 = 99;
{$EXTERNALSYM VK_NUMPAD4}
VK_NUMPAD4 = 100;
{$EXTERNALSYM VK_NUMPAD5}
VK_NUMPAD5 = 101;
{$EXTERNALSYM VK_NUMPAD6}
VK_NUMPAD6 = 102;
{$EXTERNALSYM VK_NUMPAD7}
VK_NUMPAD7 = 103;
{$EXTERNALSYM VK_NUMPAD8}
VK_NUMPAD8 = 104;
{$EXTERNALSYM VK_NUMPAD9}
VK_NUMPAD9 = 105;
{$EXTERNALSYM VK_MULTIPLY}
VK_MULTIPLY = 106;
{$EXTERNALSYM VK_ADD}
VK_ADD = 107;
{$EXTERNALSYM VK_SEPARATOR}
VK_SEPARATOR = 108;
{$EXTERNALSYM VK_SUBTRACT}
VK_SUBTRACT = 109;
{$EXTERNALSYM VK_DECIMAL}
VK_DECIMAL = 110;
{$EXTERNALSYM VK_DIVIDE}
VK_DIVIDE = 111;
{$EXTERNALSYM VK_F1}
VK_F1 = 112;
{$EXTERNALSYM VK_F2}
VK_F2 = 113;
{$EXTERNALSYM VK_F3}
VK_F3 = 114;
{$EXTERNALSYM VK_F4}
VK_F4 = 115;
{$EXTERNALSYM VK_F5}
VK_F5 = 116;
{$EXTERNALSYM VK_F6}
VK_F6 = 117;
{$EXTERNALSYM VK_F7}
VK_F7 = 118;
{$EXTERNALSYM VK_F8}
VK_F8 = 119;
{$EXTERNALSYM VK_F9}
VK_F9 = 120;
{$EXTERNALSYM VK_F10}
VK_F10 = 121;
{$EXTERNALSYM VK_F11}
VK_F11 = 122;
{$EXTERNALSYM VK_F12}
VK_F12 = 123;
{$EXTERNALSYM VK_F13}
VK_F13 = 124;
{$EXTERNALSYM VK_F14}
VK_F14 = 125;
{$EXTERNALSYM VK_F15}
VK_F15 = 126;
{$EXTERNALSYM VK_F16}
VK_F16 = 127;
{$EXTERNALSYM VK_F17}
VK_F17 = 128;
{$EXTERNALSYM VK_F18}
VK_F18 = 129;
{$EXTERNALSYM VK_F19}
VK_F19 = 130;
{$EXTERNALSYM VK_F20}
VK_F20 = 131;
{$EXTERNALSYM VK_F21}
VK_F21 = 132;
{$EXTERNALSYM VK_F22}
VK_F22 = 133;
{$EXTERNALSYM VK_F23}
VK_F23 = 134;
{$EXTERNALSYM VK_F24}
VK_F24 = 135;
{$EXTERNALSYM VK_NUMLOCK}
VK_NUMLOCK = 144;
{$EXTERNALSYM VK_SCROLL}
VK_SCROLL = 145;
{ VK_L & VK_R - left and right Alt, Ctrl and Shift virtual keys.
Used only as parameters to GetAsyncKeyState() and GetKeyState().
No other API or message will distinguish left and right keys in this way. }
{$EXTERNALSYM VK_LSHIFT}
VK_LSHIFT = 160;
84.菜单勾选/取消完成后关闭计算机
/*
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential, Pack = 1)]
internal struct TokPriv1Luid
{
public int Count;
public long Luid;
public int Attr;
}
[DllImport("kernel32.dll", ExactSpelling = true)]
internal static extern IntPtr GetCurrentProcess();

[DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]
internal static extern bool OpenProcessToken(IntPtr h, int acc, ref IntPtr phtok);

[DllImport("advapi32.dll", SetLastError = true)]
internal static extern bool LookupPrivilegeValue(string host, string name, ref long pluid);

[DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]
internal static extern bool AdjustTokenPrivileges(IntPtr htok, bool disall, ref TokPriv1Luid newst, int len, IntPtr prev, IntPtr relen);

[DllImport("user32.dll", ExactSpelling = true, SetLastError = true)]
internal static extern bool ExitWindowsEx(int flg, int rea);

internal const int SE_PRIVILEGE_ENABLED = 0x00000002;
internal const int TOKEN_QUERY = 0x00000008;
internal const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;
internal const string SE_SHUTDOWN_NAME = "SeShutdownPrivilege";
internal const int EWX_SHUTDOWN = 0x00000001;
internal const int EWX_POWEROFF = 0x00000008;
internal const int EWX_FORCE = 0x00000004;
internal const int EWX_FORCEIFHUNG = 0x00000010;
*/
int flg=EWX_FORCE | EWX_POWEROFF;
bool ok;
TokPriv1Luid tp;
IntPtr hproc = GetCurrentProcess();
IntPtr htok = IntPtr.Zero;
k = OpenProcessToken(hproc, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ref htok);
tp.Count = 1;
tp.Luid = 0;
tp.Attr = SE_PRIVILEGE_ENABLED;
k = LookupPrivilegeValue(null, SE_SHUTDOWN_NAME, ref tp.Luid);
k = AdjustTokenPrivileges(htok, false, ref tp, 0, IntPtr.Zero, IntPtr.Zero);
k = ExitWindowsEx(flg, 0);
85.菜单勾选/取消完成后重新启动计算机
/*
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential, Pack = 1)]
internal struct TokPriv1Luid
{
public int Count;
public long Luid;
public int Attr;
}
[DllImport("kernel32.dll", ExactSpelling = true)]
internal static extern IntPtr GetCurrentProcess();

[DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]
internal static extern bool OpenProcessToken(IntPtr h, int acc, ref IntPtr phtok);

[DllImport("advapi32.dll", SetLastError = true)]
internal static extern bool LookupPrivilegeValue(string host, string name, ref long pluid);

[DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]
internal static extern bool AdjustTokenPrivileges(IntPtr htok, bool disall, ref TokPriv1Luid newst, int len, IntPtr prev, IntPtr relen);

[DllImport("user32.dll", ExactSpelling = true, SetLastError = true)]
internal static extern bool ExitWindowsEx(int flg, int rea);

internal const int SE_PRIVILEGE_ENABLED = 0x00000002;
internal const int TOKEN_QUERY = 0x00000008;
internal const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;
internal const string SE_SHUTDOWN_NAME = "SeShutdownPrivilege";
internal const int EWX_SHUTDOWN = 0x00000001;
internal const int EWX_REBOOT = 0x00000002;
internal const int EWX_FORCE = 0x00000004;
internal const int EWX_FORCEIFHUNG = 0x00000010;
*/
int flg=EWX_FORCE | EWX_REBOOT;
bool ok;
TokPriv1Luid tp;
IntPtr hproc = GetCurrentProcess();
IntPtr htok = IntPtr.Zero;
k = OpenProcessToken(hproc, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ref htok);
tp.Count = 1;
tp.Luid = 0;
tp.Attr = SE_PRIVILEGE_ENABLED;
k = LookupPrivilegeValue(null, SE_SHUTDOWN_NAME, ref tp.Luid);
k = AdjustTokenPrivileges(htok, false, ref tp, 0, IntPtr.Zero, IntPtr.Zero);
k = ExitWindowsEx(flg, 0);
86.菜单勾选/取消完成后注销计算机
/*
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential, Pack = 1)]
internal struct TokPriv1Luid
{
public int Count;
public long Luid;
public int Attr;
}
[DllImport("kernel32.dll", ExactSpelling = true)]
internal static extern IntPtr GetCurrentProcess();

[DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]
internal static extern bool OpenProcessToken(IntPtr h, int acc, ref IntPtr phtok);

[DllImport("advapi32.dll", SetLastError = true)]
internal static extern bool LookupPrivilegeValue(string host, string name, ref long pluid);

[DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)]
internal static extern bool AdjustTokenPrivileges(IntPtr htok, bool disall, ref TokPriv1Luid newst, int len, IntPtr prev, IntPtr relen);

[DllImport("user32.dll", ExactSpelling = true, SetLastError = true)]
internal static extern bool ExitWindowsEx(int flg, int rea);

internal const int SE_PRIVILEGE_ENABLED = 0x00000002;
internal const int TOKEN_QUERY = 0x00000008;
internal const int TOKEN_ADJUST_PRIVILEGES = 0x00000020;
internal const string SE_SHUTDOWN_NAME = "SeShutdownPrivilege";
internal const int EWX_SHUTDOWN = 0x00000001;
internal const int EWX_LOGOFF = 0x00000000;
internal const int EWX_FORCE = 0x00000004;
internal const int EWX_FORCEIFHUNG = 0x00000010;
*/
int flg=EWX_FORCE | EWX_LOGOFF;
bool ok;
TokPriv1Luid tp;
IntPtr hproc = GetCurrentProcess();
IntPtr htok = IntPtr.Zero;
k = OpenProcessToken(hproc, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ref htok);
tp.Count = 1;
tp.Luid = 0;
tp.Attr = SE_PRIVILEGE_ENABLED;
k = LookupPrivilegeValue(null, SE_SHUTDOWN_NAME, ref tp.Luid);
k = AdjustTokenPrivileges(htok, false, ref tp, 0, IntPtr.Zero, IntPtr.Zero);
k = ExitWindowsEx(flg, 0);
87.菜单勾选/取消开机自启动程序
public void RunWhenStart(bool Started)
{
string name=%%1;
string path=Application.ExecutablePath;
RegistryKey HKLM = Registry.LocalMachine;
RegistryKey Run = HKLM.CreateSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Run\");
if (Started == true)
{
try
{
Run.SetValue(name, path);
HKLM.Close();
}
catch (Exception)
{
MessageBox.Show("注册表修改错误(开机自启未实现)");
}
}
else
{
try
{
if (Run.GetValue(name) != null)
{
Run.DeleteValue(name);
HKLM.Close();
}
else
return;
}
catch (Exception e)
{
//ExceptionTransact.WriteErrLog(base.GetType().Name, e.Message);
MessageBox(e.Message);
}
}
}
88.菜单勾选/取消自动登录系统
89.模拟键盘输入字符串
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using KenZhang.Free.VirtualInput;
using System.Runtime.InteropServices;
namespace VirtualInputDemo
{
public partial class Form1 : Form
{
public const int INPUT_KEYBOARD = 1;
public const int KEYEVENTF_KEYUP = 0x0002;
[DllImport("user32.dll")]
public static extern UInt32 SendInput(UInt32 nInputs, ref INPUT pInputs, int cbSize);
[StructLayout(LayoutKind.Explicit)]
public struct INPUT
{
[FieldOffset(0)]
public Int32 type;
[FieldOffset(4)]
public KEYBDINPUT ki;
[FieldOffset(4)]
public MOUSEINPUT mi;
[FieldOffset(4)]
public HARDWAREINPUT hi;
}

[StructLayout(LayoutKind.Sequential)]
public struct MOUSEINPUT
{
public Int32 dx;
public Int32 dy;
public Int32 mouseData;
public Int32 dwFlags;
public Int32 time;
public IntPtr dwExtraInfo;
}
[StructLayout(LayoutKind.Sequential)]
public struct KEYBDINPUT
{
public Int16 wVk;
public Int16 wScan;
public Int32 dwFlags;
public Int32 time;
public IntPtr dwExtraInfo;
}
[StructLayout(LayoutKind.Sequential)]
public struct HARDWAREINPUT
{
public Int32 uMsg;
public Int16 wParamL;
public Int16 wParamH;
}
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
textBox1.Focus();
INPUT inDown = new INPUT();
inDown.type = INPUT_KEYBOARD;
inDown.ki.wVk = (int)Keys.A;
//INPUT inUp = new INPUT();
//inUp.type = INPUT_KEYBOARD;
//inUp.ki.wVk = (int)Keys.A;
//inUp.ki.dwFlags = KEYEVENTF_KEYUP;
SendInput(1, ref inDown, Marshal.SizeOf(inDown));
//SendInput(1, ref inUp, Marshal.SizeOf(inUp));
}
}
}
90.提取PDF文件中的文本
xpdf
public partial class Form1 : Form
{
public OpenFileDialog fdlg = new OpenFileDialog();//打开文件对话框
public string filename;
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
ofdlg.Filter = "pdf文件(*.pdf)|*.pdf";//选择pdf文件
if (ofdlg.ShowDialog() == DialogResult.OK)
{
filename = string.Format("{0}", ofdlg.FileName);
}
}
　　　　　　//传送打开文件对话框中得到的filename来做为外部程序的参数来做转化
private void button2_Click(object sender, EventArgs e)
{
Process p = new Process();
string path = "pdftotext.exe"; //进程启用外部程序
　　　　　　　　　　　　　　　　//这个exe我放在debug文件夹下面
p.StartInfo.FileName = path;
p.StartInfo.Arguments = string.Format( filename + " -");//很怪异的一行
　　　　　　　　　　　　　　　　　　　　　　　//参数“－”表示可以得到输出流
p.StartInfo.UseShellExecute = false;
p.StartInfo.RedirectStandardInput = true;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.RedirectStandardError = true;
p.StartInfo.CreateNoWindow = true;

p.Start();
string s = p.StandardOutput.ReadToEnd();//得到pdf文档中的文本内容
textBox1.Text = s;
p.Close();
}
}
}

上面的程序运行后，如果是在Debug文件夹下的pdf文件就可以得到输出，可是如果在打开文件对话框中打开我桌面上的一个pdf如：@"d:\我的文档\test.pdf"，输出就会是空，但是如果把上面那怪异的一行改为：
C# code
p.StartInfo.Arguments = string.Format( @"d:\我的文档\test.pdf" + " -");

程序就又会得到输出。
呵呵，谢谢楼上的兄台，下载的xpdf中xpdftotext.exe用到的配置文件xpdfrc需要手动配置，我如果把那些字体啊，什么的映射成绝对路径下的文件，就不会出现上面的问题，但是我把配置文件中的路径改成了相对路径，于是就出现了上面的问题了，看兄台能够很轻易的就运行成功，一定是做过很多代码的，这里还得劳烦兄台再给看一下，帮下忙，能遇到一个大神不容易，大神可不能吝啬啊，先谢过了哈
91.操作内存映射文件
/*
using System.Runtime.InteropServices;
[DllImport("kernel32.dll")]
public static extern IntPtr CreateFileMapping(IntPtr hFile,
IntPtr lpFileMappingAttributes, uint flProtect,
uint dwMaximumSizeHigh,
uint dwMaximumSizeLow, string lpName);
[DllImport("kernel32.dll")]
public static extern IntPtr MapViewOfFile(IntPtr hFileMappingObject, uint
dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow,
IntPtr dwNumberOfBytesToMap);
[DllImport("kernel32.dll")]
public static extern bool UnmapViewOfFile(IntPtr lpBaseAddress);
[DllImport("kernel32.dll")]
public static extern bool CloseHandle(IntPtr hObject);
[DllImport("kernel32.dll")]
public static extern IntPtr CreateFile(string lpFileName,
int dwDesiredAccess, FileShare dwShareMode, IntPtr securityAttrs,
FileMode dwCreationDisposition, int dwFlagsAndAttributes, IntPtr hTemplateFile);
[DllImport("kernel32.dll")]
public static extern uint GetFileSize(IntPtr hFile, IntPtr lpFileSizeHigh);
public const int GENERIC_READ = -2147483648; //0x80000000
public const int GENERIC_WRITE = 0x40000000;
public const int GENERIC_EXECUTE = 0x20000000;
public const int GENERIC_ALL = 0x10000000;
public const int FILE_ATTRIBUTE_NORMAL = 0x80;
public const int FILE_FLAG_SEQUENTIAL_SCAN = 0x8000000;
public const int INVALID_HANDLE_VALUE = -1;
public const int PAGE_NOACCESS = 1;
public const int PAGE_READONLY = 2;
public const int PAGE_READWRITE = 4;
public const int FILE_MAP_COPY = 1;
public const int FILE_MAP_WRITE = 2;
public const int FILE_MAP_READ = 4;
*/
IntPtr vFileHandle = CreateFile(@"c:\temp\temp.txt",
GENERIC_READ | GENERIC_WRITE, FileShare.Read | FileShare.Write,
IntPtr.Zero, FileMode.Open,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, IntPtr.Zero);
if (INVALID_HANDLE_VALUE != (int)vFileHandle)
{
IntPtr vMappingHandle = CreateFileMapping(
vFileHandle, IntPtr.Zero, PAGE_READWRITE, 0, 0, "~MappingTemp");
if (vMappingHandle != IntPtr.Zero)
{
IntPtr vHead = MapViewOfFile(vMappingHandle,
FILE_MAP_COPY | FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, IntPtr.Zero);
if (vHead != IntPtr.Zero)
{
uint vSize = GetFileSize(vFileHandle, IntPtr.Zero);
for (int i = 0; i <= vSize / 2; i++)
{
byte vTemp = Marshal.ReadByte((IntPtr)((int)vHead + i));
Marshal.WriteByte((IntPtr)((int)vHead + i),
Marshal.ReadByte((IntPtr)((int)vHead + vSize - i - 1)));
Marshal.WriteByte((IntPtr)((int)vHead + vSize - i - 1), vTemp);
}
UnmapViewOfFile(vHead);
}
CloseHandle(vMappingHandle);
}
CloseHandle(vFileHandle);
}
92.重定向windows控制台程序的输出信息
delegate void dReadLine(string strLine);
private void excuteCommand(string strFile, string args, dReadLine onReadLine)
{
System.Diagnostics.Process p = new System.Diagnostics.Process();
p.StartInfo = new System.Diagnostics.ProcessStartInfo();
p.StartInfo.FileName = strFile;
p.StartInfo.Arguments = args;
p.StartInfo.WindowStyle. = System.Diagnostics.ProcessWindowStyle.Hidden;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.UseShellExecute = false;
p.StartInfo.CreateNoWindow = true;
p.Start();
System.IO.StreamReader reader = p.StandardOutput;//截取输出流
string line = reader.ReadLine();//每次读取一行
while (!reader.EndOfStream)
{
onReadLine(line);
line = reader.ReadLine();
}
p.WaitForExit();
}
private void PrintMessage(string strLine)
{
this.textBox1.Text += strLine + " ";
}
excuteCommand("ipconfig", "", new dReadLine(PrintMessage));
93.接受邮件
94.发送邮件
using System;
using System.Net.Sockets;
using System.Net;
using System.Security.Cryptography;
using System.IO;
// 类名：Pop3
// 功能：接收电子邮件
namespace ZTSX.Email
{
///

/// Pop3 的摘要说明。
///

public class Pop3
{
private string mstrHost = null; //主机名称或IP地址
private int mintPort = 110; //主机的端口号（默认为110）
private TcpClient mtcpClient = null; //客户端
private NetworkStream mnetStream = null; //网络基础数据流
private StreamReader m_stmReader = null; //读取字节流
private string mstrStatMessage = null; //执行STAT命令后得到的消息（从中得到邮件数）
///

/// 构造函数
///

/// 一个邮件接收对象
public Pop3()
{
}
///

/// 构造函数
///

/// 主机名称或IP地址
public Pop3(string host)
{
mstrHost = host;
}
///

/// 构造函数
///

/// 主机名称或IP地址
/// 主机的端口号
/// 一个邮件接收对象
public Pop3(string host,int port)
{
mstrHost = host;
mintPort = port;
}
#region 属性
///

/// 主机名称或IP地址
///

/// 主机名称或IP地址
public string HostName
{
get{return mstrHost;}
set{mstrHost = value;}
}
///

/// 主机的端口号
///

/// 主机的端口号
public int Port
{
get{return mintPort;}
set{mintPort = value;}
}
#endregion
#region 私有方法
///

/// 向网络访问的基础数据流中写数据（发送命令码）
///

/// 可以用于网络访问的基础数据流
/// 命令行
/// 向网络访问的基础数据流中写数据（发送命令码）
private void WriteToNetStream(ref NetworkStream netStream,String command)
{
string strToSend = command + "\r\n";
byte[] arrayToSend = System.Text.Encoding.ASCII.GetBytes(strToSend.ToCharArray());
netStream.Write(arrayToSend,0,arrayToSend.Length);
}
///

/// 检查命令行结果是否正确
///

/// 命令行的执行结果
/// 正确标志
///
/// 类型：布尔
/// 内容：true表示没有错误，false为有错误
///
/// 检查命令行结果是否有错误
private bool CheckCorrect(string message,string check)
{
if(message.IndexOf(check) == -1)
return false;
else
return true;
}
///

/// 邮箱中的未读邮件数
///

/// 执行完LIST命令后的结果
///
/// 类型：整型
/// 内容：邮箱中的未读邮件数
///
/// 邮箱中的未读邮件数
private int GetMailNumber(string message)
{
string[] strMessage = message.Split(' ');
return Int32.Parse(strMessage[1]);
}
///

/// 得到经过解码后的邮件的内容
///

/// 解码前的邮件的内容
///
/// 类型：字符串
/// 内容：解码后的邮件的内容
///
/// 得到解码后的邮件的内容
private string GetDecodeMailContent(string encodingContent)
{
string strContent = encodingContent.Trim();
string strEncode = null;
int iStart = strContent.IndexOf("Base64");
if(iStart == -1)
throw new Pop3Exception("邮件内容不是Base64编码，请检查");
else
{
strEncode = strContent.Substring(iStart + 6,strContent.Length - iStart - 6);
try
{
return SX.Encode.TransformToString(strEncode);
}
catch(SX.EncodeException exc)
{
throw new Pop3Exception(exc.Message);
}
}
}
#endregion
///

/// 与主机建立连接
///

///
/// 类型：布尔
/// 内容：连接结果（true为连接成功，false为连接失败）
///
/// 与主机建立连接
public bool Connect()
{
if(mstrHost == null)
throw new Exception("请提供SMTP主机名称或IP地址！");
if(mintPort == 0)
throw new Exception("请提供SMTP主机的端口号");
try
{
mtcpClient = new TcpClient(mstrHost,mintPort);
mnetStream = mtcpClient.GetStream();
m_stmReader = new StreamReader(mtcpClient.GetStream());
string strMessage = m_stmReader.ReadLine();
if(CheckCorrect(strMessage,"+OK") == true)
return true;
else
return false;
}
catch(SocketException exc)
{
throw new Pop3Exception(exc.ToString());
}
catch(NullReferenceException exc)
{
throw new Pop3Exception(exc.ToString());
}
}
#region Pop3命令
///

/// 执行Pop3命令，并检查执行的结果
///

/// Pop3命令行
///
/// 类型：字符串
/// 内容：Pop3命令的执行结果
///
private string ExecuteCommand(string command)
{
string strMessage = null; //执行Pop3命令后返回的消息
try
{
//发送命令
WriteToNetStream(ref mnetStream,command);
//读取多行
if(command.Substring(0,4).Equals("LIST") || command.Substring(0,4).Equals("RETR") || command.Substring(0,4).Equals("UIDL")) //记录STAT后的消息（其中包含邮件数）
{
strMessage = ReadMultiLine();
if(command.Equals("LIST")) //记录LIST后的消息（其中包含邮件数）
mstrStatMessage = strMessage;
}
//读取单行
else
strMessage = m_stmReader.ReadLine();
//判断执行结果是否正确
if(CheckCorrect(strMessage,"+OK"))
return strMessage;
else
return "Error";
}
catch(IOException exc)
{
throw new Pop3Exception(exc.ToString());
}
}
///

/// 在Pop3命令中，LIST、RETR和UIDL命令的结果要返回多行，以点号（.）结尾，
/// 所以如果想得到正确的结果，必须读取多行
///

///
/// 类型：字符串
/// 内容：执行Pop3命令后的结果
///
private string ReadMultiLine()
{
string strMessage = m_stmReader.ReadLine();
string strTemp = null;
while(strMessage != ".")
{
strTemp = strTemp + strMessage;
strMessage = m_stmReader.ReadLine();
}
return strTemp;
}
//USER命令
private string USER(string user)
{
return ExecuteCommand("USER " + user) + "\r\n";
}
//PASS命令
private string PASS(string password)
{
return ExecuteCommand("PASS " + password) + "\r\n";
}
//LIST命令
private string LIST()
{
return ExecuteCommand("LIST") + "\r\n";
}
//UIDL命令
private string UIDL()
{
return ExecuteCommand("UIDL") + "\r\n";
}
//NOOP命令
private string NOOP()
{
return ExecuteCommand("NOOP") + "\r\n";
}
//STAT命令
private string STAT()
{
return ExecuteCommand("STAT") + "\r\n";
}
//RETR命令
private string RETR(int number)
{
return ExecuteCommand("RETR " + number.ToString()) + "\r\n";
}
//DELE命令
private string DELE(int number)
{
return ExecuteCommand("DELE " + number.ToString()) + "\r\n";
}
//QUIT命令
private void Quit()
{
WriteToNetStream(ref mnetStream,"QUIT");
}
///

/// 收取邮件
///

/// 用户名
/// 口令
///
/// 类型：字符串数组
/// 内容：解码前的邮件内容
///
private string[] ReceiveMail(string user,string password)
{
int iMailNumber = 0; //邮件数
if(USER(user).Equals("Error"))
throw new Pop3Exception("用户名不正确！");
if(PASS(password).Equals("Error"))
throw new Pop3Exception("用户口令不正确！");
if(STAT().Equals("Error"))
throw new Pop3Exception("准备接收邮件时发生错误！");
if(LIST().Equals("Error"))
throw new Pop3Exception("得到邮件列表时发生错误！");
try
{
iMailNumber = GetMailNumber(mstrStatMessage);
//没有新邮件
if(iMailNumber == 0)
return null;
else
{
string[] strMailContent = new string[iMailNumber];
for(int i = 1 ; i <= iMailNumber ; i++)
{
//读取邮件内容
strMailContent[i - 1] = GetDecodeMailContent(RETR(i));
}
return strMailContent;
}
}
catch(Pop3Exception exc)
{
throw new Pop3Exception(exc.ToString());
}
}
#endregion

///

/// 收取邮件
///

/// 用户名
/// 口令
///
/// 类型：字符串数组
/// 内容：解码前的邮件内容
///
///收取邮箱中的未读邮件
public string[] Receive(string user,string password)
{
try
{
return ReceiveMail(user,password);
}
catch(Pop3Exception exc)
{
throw new Pop3Exception(exc.ToString());
}
}
///

/// 断开所有与服务器的会话
///

/// 断开所有与服务器的会话
public void DisConnect()
{
try
{
Quit();
if(m_stmReader != null)
m_stmReader.Close();
if(mnetStream != null)
mnetStream.Close();
if(mtcpClient != null)
mtcpClient.Close();
}
catch(SocketException exc)
{
throw new Pop3Exception(exc.ToString());
}
}
///

/// 删除邮件
///

/// 邮件号
public void DeleteMail(int number)
{
//删除邮件
int iMailNumber = number + 1;
if(DELE(iMailNumber).Equals("Error"))
throw new Pop3Exception("删除第" + iMailNumber.ToString() + "时出现错误！");
}
}
}
95.报表相关
/*
using CrystalDecisions.CrystalReports.Engine;
using CrystalDecisions.Shared;
*/
2、水晶报表的两种格式
1）pull模式,不利用DataSet,直接从数据库中取出数据
2) push模式,使用DataSet,利用它进行数据的加载和处理等
3. 水晶报表使用的库
1)水晶报表的引擎(CREnging.dll),作用:合并数据,装换格式
2)水晶报表设计器(CRDesigner.dll),作用：设计标题，插入数据等
3）水晶报表查看控件（CRWebFormViewer.DLL）
4)需要引入的命名空间
using CrystalDecisions.CrystalReports.Engine;
using CrystalDecisions.Shared;
4、Pull模式下使用水晶报表
1）创建rpt文件
2）拖放CrystalReportViewer
3）绑定
5、读取水晶报表文件
private void ReadCRV(cryatalReportViewer crv)
{
openFileDialog dlg=new OpenFileDialog();
dlg.Title="打开水晶报表文件";
dlg.Filter="水晶报表文件(*.rpt)|*.rpt|所有文件|*.*";
if(dlg.showDialog()==DialogResult.OK)
{
crv.ReportSource=dlg.FileName;
}
}
6. B/S下读取报表的文件
private void ReadCRV(cryatalReportViewer crv,File file)
{
string strName=file.PostedFile.FileName;
if(strName.Trim()!="")
{
crv.ReportSource=strName
Session["fileName"]=strName;
}
}
在B/S中要防止数据源的丢失
priavte void Page_Load(object sender,System.EventArgs e)
{
if(Session["fileName"]!=null)
{
crv.ReportSource=Session["fileName"].ToString();
}
}
7. 假如直接从数据库中读取数据，采用PULL模式可能出现错误（登录的用户名和密码不对）
private void ReadCRV(CrystalReportViewer crv,CrystalReport cr)
{
ReportDocument reportDoc=new ReportDocument();
reportDoc.Load(Server.MapPath(cr));//要加载的rpt文件的名字
//解决登录的问题
TableLogOnInfo logonInfo = new TableLogOnInfo();
foreach(Table tb in ReportDoc.Database.Tables)
{
logonInfo=tb.LogOnInfo;
logonInfo.ConnectionInfo.ServerName="(loacl)";
logonInfo.ConnectionInfo.DatabaseName="Pubs";
logonInfo.ConnectionInfo.UserId="sa";
logonInfo.ConnectionInfo.Password="";
tb.ApplyLogOnInfo(logonInfo);
}
crv.ReportSource=reportDoc;
}
8. 采用Push模式，直接在数据源读取
private void BindReport(CrystalReportViewer crv)
{
string strProvider="Server=(local);DataBase=pubs;uid=sa;pwd=";
CrystalReport cr=new CrystalReport();
DataSet ds=new DataSet();
SqlConnection conn=new SqlConnection(strProvider);
conn.open();
string strSql="select * from jobs";
SqlDataAdapter dap=new SqlDataAdapter(strSql,conn);
adp.Fill(ds,"jobs");
cr.SetDataSource(ds);
crv.ReportSource=cr;
}
9. 导出水晶报表的文件
private void ExportCrv(CrystalReport cr)
{
DiskFileDestionOptions dOpt=new DiskFileDestionOptions();
cr.ExportOptions.ExportDestinationType=ExportDestinationType.DiskFile();
cr.ExportOptions.ExportFormatType= ExportFormatType.PortableDocFormat;
dOpt.DiskFileName="C:\output.pdf";
cr.ExportOptions.DestinationOptions=dOpt;
cr.Export();

}
private void ExportCrv(CrystalReport cr,string strType,string strPath)
{
DiskFileDestionOptions dOpt=new DiskFileDestionOptions();
cr.ExportOptions.ExportDestinationType=ExportDestinationType.DiskFile();
switch(strType)
{
case "RTF":
cr.ExportOptions.ExportFormatType=ExportFormatType.RichText;
dOpt.DiskFileName=strPath;
break;
case "PDF":
cr.ExportOptions.ExportFormatType=ExportFormatType.PortableDocFormat;
dOpt.DiskFileName=strPath;
break;
case "DOC":
cr.ExportOptions.ExportFormatType=ExportFormatType.WordForWindows;
dOpt.DiskFileName=strPath;
break;
case "XLS":
cr.ExportOptions.ExportFormatType=ExportFormatType.Excel;
dOpt.DiskFileName=strPath;
break;
default;
break;

}
cr.ExportOptions.DestinationOptions=dOpt;
cr.Export();
}
10 B/S下水晶报表的打印
priavte void PrintCRV(CrystalReport cr)
{
stringstrPrinterName=@"printName";
PageMargins margins=cr.PrintOptions.PageMargins;
margins.bottomMargin = 250;
margins.leftMargin = 350;
margins.rightMargin = 350;
margins.topMargin = 450;
cr.PrintOptions.ApplyPageMargins(margins);
cr.PrintOptions.printerName=strPrinterName;
cr.PrintToPrinter(1,false,0,0)//参数设置为0，表示打印所用页
}
96.全屏幕截取
/*
using System.Drawing.Drawing2D;
using System.Runtime.InteropServices;
using System.Collections;
using System.Drawing.Imaging;
using System.Threading;
*/
[DllImport("gdi32.dll")]
private static extern int BitBlt(IntPtr hdcDest,int nXDest,int nYDest,int nWidth,int nHeight,IntPtr hdcSrc,int nXSrc,int nYSrc,UInt32 dwRop);
//this.Hide();//如果你不想截取的图象中有此应用程序
//Thread.Sleep(1000);
Rectangle rect = new Rectangle();
rect = Screen.GetWorkingArea(this);//获得当前屏幕的大小
Graphics g = this.CreateGraphics();
//创建一个以当前屏幕为模板的图象
Image myimage = new Bitmap(rect.Width, rect.Height, g);
//第二种得到全屏坐标的方法
// Image myimage = new Bitmap(Screen.PrimaryScreen.Bounds.Width,Screen.PrimaryScreen.Bounds.Height,g);
//创建以屏幕大小为标准的位图
Graphics gg = Graphics.FromImage(myimage);
IntPtr dc = g.GetHdc();//得到屏幕的DC
IntPtr dcdc = gg.GetHdc();//得到Bitmap的DC
BitBlt(dcdc, 0, 0, rect.Width, rect.Height, dc, 0, 0, 13369376);
//调用此API函数，实现屏幕捕获
g.ReleaseHdc(dc);//释放掉屏幕的DC
gg.ReleaseHdc(dcdc);//释放掉Bitmap的DC
myimage.Save(Application.StartupPath + @"\bob.jpg", ImageFormat.Jpeg);//以JPG文件格式来保存
this.Show();
97.区域截幕
/*
using System.Drawing.Drawing2D;
using System.Runtime.InteropServices;
using System.Collections;
using System.Drawing.Imaging;
using System.Threading;
[DllImport("gdi32.dll")]
public static extern IntPtr CreateDC(
string lpszDriver, // driver name
string lpszDevice, // device name
string lpszOutput, // not used; should be NULL
Int64 lpInitData // optional printer data
);

[DllImport("gdi32.dll")]
public static extern IntPtr CreateCompatibleDC(
IntPtr hdc // handle to DC
);

[DllImport("gdi32.dll")]
public static extern int GetDeviceCaps(
IntPtr hdc, // handle to DC
GetDeviceCapsIndex nIndex // index of capability
);
[DllImport("gdi32.dll")]
public static extern IntPtr CreateCompatibleBitmap(
IntPtr hdc, // handle to DC
int nWidth, // width of bitmap, in pixels
int nHeight // height of bitmap, in pixels
);
[DllImport("gdi32.dll")]
public static extern IntPtr SelectObject(
IntPtr hdc, // handle to DC
IntPtr hgdiobj // handle to object
);
[DllImport("gdi32.dll")]
public static extern int BitBlt(
IntPtr hdcDest, // handle to destination DC
int nXDest, // x-coord of destination upper-left corner
int nYDest, // y-coord of destination upper-left corner
int nWidth, // width of destination rectangle
int nHeight, // height of destination rectangle
IntPtr hdcSrc, // handle to source DC
int nXSrc, // x-coordinate of source upper-left corner
int nYSrc, // y-coordinate of source upper-left corner
UInt32 dwRop // raster operation code
);
[DllImport("gdi32.dll")]
public static extern int DeleteDC(
IntPtr hdc // handle to DC
);
*/
public static Bitmap GetPartScreen(Point P1,Point P2,bool Full)
{
IntPtr hscrdc,hmemdc;
IntPtr hbitmap,holdbitmap;
int nx,ny,nx2,ny2;
nx=ny=nx2=ny2=0;
int nwidth, nheight;
int xscrn, yscrn;
hscrdc = CreateDC("DISPLAY", null, null, 0);//创建DC句柄
hmemdc = CreateCompatibleDC(hscrdc);//创建一个内存DC
xscrn = GetDeviceCaps(hscrdc, GetDeviceCapsIndex.HORZRES);//获取屏幕宽度
yscrn = GetDeviceCaps(hscrdc, GetDeviceCapsIndex.VERTRES);//获取屏幕高度
if(Full)//如果是截取整个屏幕
{
nx = 0;
ny = 0;
nx2 = xscrn;
ny2 = yscrn;
}
else
{
nx = P1.X;
ny = P1.Y;
nx2 =P2.X;
ny2 =P2.Y;
//检查数值合法性
if(nx<0)nx = 0;
if(ny<0)ny = 0;
if(nx2>xscrn)nx2 = xscrn;
if(ny2>yscrn)ny2 = yscrn;
}
nwidth = nx2 - nx;//截取范围的宽度
nheight = ny2 - ny;//截取范围的高度
hbitmap = CreateCompatibleBitmap(hscrdc, nwidth, nheight);//从内存DC复制到hbitmap句柄
holdbitmap = SelectObject(hmemdc, hbitmap);
BitBlt(hmemdc, 0, 0, nwidth, nheight,hscrdc, nx, ny,(UInt32)0xcc0020);
hbitmap = SelectObject(hmemdc, holdbitmap);
DeleteDC(hscrdc);//删除用过的对象
DeleteDC(hmemdc);//删除用过的对象
return Bitmap.FromHbitmap(hbitmap);//用Bitmap.FromHbitmap从hbitmap返回Bitmap
}
98.计算文件MD5值
/*
using System.IO;
using System.Security.Cryptography;
*/
string path = %%1;
FileStream fs = new FileStream(path,FileMode.Open,FileAccess.Read);
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
byte [] md5byte = md5.ComputeHash(fs);
int i,j;
StringBuilder sb = new StringBuilder(16);
foreach (byte b in md5byte)
{
　 i = Convert.ToInt32(b);
　　 j = i >> 4;
　　 sb.Append(Convert.ToString(j,16));
　　 j = ((i << 4) & 0x00ff) >> 4;
　　 sb.Append(Convert.ToString(j,16));
}
string %%2=sb.ToString();
99.计算获取文件夹中文件的MD5值
/*
using System.IO;
using System.Security.Cryptography;
using System.Collections;
*/
bool b=false;
string path = (%%2.LastIndexOf("\\") == %%2.Length - 1) ? %%2 : %%2 + "\\";
string parent = Path.GetDirectoryName(%%1);
Directory.CreateDirectory(path + Path.GetFileName(%%1));
DirectoryInfo dir = new DirectoryInfo((%%1.LastIndexOf("\\") == %%1.Length - 1) ? %%1 : %%1 + "\\");
FileSystemInfo[] fileArr = dir.GetFileSystemInfos();
Queue Folders = new Queue(dir.GetFileSystemInfos());
while (Folders.Count > 0)
{
FileSystemInfo tmp = Folders.Dequeue();
FileInfo f = tmp as FileInfo;
if (b && f == null)
{
DirectoryInfo d = tmp as DirectoryInfo;
Directory.CreateDirectory(d.FullName.Replace((parent.LastIndexOf("\\") == parent.Length - 1) ? parent : parent + "\\", path));
foreach (FileSystemInfo fi in d.GetFileSystemInfos())
{
Folders.Enqueue(fi);
}
}
else
{
FileStream fs = new FileStream(f,FileMode.Open,FileAccess.Read);
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
byte [] md5byte = md5.ComputeHash(fs);
int i,j;
StringBuilder sb = new StringBuilder(16);
foreach (byte b in md5byte)
{
　 i = Convert.ToInt32(b);
　　 j = i >> 4;
　　 sb.Append(Convert.ToString(j,16));
　　 j = ((i << 4) & 0x00ff) >> 4;
　　 sb.Append(Convert.ToString(j,16));
}
string %%3=sb.ToString();
}
}

2011-01-09T14:50:00.000-05:00

1、IIS下301设置

Internet信息服务管理器 -> 虚拟目录 -> 重定向到URL，输入需要转向的目标URL，并选择“资源的永久重定向”。

2、ASP下的301转向代码

<%@ Language=VBScript %>
<%
Response.Status=”301 Moved Permanently”
Response.AddHeader “Location”, “http://www.lesishu.cn/articles/301/”
%>

3、ASP.Net下的301转向代码

<script runat=”server”>
private void Page_Load(object sender, System.EventArgs e)
{
Response.Status = “301 Moved Permanently”;
Response.AddHeader(”Location”,”http://www.lesishu.cn/articles/301/“);
}
</script>

4、PHP下的301转向代码

header(”HTTP/1.1 301 Moved Permanently”);
header(”Location: http://www.lesishu.cn/articles/301/”);
exit();

5、CGI Perl下的301转向代码

$q = new CGI;
print $q->redirect(”http://www.new-url.com/”);

6、JSP下的301转向代码

<%
response.setStatus(301);
response.setHeader( “Location”, “http://www.lesishu.cn/” );
response.setHeader( “Connection”, “close” );
%>

7、Apache下301转向代码

新建.htaccess文件，输入下列内容（需要开启mod_rewrite）：

1）将不带WWW的域名转向到带WWW的域名下

Options +FollowSymLinks
RewriteEngine on
RewriteCond %{HTTP_HOST} ^lesishu.cn [NC]
RewriteRule ^(.*)$ http://www.lesishu.cn/$1 [L,R=301]

2）重定向到新域名

Options +FollowSymLinks
RewriteEngine on
RewriteRule ^(.*)$ http://www.lesishu.cn/$1 [L,R=301]

3）使用正则进行301转向，实现伪静态

Options +FollowSymLinks
RewriteEngine on
RewriteRule ^news-(.+)\.html$ news.php?id=$1

将news.php?id=123这样的地址转向到news-123.html

8、Apache下vhosts.conf中配置301转向

为实现URL规范化，SEO通常将不带WWW的域名转向到带WWW域名，vhosts.conf中配置为：

<VirtualHost *:80>
ServerName www.lesishu.cn
DocumentRoot /home/lesishu
</VirtualHost>

<VirtualHost *:80>
ServerName lesishu.cn
RedirectMatch permanent ^/(.*) http://www.lesishu.cn/$1
</VirtualHost>

Apache下除了以上2种方法，还有其他配置方法和可选参数，建议阅读Apache文档。

301转向情况检测

1. http://www.seoconsultants.com/tools/headers.asp
2. http://www.internetofficer.com/seo-tool/redirect-check/

JS获取浏览器窗口大小

2010-11-18T21:55:00.000-05:00

网页可见区域宽：document.body.clientWidth
网页可见区域高：document.body.clientHeight
网页可见区域宽：document.body.offsetWidth (包括边线的宽)
网页可见区域高：document.body.offsetHeight (包括边线的宽)
网页正文全文宽：document.body.scrollWidth
网页正文全文高：document.body.scrollHeight
网页被卷去的高：document.body.scrollTop
网页被卷去的左：document.body.scrollLeft
网页正文部分上：window.screenTop
网页正文部分左：window.screenLeft
屏幕分辨率的高：window.screen.height
屏幕分辨率的宽：window.screen.width
屏幕可用工作区高度：window.screen.availHeight
屏幕可用工作区宽度：window.screen.availWidth

HTML精确定位:scrollLeft,scrollWidth,clientWidth,offsetWidth
scrollHeight: 获取对象的滚动高度。
scrollLeft:设置或获取位于对象左边界和窗口中目前可见内容的最左端之间的距离
scrollTop:设置或获取位于对象最顶端和窗口中可见内容的最顶端之间的距离
scrollWidth:获取对象的滚动宽度
offsetHeight:获取对象相对于版面或由父坐标 offsetParent 属性指定的父坐标的高度
offsetLeft:获取对象相对于版面或由 offsetParent 属性指定的父坐标的计算左侧位置
offsetTop:获取对象相对于版面或由 offsetTop 属性指定的父坐标的计算顶端位置
event.clientX 相对文档的水平座标
event.clientY 相对文档的垂直座标
event.offsetX 相对容器的水平坐标
event.offsetY 相对容器的垂直坐标
document.documentElement.scrollTop 垂直方向滚动的值
event.clientX+document.documentElement.scrollTop 相对文档的水平座标+垂直方向滚动的量

IE，FireFox 差异如下：

IE6.0、FF1.06+：

clientWidth = width + padding

clientHeight = height + padding

offsetWidth = width + padding + border

offsetHeight = height + padding + border

IE5.0/5.5：
clientWidth = width - border

clientHeight = height - border

offsetWidth = width

offsetHeight = height

(需要提一下：CSS中的margin属性，与clientWidth、offsetWidth、clientHeight、offsetHeight均无关)

网页可见区域宽： document.body.clientWidth
网页可见区域高： document.body.clientHeight
网页可见区域宽： document.body.offsetWidth (包括边线的宽)
网页可见区域高： document.body.offsetHeight (包括边线的高)
网页正文全文宽： document.body.scrollWidth
网页正文全文高： document.body.scrollHeight
网页被卷去的高： document.body.scrollTop
网页被卷去的左： document.body.scrollLeft
网页正文部分上： window.screenTop
网页正文部分左： window.screenLeft
屏幕分辨率的高： window.screen.height
屏幕分辨率的宽： window.screen.width
屏幕可用工作区高度： window.screen.availHeight
屏幕可用工作区宽度： window.screen.availWidth

－－－－－－－－－－－－－－－－－－－

技术要点
本节代码主要使用了Document对象关于窗口的一些属性，这些属性的主要功能和用法如下。

要得到窗口的尺寸，对于不同的浏览器，需要使用不同的属性和方法：若要检测窗口的真实尺寸，在Netscape下需要使用Window的属性；在IE下需要深入Document内部对body进行检测；在DOM环境下，若要得到窗口的尺寸，需要注意根元素的尺寸，而不是元素。

Window对象的innerWidth属性包含当前窗口的内部宽度。Window对象的innerHeight属性包含当前窗口的内部高度。

Document对象的body属性对应HTML文档的标签。Document对象的documentElement属性则表示HTML文档的根节点。

document.body.clientHeight表示HTML文档所在窗口的当前高度。document.body. clientWidth表示HTML文档所在窗口的当前宽度。

< !DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
       <html xmlns="http://www.w3.org/1999/xhtml">
       <head>
       <title>请调整浏览器窗口</title>
       <meta http-equiv="content-type" content="text/html; charset=gb2312">

       </meta></head>
       <body>
       <h2 align="center">请调整浏览器窗口大小</h2><hr />
       <form action="#" method="get" name="form1" id="form1">
       <!--显示浏览器窗口的实际尺寸-->

       浏览器窗口 的 实际高度: <input type="text" name="availHeight" size="4"/><br />
       浏览器窗口 的 实际宽度: <input type="text" name="availWidth" size="4"/><br />
       </form>
       <script type="text/javascript">
       <!--
       var winWidth = 0;
       var winHeight = 0;
       function findDimensions() //函数：获取尺寸
       {
       //获取窗口宽度
       if (window.innerWidth)
       winWidth = window.innerWidth;
       else if ((document.body) && (document.body.clientWidth))
       winWidth = document.body.clientWidth;
       //获取窗口高度
       if (window.innerHeight)
       winHeight = window.innerHeight;
       else if ((document.body) && (document.body.clientHeight))
       winHeight = document.body.clientHeight;
       //通过深入Document内部对body进行检测，获取窗口大小
       if (document.documentElement  && document.documentElement.clientHeight && document.documentElement.clientWidth)
       {
       winHeight = document.documentElement.clientHeight;
       winWidth = document.documentElement.clientWidth;
       }
       //结果输出至两个文本框
       document.form1.availHeight.value= winHeight;
       document.form1.availWidth.value= winWidth;
       }
       findDimensions();
       //调用函数，获取数值
       window.onresize=findDimensions;
   

       //-->
       </script>
       </body>
       </html>

源程序解读

（1）程序首先建立一个表单，包含两个文本框，用于显示窗口当前的宽度和高度，并且，其数值会随窗口大小的改变而变化。

（2）在随后的JavaScript代码中，首先定义了两个变量winWidth和winHeight，用于保存窗口的高度值和宽度值。

（3）然后，在函数findDimensions ( )中，使用window.innerHeight和window.innerWidth得到窗口的高度和宽度，并将二者保存在前述两个变量中。

（4）再通过深入Document内部对body进行检测，获取窗口大小，并存储在前述两个变量中。

（5）在函数的最后，通过按名称访问表单元素，结果输出至两个文本框。

（6）在JavaScript代码的最后，通过调用findDimensions ( )函数，完成整个操作。

Create CSS Rounded Corners by css or images

2010-09-19T18:58:00.000-04:00

There are several good resources teach how to create rounded corners by css and images.

1. Google Rounded Corners Generator

http://groups-beta.google.com/groups/roundedcorners? c=999999&bc=white&w=4&h=4&a=tr

2. Spiffy Corners

http://www.spiffycorners.com/sc.php?sc=spiffy&bg=ffffff&fg=0a67e6

3. Cornershop

http://wigflip.com/cornershop/

They can generate css source code and images based on your demand. Really useful.

关于C#小数位数

2010-08-25T16:07:00.000-04:00

1.简单的例子

System.Globalization.NumberFormatInfo provider = new System.Globalization.NumberFormatInfo();

provider.NumberDecimalDigits =intDecLength; //要設定的小數位數

double strCashAmt=Convert.ToDouble(this.txtCashAmt.Text); //先把控件內的值轉成double

this.txtCashAmt.Text = strCashAmt.ToString("N",provider); //再利用ToString函數格式化小數位數

2.C#保留小数位N位,四舍五入 .

decimal d= decimal.Round(decimal.Parse("0.55555"),2);

3.C#保留小数位N位四舍五入

Math.Round(0.55555,2)

4,C#保留小数位N位四舍五入

double dbdata = 0.55555;

string str1 = dbdata.ToString("f2");//fN 保留N位，四舍五入

5.C#保留小数位N位四舍五入

string result = String.Format("{0:N2}", 0.55555);//2位

string result = String.Format("{0:N3}", 0.55555);//3位

6. C#保留小数位N位四舍五入

double s=0.55555;

result=s.ToString("#0.00");//点后面几个0就保留几位

C#保留小数位数，及百分号的解决方法:

1、用NumberFormatInfo类来解决:

System.Globalization.NumberFormatInfo provider = new System.Globalization.NumberFormatInfo();

provider.PercentDecimalDigits = 2;//小数点保留几位数.

provider.PercentPositivePattern = 2;//百分号出现在何处.

double result = (double)1 / 3;//一定要用double类型.

Response.Write(result.ToString("P", provider));

2、用toString方法.:

public string getRate(double hcount, double task)

{

string rValue;

string temp = "";

if (task == 0)

{

task = 1;

}

double db = (hcount / task) * 100;

if (hcount >= task)

{

rValue = "100%";

}

else

{

rValue = db.ToString("#0.#0") + "%";

}

return rValue;

}

string str1 = String.Format("{0:N1}",56789); //result: 56,789.0

string str2 = String.Format("{0:N2}",56789); //result: 56,789.00

string str3 = String.Format("{0:N3}",56789); //result: 56,789.000

string str8 = String.Format("{0:F1}",56789); //result: 56789.0

string str9 = String.Format("{0:F2}",56789); //result: 56789.00

string str11 =(56789 / 100.0).ToString("#.##"); //result: 567.89

string str12 =(56789 / 100).ToString("#.##"); //result: 567

Install solr in windows tomcat

2010-08-16T23:45:00.000-04:00

1. download solr like apache-solr-1.4.1
2. download tomcat 5.5 or above
3. Install tomcat
4. Extract apache-solr-1.4.1 package to anywhere
5. Copy apache-solr-1.4.1\dist\apache-solr-1.4.1.war to Tomcat webapps folder, for instance: Tomcat 5.5\webapps
6. Start tomcat and get: Tomcat 5.5\webapps\apache-solr-1.4.1 directory
7. Stop tomcat, open Tomcat 5.5\webapps\solr\WEB-INF\web.xml and copy below

<env-entry>
<env-entry-name>solr/home</env-entry-name>
<env-entry-value>C:\solr</env-entry-value>
<env-entry-type>java.lang.String</env-entry-type>
</env-entry>

to replace the old.
8. Zip apache-solr-1.4.1 and rename to solr.zip
9. Delete Tomcat 5.5\webapps\apache-solr-1.4.1 directory
10. Copy apache-solr-1.4.1\example\solr folder to c:
11. restart tomcat

That's it.

SQL Server Express Connection String

2010-08-02T21:52:00.000-04:00

1. Working with SQL Client:
1.1 NameSpace: System.Data.SqlClient;
1.2 Objects: DataSet dataSet;
SqlConnection conn;
SqlDataAdapter dbAdapter;
1.3 Connection Strings:

1.3.1 Using Windows Authentication Mode of Connectivity:
string conString = "Server=.\\SQLEXPRESS;" +
"DataBase=yourDatabase;" +
"Integrated Security=SSPI;";

1.3.2 Using SQL Server Authentication Mode of Connectivity:
string conString = "Server=.\\SQLEXPRESS;" +
"DataBase=yourDatabase;" +
"Uid=yourUserId;Pwd=yourPassword;";

2. Working with OLEDB:
2.1 NameSpace: System.Data.OleDb;
2.2 Objects: DataSet dataSet;
OleDbConnection conn;
OleDbDataAdapter dbAdapter;
2.3 Connection Strings:

2.3.1 Using Windows Authentication Mode of Connectivity:
string conString = "Provider=SQLOLEDB;" +
"Data Source=.\\SQLEXPRESS;" +
"Initial Catalog=yourDataBase;" +
"Integrated Security=SSPI;";

2.3.2 Using SQL Server Authentication Mode of Connectivity:
string conString = "Provider=SQLOLEDB;" +
"Data Source=.\\SQLEXPRESS;" +
"Initial Catalog=yourDataBase;" +
"Uid = yourUserId; Pwd = yourPassword;";

xml operation

2010-08-02T15:03:00.000-04:00

<p>用的是一种很笨的方法，但可以帮助初学者了解访问XML节点的过程。

已知有一个XML文件（bookstore.xml）如下：

</p><table rules="none" align="center" bgcolor="#ddedfb" border="1" bordercolor="#55aaff" cellpadding="0" cellspacing="0" width="500"> <tbody> <tr> <td width="10">
</td> <td> <p><?xml version="1.0" encoding="gb2312"?>
<bookstore>
<book genre="fantasy" isbn="2-3631-4">
<title>Oberon's Legacy</title>
<author>Corets, Eva</author>
<price>5.95</price>
</book>
</bookstore>
</p> </td> </tr> </tbody> </table> <p>

1、往<bookstore>节点中插入一个<book>节点：

</p> <p> </p><table rules="none" align="center" bgcolor="#ddedfb" border="1" bordercolor="#55aaff" cellpadding="0" cellspacing="0" width="500"> <tbody> <tr> <td width="10">
</td> <td> <p> XmlDocument xmlDoc=new XmlDocument();
xmlDoc.Load("bookstore.xml");
XmlNode root=xmlDoc.SelectSingleNode("bookstore");//查找<bookstore>
XmlElement xe1=xmlDoc.CreateElement("book");//创建一个<book>节点
xe1.SetAttribute("genre","李赞红");//设置该节点genre属性
xe1.SetAttribute("ISBN","2-3631-4");//设置该节点ISBN属性

XmlElement xesub1=xmlDoc.CreateElement("title");
xesub1.InnerText="CS从入门到精通";//设置文本节点
xe1.AppendChild(xesub1);//添加到<book>节点中
XmlElement xesub2=xmlDoc.CreateElement("author");
xesub2.InnerText="候捷";
xe1.AppendChild(xesub2);
XmlElement xesub3=xmlDoc.CreateElement("price");
xesub3.InnerText="58.3";
xe1.AppendChild(xesub3);

root.AppendChild(xe1);//添加到<bookstore>节点中
xmlDoc.Save("bookstore.xml");
</p> </td> </tr> </tbody> </table> <p>
//================
结果为：

</p> <p> </p><table rules="none" align="center" bgcolor="#ddedfb" border="1" bordercolor="#55aaff" cellpadding="0" cellspacing="0" width="500"> <tbody> <tr> <td width="10">
</td> <td> <p><?xml version="1.0" encoding="gb2312"?>
<bookstore>
<book genre="fantasy" isbn="2-3631-4">
<title>Oberon's Legacy</title>
<author>Corets, Eva</author>
<price>5.95</price>
</book>
<book genre="李赞红" isbn="2-3631-4">
<title>CS从入门到精通</title>
<author>候捷</author>
<price>58.3</price>
</book>
</bookstore>
</p> </td> </tr> </tbody> </table> <p>
2、修改节点：将genre属性值为“李赞红“的节点的genre值改为“update李赞红”，将该节点的子节点<author>的文本修改为“亚胜”。

</p><table rules="none" align="center" bgcolor="#ddedfb" border="1" bordercolor="#55aaff" cellpadding="0" cellspacing="0" width="500"> <tbody> <tr> <td width="10">
</td> <td> <p> XmlNodeList nodeList=xmlDoc.SelectSingleNode("bookstore").ChildNodes;//获取bookstore节点的所有子节点
foreach(XmlNode xn in nodeList)//遍历所有子节点
{
XmlElement xe=(XmlElement)xn;//将子节点类型转换为XmlElement类型
if(xe.GetAttribute("genre")=="李赞红")//如果genre属性值为“李赞红”
{
xe.SetAttribute("genre","update李赞红");//则修改该属性为“update李赞红”

XmlNodeList nls=xe.ChildNodes;//继续获取xe子节点的所有子节点
foreach(XmlNode xn1 in nls)//遍历
{
XmlElement xe2=(XmlElement)xn1;//转换类型
if(xe2.Name=="author")//如果找到
{
xe2.InnerText="亚胜";//则修改
break;//找到退出来就可以了
}
}
break;
}
}

xmlDoc.Save("bookstore.xml");//保存。
</p> </td> </tr> </tbody> </table>

//=================

最后结果为：

<table rules="none" align="center" bgcolor="#ddedfb" border="1" bordercolor="#55aaff" cellpadding="0" cellspacing="0" width="500"> <tbody> <tr> <td width="10">
</td> <td> <p><?xml version="1.0" encoding="gb2312"?>
<bookstore>
<book genre="fantasy" isbn="2-3631-4">
<title>Oberon's Legacy</title>
<author>Corets, Eva</author>
<price>5.95</price>
</book>
<book genre="update李赞红" isbn="2-3631-4">
<title>CS从入门到精通</title>
<author>亚胜</author>
<price>58.3</price>
</book>
</bookstore>
</p> </td> </tr> </tbody> </table>

3、删除 <book genre="fantasy" isbn="2-3631-4">节点的genre属性，删除 <book genre="update李赞红" isbn="2-3631-4">节点。

<table rules="none" align="center" bgcolor="#ddedfb" border="1" bordercolor="#55aaff" cellpadding="0" cellspacing="0" width="500"> <tbody> <tr> <td width="10">
</td> <td> <p>XmlNodeList xnl=xmlDoc.SelectSingleNode("bookstore").ChildNodes;

foreach(XmlNode xn in xnl)
{
XmlElement xe=(XmlElement)xn;</p> </td> </tr> </tbody> </table>
if(xe.GetAttribute("genre")=="fantasy")
{
xe.RemoveAttribute("genre");//删除genre属性
}
else if(xe.GetAttribute("genre")=="update李赞红")
{
xe.RemoveAll();//删除该节点的全部内容
}
}
xmlDoc.Save("bookstore.xml");

//====================

最后结果为：

<table rules="none" align="center" bgcolor="#ddedfb" border="1" bordercolor="#55aaff" cellpadding="0" cellspacing="0" width="500"> <tbody> <tr> <td width="10">
</td> <td><?xml version="1.0" encoding="gb2312"?>
<bookstore>
<book isbn="2-3631-4">
<title>Oberon's Legacy</title>
<author>Corets, Eva</author>
<price>5.95</price>
</book>
<book>
</book>
</bookstore></td> </tr> </tbody> </table>

4、显示所有数据。

<table rules="none" align="center" bgcolor="#ddedfb" border="1" bordercolor="#55aaff" cellpadding="0" cellspacing="0" width="500"> <tbody> <tr> <td width="10">
</td> <td> <p> XmlNode xn=xmlDoc.SelectSingleNode("bookstore");

XmlNodeList xnl=xn.ChildNodes;

foreach(XmlNode xnf in xnl)
{
XmlElement xe=(XmlElement)xnf;
Console.WriteLine(xe.GetAttribute("genre"));//显示属性值
Console.WriteLine(xe.GetAttribute("ISBN"));

XmlNodeList xnf1=xe.ChildNodes;
foreach(XmlNode xn2 in xnf1)
{
Console.WriteLine(xn2.InnerText);//显示子节点点文本
}
} </p> </td> </tr> </tbody> </table> <p> </p> <p>
转载自:http://blog.csdn.net/s98/archive/2004/10/17/140307.aspx

XmlDocument xmlDoc=new XmlDocument();
xmlDoc.Load("c:/aaa.xml");
XmlNode xn=xmlDoc.SelectSingleNode("todate");
XmlNodeList xnl=xn.ChildNodes;
foreach(XmlNode xnf in xnl)
{
XmlElement xe=(XmlElement)xnf;

XmlNodeList xnf1=xe.ChildNodes;

Response.Write(xnf1[0].InnerText);//显示子节点点文本
} </p> <p> XmlDocument xmlDoc=new XmlDocument();
xmlDoc.Load("c:/aaa.xml");
XmlNode xn=xmlDoc.SelectSingleNode("todate");
XmlNodeList xnl=xn.ChildNodes;
foreach(XmlNode xnf in xnl)
{
XmlElement xe=(XmlElement)xnf;

XmlNodeList xnf1=xe.ChildNodes;

xnf1[0].InnerText="10";
xmlDoc.Save("c:/aaa.xml");</p>

一些常用的正则表达式

2010-06-10T17:07:00.000-04:00

正则表达式用于字符串处理，表单验证等场合，实用高效，但用到时总是不太把握，以致往往要上网查一番。我将一些常用的表达式收藏在这里，作备忘之用。本贴随时会更新。

匹配中文字符的正则表达式： [\u4e00-\u9fa5]

匹配双字节字符(包括汉字在内)：[^\x00-\xff]

应用：计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）

String.prototype.len=function(){return this.replace([^\x00-\xff]/g,”aa”).length;}

匹配空行的正则表达式：\n[\s ]*\r

匹配HTML标记的正则表达式：/<(.*)>.*<\/\1><(.*) \/>/

匹配首尾空格的正则表达式：(^\s*)(\s*$)

应用：javascript中没有像vbscript那样的trim函数，我们就可以利用这个表达式来实现，如下：

String.prototype.trim = function()
{
return this.replace(/(^\s*)(\s*$)/g, “”);
}

利用正则表达式分解和转换IP地址：

下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascript程序：

function IP2V(ip)
{
re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //匹配IP地址的正则表达式
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
throw new Error(“Not a valid IP address!”)
}
}

不过上面的程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下：

var ip=”10.100.20.168″
ip=ip.split(“.”)
alert(“IP值是：”+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))

匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

匹配网址URL的正则表达式：http://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?

利用正则表达式去除字串中重复的字符的算法程序：[注：此程序不正确，原因见本贴回复]

var s=”abacabefgeeii”
var s1=s.replace(/(.).*\1/g,”$1″)
var re=new RegExp(“["+s1+"]“,”g”)
var s2=s.replace(re,”")
alert(s1+s2) //结果为：abcefgi

我原来在CSDN上发贴寻求一个表达式来实现去除重复字符的方法，最终没有找到，这是我能想到的最简单的实现方法。思路是使用后向引用取出包括重复的字符，再以重复的字符建立第二个表达式，取到不重复的字符，两者串连。这个方法对于字符顺序有要求的字符串可能不适用。

得用正则表达式从URL地址中提取文件名的javascript程序，如下结果为page1

s=”http://www.9499.net/page1.htm”
s=s.replace(/(.*\/){0,}([^\.]+).*/ig,”$2″)
alert(s)

利用正则表达式限制网页表单里的文本框输入内容：

用正则表达式限制只能输入中文：onkeyup=”value=value.replace(/[^\u4E00-\u9FA5]/g,”)” onbeforepaste=”clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^\u4E00-\u9FA5]/g,”))”

用正则表达式限制只能输入全角字符： onkeyup=”value=value.replace(/[^\uFF00-\uFFFF]/g,”)” onbeforepaste=”clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^\uFF00-\uFFFF]/g,”))”

用正则表达式限制只能输入数字：onkeyup=”value=value.replace(/[^\d]/g,”) “onbeforepaste=”clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^\d]/g,”))”

用正则表达式限制只能输入数字和英文：onkeyup=”value=value.replace(/[\W]/g,”) “onbeforepaste=”clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^\d]/g,”))”

正则表达式，相关链接
http://blog.csdn.net/laily/category/19548.aspx
http://blog.csdn.net/laily/archive/2004/06/30/30525.aspx 微软的正则表达式教程（五）：选择/编组和后向引用

http://blog.csdn.net/laily/archive/2004/06/30/30522.aspx 微软的正则表达式教程（四）：限定符和定位符

http://blog.csdn.net/laily/archive/2004/06/30/30517.aspx 微软的正则表达式教程（三）：字符匹配

http://blog.csdn.net/laily/archive/2004/06/30/30514.aspx 微软的正则表达式教程（二）：正则表达式语法和优先权顺序

http://blog.csdn.net/laily/archive/2004/06/30/30511.aspx 微软的正则表达式教程（一）：正则表达式简介

http://blog.csdn.net/laily/archive/2004/06/30/30360.aspx 小程序大作为：高级查找/替换、正则表达式练习器、Javascript脚本程序调试器

http://blog.csdn.net/laily/archive/2004/06/24/25872.aspx 经典正则表达式

正则表达式，正规表达式，正则表达式匹配，正则表达式语法，模式匹配，正规表达式匹配 javascript正则表达式 ASP正则表达式 ASP.NET正则表达式 C#正则表达式 JSP正则表达式 PHP正则表达式 VB.NET正则表达式 VBSCript正则表达式编程 delphi正则表达式 jscript

补充：
^\d+$　　//匹配非负整数（正整数 + 0）
^[0-9]*[1-9][0-9]*$　　//匹配正整数
^((-\d+)(0+))$　　//匹配非正整数（负整数 + 0）
^-[0-9]*[1-9][0-9]*$　　//匹配负整数
^-?\d+$　　　　//匹配整数
^\d+(\.\d+)?$　　//匹配非负浮点数（正浮点数 + 0）
^(([0-9]+\.[0-9]*[1-9][0-9]*)([0-9]*[1-9][0-9]*\.[0-9]+)([0-9]*[1-9][0-9]*))$　　//匹配正浮点数
^((-\d+(\.\d+)?)(0+(\.0+)?))$　　//匹配非正浮点数（负浮点数 + 0）
^(-(([0-9]+\.[0-9]*[1-9][0-9]*)([0-9]*[1-9][0-9]*\.[0-9]+)([0-9]*[1-9][0-9]*)))$　　//匹配负浮点数
^(-?\d+)(\.\d+)?$　　//匹配浮点数
^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串
^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串
^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串
^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串
^\w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串
^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$　　　　//匹配email地址
^[a-zA-z]+://匹配(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$　　//匹配url
利用正则表达式去除字串中重复的字符的算法程序：

var s=”abacabefgeeii”
var s1=s.replace(/(.).*\1/g,”$1″)
var re=new RegExp(“["+s1+"]“,”g”)
var s2=s.replace(re,”")
alert(s1+s2) //结果为：abcefgi
===============================
如果var s = “abacabefggeeii”
结果就不对了，结果为：abeicfgg
正则表达式的能力有限
1.确认有效电子邮件格式
下面的代码示例使用静态 Regex.IsMatch 方法验证一个字符串是否为有效电子邮件格式。如果字符串包含一个有效的电子邮件地址，则 IsValidEmail 方法返回 true，否则返回 false，但不采取其他任何操作。您可以使用 IsValidEmail，在应用程序将地址存储在数据库中或显示在 ASP.NET 页中之前，筛选出包含无效字符的电子邮件地址。

[Visual Basic]
Function IsValidEmail(strIn As String) As Boolean
‘ Return true if strIn is in valid e-mail format.
Return Regex.IsMatch(strIn, (“^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)(([\w-]+\.)+))([a-zA-Z]{2,4}[0-9]{1,3})(\]?)$”)
End Function
[C#]
bool IsValidEmail(string strIn)
{
// Return true if strIn is in valid e-mail format.
return Regex.IsMatch(strIn, @”^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)(([\w-]+\.)+))([a-zA-Z]{2,4}[0-9]{1,3})(\]?)$”);
}

2.清理输入字符串
下面的代码示例使用静态 Regex.Replace 方法从字符串中抽出无效字符。您可以使用这里定义的 CleanInput 方法，清除掉在接受用户输入的窗体的文本字段中输入的可能有害的字符。CleanInput 在清除掉除 @、-（连字符）和 .（句点）以外的所有非字母数字字符后返回一个字符串。

[Visual Basic]
Function CleanInput(strIn As String) As String
‘ Replace invalid characters with empty strings.
Return Regex.Replace(strIn, “[^\w\.@-]“, “”)
End Function
[C#]
String CleanInput(string strIn)
{
// Replace invalid characters with empty strings.
return Regex.Replace(strIn, @”[^\w\.@-]“, “”);
}

3.更改日期格式
以下代码示例使用 Regex.Replace 方法来用 dd-mm-yy 的日期形式代替 mm/dd/yy 的日期形式。

[Visual Basic]
Function MDYToDMY(input As String) As String
Return Regex.Replace(input, _
“\b(?\d{1,2})/(?\d{1,2})/(?\d{2,4})\b”, _
“${day}-${month}-${year}”)
End Function
[C#]
String MDYToDMY(String input)
{
return Regex.Replace(input,
“\\b(?\\d{1,2})/(?\\d{1,2})/(?\\d{2,4})\\b”,
“${day}-${month}-${year}”);
}
Regex 替换模式
本示例说明如何在 Regex.Replace 的替换模式中使用命名的反向引用。其中，替换表达式 ${day} 插入由 (?…) 组捕获的子字符串。

有几种静态函数使您可以在使用正则表达式操作时无需创建显式正则表达式对象，而 Regex.Replace 函数正是其中之一。如果您不想保留编译的正则表达式，这将给您带来方便

4.提取 URL 信息
以下代码示例使用 Match.Result 来从 URL 提取协议和端口号。例如，“http://www.contoso.com:8080/letters/readme.html”将返回“http:8080”。

[Visual Basic]
Function Extension(url As String) As String
Dim r As New Regex(“^(?\w+)://[^/]+?(?:\d+)?/”, _
RegexOptions.Compiled)
Return r.Match(url).Result(“${proto}${port}”)
End Function
[C#]
String Extension(String url)
{
Regex r = new Regex(@”^(?\w+)://[^/]+?(?:\d+)?/”,
RegexOptions.Compiled);
return r.Match(url).Result(“${proto}${port}”);
}

disable Axis2 soapAction

2010-01-20T18:32:00.000-05:00

Sometimes we want to disable soapAction of Axis2 to communicate .Net WCF webservice.

Add below in NetworkNode2Stub.java

//adding SOAP soap_headers
_serviceClient.addHeadersToEnvelope(env);
// set the message context with that soap envelope
_messageContext.setEnvelope(env);

// add the message contxt to the operation client
_operationClient.addMessageContext(_messageContext);

// Disable SOAP_ACTION to fix .Net endpoint without soapAction
_operationClient.getOptions().setProperty(

org.apache.axis2.Constants.Configuration.DISABLE_SOAP_ACTION,
org.apache.axis2.Constants.VALUE_TRUE);
//execute the operation client
_operationClient.execute(true);

Tomcat 5.X setup jndi

2010-01-08T18:50:00.000-05:00

1. Copy jdbc driver to Tomcat 5.X\common\lib
2. Romove all commons-dbcp-x.x.x,commons-pool-x.x and jdbc driver from application/WEB-INF/lib

3. Add Context and jndi parameters in server.xml file as below:

Tomcat 5.0.xx:
(the entity way) was the only way that worked.

[server.xml]:
<Service...>
<Engine...>
<Host...>
...
<Context crossContext="true" docBase="/opt/tomcat5/webapps/oracleTest" path="/oracleTest" reloadable="true">
<Resource name="jdbc/myoracle" auth="Container"
type="javax.sql.DataSource"/>
<ResourceParams name="jdbc/myoracle">
<parameter>
<name>factory</name>
<value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
</parameter>
<parameter>
<name>driverClassName</name>
<value>oracle.jdbc.OracleDriver</value>
</parameter>
<parameter>
<name>url</name>
<value>jdbc:oracle:thin:@15.1.1.40:1521:dbastra</value>
</parameter>
<parameter>
<name>username</name>
<value>uuuuuu</value>
</parameter>
<parameter>
<name>password</name>
<value>xxxxxxxx</value>
</parameter>
<parameter>
<name>maxActive</name>
<value>20</value>
</parameter>
<parameter>
<name>maxIdle</name>
<value>10</value>
</parameter>
<parameter>
<name>maxWait</name>
<value>-1</value>
</parameter>
</ResourceParams>
<Resource name="jdbc/myoracle5" auth="Container"
type="javax.sql.DataSource" />
</Context>
</Host>
</Engine>
</Service>

Tomcat 5.5.xx:
(the attributes way) was the only way that worked.

[server.xml]:
<Service...>
<Engine...>
<Host...>
...
<Context path="/oracleTest" reloadable="true"
docBase="/opt/tomcat5/webapps/oracleTest">

<Logger className="org.apache.catalina.logger.SystemOutLogger"
verbosity="4" timestamp="true" />

<Resource name="jdbc/myoracle5" auth="Container"
type="javax.sql.DataSource" driverClassName="oracle.jdbc.OracleDriver"
url="jdbc:oracle:thin:@15.1.1.40:1521:dbastra" username="aradmin"
password="ar#admin#" maxActive="20" maxIdle="10" maxWait="-1" />

</Context>
</Host>
</Engine>
</Service>

for BOTH versions:

Here there are some points we should take a look:

<Context> in [server.xml] !!
"Please note that for tomcat 5, unlike tomcat 4.x, it is NOT recommended to place <Context> elements directly in the server.xml file. Instead, put them in the META-INF/context.xml directory of your WAR file or the conf directory as described above."
http://tomcat.apache.org/tomcat-5.5-doc/config/context.html

And if we cut the <Context>..</Context> body we described above from the server.xml and paste it into [META-INF/context.xml] or into [conf/Catalina/localhost/oracleTest.xml], it works...

<?xml version='1.0' encoding='utf-8'?>
<Context crossContext="true" docBase="/forge/oracleTest" path="/oracleTest" reloadable="true">
<Logger className="org.apache.catalina.logger.FileLogger"
prefix="localhost_DBTest_log." suffix=".txt" timestamp="true" />

<Resource ... (the one that applies to your version)>

</Context>

GlobalNamingResources:
"GlobalNamingResources element defines the global JNDI resources for the Server. These resources are listed in the server's global JNDI resource context. This context is distinct from the per-web-application JNDI contexts described in the JNDI Resources HOW-TO. The resources defined in this element are not visible in the per-web-application contexts unless you explicitly link them with <ResourceLink> elements."
http://tomcat.apache.org/tomcat-5.5-doc/config/globalresources.html
http://tomcat.apache.org/tomcat-5.5-doc/config/context.html#Resource%20Links

Article From http://forums.sun.com/thread.jspa?threadID=567630&start=15

Parse Large xml using dom4j

2010-01-05T18:45:00.000-05:00

dom4j提供了基于事件的模型来操作xml文档。利用该模型开发人员可以一部分、一部分的处理XML文档，而不需要将整个XML文档都加载到内存中。例如：假想你要处理一个非常大的XML文档，它可能是由数据库的某张数据表而来的。如下所示：
<ROWSET>
<ROW ID="1">
...
</ROW>
<ROW ID="2">
...
</ROW>
...
<ROW ID="N">
...
</ROW>
</ROWSET>
我们可以在某一时间只处理一个ROW节点，而不必立刻将文档的所有内容加载到内存中。dom4j提供一个基于事件的模型来实现它。我们可以注册一个事件处理器来处理一个或多个路径表达式。事件处理器会在注册路径的开始和结束时被调用执行。当注册路径的开始标签找到时执行事件处理器的 onStart()方法，当注册路径的结束标签被找到时执行事件处理器的onEnd()方法。

onStart()和onEnd()方法传递一个ElementPath实例参数，这个实例既为根据注册路径遍历xml文档时的当前节点（Element）。如果想对遍历的当前节点进行操作，可以在onEnd()方法中对当前节点调用detach()方法保存改。
下面是示例代码：

SAXReader reader = new SAXReader();
reader.addHandler( "/ROWSET/ROW",
new ElementHandler() {
public void onStart(ElementPath path) {
// do nothing here...
}
public void onEnd(ElementPath path) {
// process a ROW element
Element row = path.getCurrent();
Element rowSet = row.getParent();
Document document = row.getDocument();
...
// prune the tree
row.detach();
}
}
);

Document document = reader.read(url);
上面的办法解决了读的问题可是写的问题还没有解决。我命由我不由天（吹牛皮），畅游dom4j的doc文档找到如下几个方法
startDocument()
writeOpen();
writeClose();
endDocument()
动手一试，问题搞定，看来牛皮没白吹。下面是示例代码：

/**
* 数据写入xml文件
* @param filePath 目标xml文件的存放路径
* @return
*/
public boolean writeXML(String filePath){
XMLWriter out;
try {

/*
* 创建XMLWriter对象，设置XML编码，解决中文问题。
*/
OutputFormat outputFormat = OutputFormat.createPrettyPrint();
outputFormat.setEncoding("GBK");
out = new XMLWriter(new FileWriter(filePath),outputFormat);

out.startDocument();
Element rootElement = DocumentHelper.createElement("mans");
out.writeOpen(rootElement);

/*
* 向mans节点写入子节点
*/
for(int i=0 ; i<1000000 ; i++){
Element man = createManElement(new Long(i), "shuhang"+i);//用于创建节点的方法
out.write(man);
System.out.println(" the loop index is : " + i);
}

out.writeClose(rootElement);
out.endDocument();

out.close();
return true;
} catch (IOException e) {
e.printStackTrace();
return false;
} catch (SAXException e) {
e.printStackTrace();
return false;
}
}

新问题出现。对于读取数据的方法，在onEnd()方法中只是进行对Element的简单操作而已，若要对Element进行复杂的处理怎么办，如将Element节点的数据写入数据库，无法在onEnd()方法中加入过多的代码，因为无法通过编译。仔细想了一下dom4j的注册事件处理器应该用的是模板方法，通过钩子将用户的操作加入到模板中去。何不自己写一个事件处理器来完成我们自己的定制操作，代码如下：

public class ManElementHandler implements ElementHandler {
public String mdbName;

public ManElementHandler(){

}

public ManElementHandler(String mdbName){
this.mdbName = mdbName;
}

public boolean saveMan(Element element, String mdbName){
return true;
}

public void onEnd(ElementPath arg0) {
Element row = arg0.getCurrent();
Element rowSet = row.getParent();
Document document = row.getDocument();
Element root = document.getRootElement();
Iterator it = root.elementIterator();
while(it.hasNext()){
Element element = (Element)it.next();
System.out.println(" id : " + element.elementText("id") + " name : " + element.elementText("name"));
saveMan(element, this.mdbName);
}
row.detach();
}
public void onStart(ElementPath path) {

}
}

下面给出完整的实例代码。该实例首先创建一个xml文档，然后读取xml文档中的数据并将数据写入Access数据库中。测试时使用的文件大小为125M未发生内存溢出。

//*****************************************************************************************************************
package com;
import java.sql.Connection;
import java.sql.DriverManager;
/**
* 获取Access数据库的连接
* @author 佛山无影脚
* @version 1.0
* Jul 7, 2008 4:35:49 PM
*/
public class AccessMDBUtil {
public static Connection connectMdb(String mdbName) {
if(mdbName == null mdbName.equals("")){
return null;
}
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
String dburl ="jdbc:odbc:driver={Microsoft Access Driver (*.mdb)};DBQ="+mdbName;
Connection conn=DriverManager.getConnection(dburl);
return conn;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}
//*******************************************************************************************************************
//*******************************************************************************************************************
package com;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.ElementPath;
/**
* 定制的事件处理器
* @author 佛山无影脚
* @version 1.0
* Jul 7, 2008 4:35:49 PM
*/
public class ManElementHandler implements ElementHandler {
public String mdbName;//数据库名称含路径

public ManElementHandler(){

}

public ManElementHandler(String mdbName){
this.mdbName = mdbName;
}

/**
*将Element节点数据保存到数据库
*@param element 遍历XML文档时的当前节点
*@param mdbName 数据库名称含路径
*@return
*/
public boolean saveMan(Element element, String mdbName){
System.out.println(" the method saveMan in ManElementHandler is execute!");
Statement stmt = null;
ResultSet rs = null;
Connection conn = null;
try {
conn= AccessMDBUtil.connectMdb(mdbName);
stmt=conn.createStatement();
String sql = "insert into mans(id,name) values(" + element.elementText("id") + ",'" + element.elementText("name") + "')";
stmt.executeUpdate(sql);

} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
if(rs != null) {
try {
rs.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(conn != null) {
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

return true;
}

public void onEnd(ElementPath arg0) {
Element row = arg0.getCurrent();
Element rowSet = row.getParent();
Document document = row.getDocument();
Element root = document.getRootElement();
Iterator it = root.elementIterator();
while(it.hasNext()){
Element element = (Element)it.next();
System.out.println(" id : " + element.elementText("id") + " name : " + element.elementText("name"));
saveMan(element, this.mdbName);
}
row.detach();
}
public void onStart(ElementPath path) {

}
}
//*************************************************************************************************************************
//*************************************************************************************************************************
package com;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
/**
* 测试
* @author 佛山无影脚
* @version 1.0
* Jul 7, 2008 4:35:49 PM
*/
public class ManTest {
/**
* 创建man节点
* <man><id>1</id><name>佛山无影脚</name></man>
* @param id
* @param name
* @return
*/
public Element createManElement(Long id,String name){
Element manElement = DocumentHelper.createElement("man");
manElement.addElement("id").addText(id.toString());
manElement.addElement("name").addText(name);
return manElement;
}

/**
* 数据写入xml文件
* @param filePath 目标xml文件的存放路径
* @return
*/
public boolean writeXML(String filePath){
XMLWriter out;
try {

/*
* 创建XMLWriter对象，设置XML编码，解决中文问题。
*/
OutputFormat outputFormat = OutputFormat.createPrettyPrint();
outputFormat.setEncoding("GBK");
out = new XMLWriter(new FileWriter(filePath),outputFormat);

out.startDocument();
Element rootElement = DocumentHelper.createElement("mans");
out.writeOpen(rootElement);

/*
* 向mans节点写入子节点
*/
for(int i=0 ; i<1000000 ; i++){
Element man = this.createManElement(new Long(i), "shuhang"+i);
out.write(man);
System.out.println(" the loop index is : " + i);
}

out.writeClose(rootElement);
out.endDocument();

out.close();
return true;
} catch (IOException e) {
e.printStackTrace();
return false;
} catch (SAXException e) {
e.printStackTrace();
return false;
}
}

/**
* 从xml文件中读取数据，并将数据写入Access数据
* @param filePath xml文件的存放路径
* @return
*/
public boolean readXML(String filePath){

ManElementHandler manElementHandler = new ManElementHandler("F:\\dom4j\\xmlTest.mdb");
SAXReader reader = new SAXReader();
reader.addHandler( "/mans/man", manElementHandler);
Document document = null;
try {
File file = new File(filePath);
document = reader.read(file);
} catch (DocumentException e) {
e.printStackTrace();
return false;
}
return true;
}

public static void main(String[] args){
XMLReader reader = null;
long startTime = System.currentTimeMillis();
ManTest mantest = new ManTest();

mantest.writeXML("f:\\dom4j\\mans.xml");
mantest.readXML("f:\\dom4j\\mans.xml");

long endTime = System.currentTimeMillis();
System.out.println(" is end! the millis is : " + (endTime - startTime));

}
}
//*************************************************************************************************************************

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/shuhang1106/archive/2008/07/09/2627581.aspx