发布新日志

  • 数据库两张表的比较

    2009-03-30 11:23:44

    在某些情况下，我们会需要比较两张表的数据是否一样。

    　　假设有两张表A与表B它们的字段相同，但是当中的数据可能不同，而且有些字段的数据还有可能为空。

    　　方法一(手动)：把需要比较的两张表的数据按照某种规则排序后导出为xls,这里我直接用PL/SQL Developer导出。

    　　然后用把xls文件转换成txt文件，这里我用的是batconv转换公式。

    　　现在我们就有了两个txt文件。

    　　然后用beyond compare文件比较器比较内容。

    　　优点：数据差异一目了然，缺点：比较费时。

    　　方法二(通过Sql语句来比较)：

    　　创建表的语句：

    create table formula(
    　　id varchar2(50) primary key--自动生成的，唯一的。
    　　formulaName varchar2(50),
    　　formulaContent varchar2(2000),
    　　formulaType varchar2(20),
    　　)

    　　当中除id不为空，其它三项均可能为空。

    　　一般情况下我们可以用

    select * from formula A where not exists (select * from formula B where A.formulaName=
    　　B.formulaName and A.formulaContent=B.formulaContent and A.formulaType=B.formulaType)

    　　在oracle 情况下如果两张表的某个字段都为null则其通过A.*=B.*是比较不出来的。

    　　因此要额外加上这样的判断

    or(A.formulaContent is null and B.formulaContent is null) or
    　　(A.fomrulaName is null and B.fomrulaName is null) or (A.formulaType is null and B.fomrulaType is null)

    　　通过上面这个sql语句我们就可以找在A表中存在，但在B表中不存在的数据

    　　反过来可以查询在B表中存在，但在A表中不存在的数据。

    　　若两个查询都为空，则说明两张表的相应字段完全相同。

    　　若这两张表在不同的数据库，则要通过建立DBLink。

    　　优点：数据比较快，特别是在数据量比较大的数据优势更加明显，

    　　缺点：比较时不能很快看出两张表的差异。因为查询的只是当中的某一张表。

    查看(268) 评论(0) 收藏 分享 管理

  • 存储过程常用技巧

    2009-03-30 10:52:36

    作者：袁光东
    我们在进行pl/sql编程时打交道最多的就是存储过程了。存储过程的结构是非常的简单的，我们在这里除了学习存储过程的基本结构外，还会学习编写存储过程时相关的一些实用的知识。如：游标的处理，异常的处理，集合的选择等等

    1.存储过程结构
    1.1 第一个存储过程
    Java代码 复制代码
    1. create or replace procedure proc1(   
    2.   p_para1 varchar2,   
    3.   p_para2 out varchar2,   
    4.   p_para3 in out varchar2   
    5. )as    
    6.  v_name varchar2(20);   
    7. begin   
    8.   v_name := '张三丰';   
    9.   p_para3 := v_name;   
    10.   dbms_output.put_line('p_para3:'||p_para3);   
    11. end;  


    上面就是一个最简单的存储过程。一个存储过程大体分为这么几个部分:
    创建语句：create or replace procedure 存储过程名
    如果没有or replace语句，则仅仅是新建一个存储过程。如果系统存在该存储过程，则会报错。Create or replace procedure 如果系统中没有此存储过程就新建一个，如果系统中有此存储过程则把原来删除掉，重新创建一个存储过程。
    存储过程名定义：包括存储过程名和参数列表。参数名和参数类型。参数名不能重复， 参数传递方式:IN, OUT, IN OUT
    IN 表示输入参数，按值传递方式。
    OUT 表示输出参数，可以理解为按引用传递方式。可以作为存储过程的输出结果，供外部调用者使用。
    IN OUT 即可作输入参数，也可作输出参数。
    参数的数据类型只需要指明类型名即可，不需要指定宽度。
    参数的宽度由外部调用者决定。
    过程可以有参数，也可以没有参数
    变量声明块：紧跟着的as (is )关键字，可以理解为pl/sql的declare关键字，用于声明变量。
    变量声明块用于声明该存储过程需要用到的变量，它的作用域为该存储过程。另外这里声明的变量必须指定宽度。遵循PL/SQL的变量声明规范。
    过程语句块：从begin 关键字开始为过程的语句块。存储过程的具体逻辑在这里来实现。
    异常处理块：关键字为exception ，为处理语句产生的异常。该部分为可选
    结束块：由end关键字结果。

    1.2 存储过程的参数传递方式
    存储过程的参数传递有三种方式:IN,OUT,IN OUT .
    IN 按值传递，并且它不允许在存储过程中被重新赋值。如果存储过程的参数没有指定存参数传递类型，默认为IN
    Java代码 复制代码
    1. create or replace procedure proc1(   
    2.   p_para1 varchar2,   
    3.   p_para2 out varchar2,   
    4.   p_para3 in out varchar2   
    5. )as    
    6.  v_name varchar2(20);   
    7. begin   
    8.   p_para1 :='aaa';   
    9.   p_para2 :='bbb';   
    10.   v_name := '张三丰';   
    11.   p_para3 := v_name;   
    12.   dbms_output.put_line('p_para3:'||p_para3);   
    13.   null;   
    14. end;   
    15.        
    16. Warning: Procedure created with compilation errors   
    17.   
    18. SQL> show error;   
    19. Errors for PROCEDURE LIFEMAN.PROC1:   
    20.   
    21. LINE/COL ERROR   
    22. -------- ----------------------------------------------------------------------   
    23. 8/3      PLS-00363: expression 'P_PARA1' cannot be used as an assignment target   
    24. 8/3      PL/SQL: Statement ignored  
    这一点与其它高级语言都不同。它相当于java在参数前面加上final关键字。


    OUT 参数：作为输出参数，需要注意，当一个参数被指定为OUT类型时，就算在调用存储过程之前对该参数进行了赋值，在存储过程中该参数的值仍然是null.
    Java代码 复制代码
    1. create or replace procedure proc1(   
    2.   p_para1 varchar2,   
    3.   p_para2 out varchar2,   
    4.   p_para3 in out varchar2   
    5. )as    
    6.  v_name varchar2(20);   
    7. begin   
    8.   v_name := '张三丰';   
    9.   p_para3 := v_name;   
    10.   dbms_output.put_line('p_para1:'||p_para1);   
    11.   dbms_output.put_line('p_para2:'||p_para2);   
    12.   dbms_output.put_line('p_para3:'||p_para3);   
    13. end;   
    14.   
    15. SQL> var p1 varchar2(10);   
    16. SQL> var p2 varchar2(10);   
    17. SQL> var p3 varchar2(10);   
    18. SQL> exec :p1 :='aaaa';   
    19. SQL> exec :p2 :='bbbb';   
    20. SQL> exec :p3 :='cccc';   
    21. SQL> exec proc1(:p1,:p2,:p3);   
    22. p_para1:aaaa   
    23. p_para2:   
    24. p_para3:张三丰   
    25. SQL> exec dbms_output.put_line(:p2);   
    26.   
    27.   
    28. PL/SQL procedure successfully completed   
    29. p2   
    30. ---------  

    INOUT 是真正的按引用传递参数。即可作为传入参数也可以作为传出参数。

    Java代码 复制代码
    1. 1.3 存储过程参数宽度   
    2. create or replace procedure proc1(   
    3.   p_para1 varchar2,   
    4.   p_para2 out varchar2,   
    5.   p_para3 in out varchar2   
    6. )as    
    7.  v_name varchar2(2);   
    8. begin   
    9.   v_name := p_para1;   
    10. end;   
    11.   
    12. SQL> var p1 varchar2(10);   
    13. SQL> var p2 varchar2(20);   
    14. SQL> var p3 varchar2(30);   
    15. SQL> exec :p1 :='aaaaaa';   
    16. SQL> exec proc1(:p1,:p2,:p3);   
    17.        
    18.        
    19. ORA-06502: PL/SQL: numeric or value error: character string buffer too small   
    20. ORA-06512: at "LIFEMAN.PROC1", line 8  
    21. ORA-06512: at line 1  

    首先，我们要明白，我们无法在存储过程的定义中指定存储参数的宽度，也就导致了我们无法在存储过程中控制传入变量的宽度。这个宽度是完全由外部传入时决定的。
    我们再来看看OUT类型的参数的宽度。
    Java代码 复制代码
    1. create or replace procedure proc1(   
    2.   p_para1 varchar2,   
    3.   p_para2 out varchar2,   
    4.   p_para3 in out varchar2   
    5. )as    
    6.  v_name varchar2(2);   
    7. begin   
    8.   p_para2 :='aaaaaaaaaaaaaaaaaaaa';   
    9. end;   
    10. SQL> var p1 varchar2(1);   
    11. SQL> var p2 varchar2(1);   
    12. SQL> var p3 varchar2(1);   
    13. SQL> exec :p2 :='a';   
    14. SQL> exec proc1(:p1,:p2,:p3);  
    在该过程中，p_para2被赋予了20个字符a.
    而在外部的调用过程中，p2这个参数仅仅被定义为varchar2(1).
    而把p2作为参数调用这个过程，却并没有报错。而且它的真实值就是20个a
    Java代码 复制代码
    1. SQL> select dump(:p2) from dual;   
    2. DUMP(:P2)   
    3. ---------------------------------------------------------------------------   
    4. Typ=1 Len=20: 97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97  
    5. p2   
    6. ---------   
    7. aaaaaaaaaaaaaaaaaaaa   
    8.        
    9.     再来看看IN OUT参数的宽度   
    10. create or replace procedure proc1(   
    11.   p_para1 varchar2,   
    12.   p_para2 out varchar2,   
    13.   p_para3 in out varchar2   
    14. )as    
    15.  v_name varchar2(2);   
    16. begin   
    17.   p_para3 :='aaaaaaaaaaaaaaaaaaaa';   
    18. end;   
    19.   
    20. SQL> var p1 varchar2(1);   
    21. SQL> var p2 varchar2(1);   
    22. SQL> var p3 varchar2(1);   
    23. SQL> exec proc1(:p1,:p2,:p3);  
    执行这个过程，仍然正确执行。

    可见，对于IN参数，其宽度是由外部决定。
    对于OUT 和IN OUT 参数，其宽度是由存储过程内部决定。
    因此，在写存储过程时，对参数的宽度进行说明是非常有必要的，最明智的方法就是参数的数据类型使用%type。这样双方就达成了一致。

    1.3 参数的默认值
    存储过程的参数可以设置默认值
    Java代码 复制代码
    1. create or replace procedure procdefault(p1 varchar2,   
    2.                                         p2 varchar2 default 'mark')   
    3. as    
    4. begin   
    5.   dbms_output.put_line(p2);   
    6. end;   
    7.   
    8. SQL> set serveroutput on;   
    9. SQL> exec procdefault('a');  
    mark
    可以通过default 关键字为存储过程的参数指定默认值。在对存储过程调用时，就可以省略默认值。
    需要注意的是：默认值仅仅支持IN传输类型的参数。OUT 和 IN OUT不能指定默认值

    对于有默认值的参数不是排在最后的情况。
    Java代码 复制代码
    1. create or replace procedure procdefault2(p1 varchar2 default 'remark',   
    2.                                         p2 varchar2 )   
    3. as    
    4. begin   
    5.   dbms_output.put_line(p1);   
    6. end;  
    第一个参数有默认值，第二个参数没有。如果我们想使用第一个参数的默认值时
    exec procdefault2('aa');
    这样是会报错的。
    那怎么变呢？可以指定参数的值。
    Java代码 复制代码
    1. SQL> exec procdefault2(p2 =>'aa');  

    remark
    这样就OK了，指定aa传给参数p2


    2. 存储过程内部块
    2.1 内部块
    我们知道了存储过程的结构，语句块由begin开始，以end结束。这些块是可以嵌套。在语句块中可以嵌套任何以下的块。
    Java代码 复制代码
    1. Declare … begin … exception … end;   
    2. create or replace procedure innerBlock(p1 varchar2)   
    3. as    
    4.   o1 varchar2(10) := 'out1';   
    5. begin   
    6.   dbms_output.put_line(o1);   
    7.   declare    
    8.     inner1 varchar2(20);   
    9.   begin   
    10.     inner1 :='inner1';   
    11.     dbms_output.put_line(inner1);   
    12.   
    13.     declare    
    14.       inner2 varchar2(20);   
    15.     begin   
    16.       inner2 := 'inner2';   
    17.       dbms_output.put_line(inner2);   
    18.     end;   
    19.   exception    
    20.     when others then   
    21.       null;   
    22.   end;   
    23. end;  
    需要注意变量的作用域。

    3.存储过程的常用技巧
    3.1 哪种集合?
    我们在使用存储过程的时候经常需要处理记录集，也就是多条数据记录。分为单列多行和多列多行，这些类型都可以称为集合类型。我们在这里进行比较这些集合类型，以便于在编程时做出正确的选择。
    索引表,也称为pl/sql表，不能存储于数据库中，元素的个数没有限制,下标可以为负值。
    Java代码 复制代码
    1. type t_table is table of varchar2(20) index by binary_integer;   
    2.  v_student t_table;  
    varchar2(20)表示存放元素的数据类型，binary_integer表示元素下标的数据类型。
    嵌套表，索引表没有 index by子句就是嵌套表，它可以存放于数据中，元素个数无限，下标从1开始，并且需要初始化
    Java代码 复制代码
    1. type t_nestTable is table of varchar2(20);   
    2. v_class t_nestTable ;  
    仅是这样声明是不能使用的，必须对嵌套表进行初始化，对嵌套表进行初始化可以使用它的构造函数
    Java代码 复制代码
    1. v_class :=t_nestTable('a','b','c');  
    变长数组，变长数组与高级语言的数组类型非常相似，下标以1开始，元素个数有限。
    Java代码 复制代码
    1. type t_array is varray (20) of varchar2(20);  

    varray(20)就定义了变长数组的最大元素个数是20个
    变长数组与嵌套表一样，也可以是数据表列的数据类型。
    同时，变长数组的使用也需要事先初始化。

    类型 可存储于数据库 元素个数 是否需初始化 初始下标值
    索引表 否 无限 不需
    嵌套表 可 无限 需 1
    可变数组 可 有限(自定义) 需 1

    由此可见，如果仅仅是在存储过程中当作集合变量使用，索引表是最好的选择。

    3.2 选用何种游标?
    显示游标分为：普通游标，参数化游标和游标变量三种。
    下面以一个过程来进行说明
    Java代码 复制代码
    1. create or replace procedure proccursor(p varchar2)   
    2. as    
    3. v_rownum number(10) := 1;   
    4. cursor c_postype is select pos_type from pos_type_tbl where rownum =1;   
    5. cursor c_postype1 is select pos_type from pos_type_tbl where rownum = v_rownum;   
    6. cursor c_postype2(p_rownum number) is select pos_type from pos_type_tbl where rownum = p_rownum;   
    7. type t_postype is ref cursor ;   
    8. c_postype3 t_postype;   
    9. v_postype varchar2(20);   
    10. begin   
    11.   open c_postype;   
    12.   fetch c_postype into v_postype;   
    13.   dbms_output.put_line(v_postype);   
    14.   close c_postype;   
    15.   open c_postype1;   
    16.   fetch c_postype1 into v_postype;   
    17.   dbms_output.put_line(v_postype);   
    18.   close c_postype1;   
    19.   open c_postype2(1);   
    20.   fetch c_postype2 into v_postype;   
    21.   dbms_output.put_line(v_postype);   
    22.   close c_postype2;   
    23.   open c_postype3 for select pos_type from pos_type_tbl where rownum =1;   
    24.   fetch c_postype3 into v_postype;   
    25.   dbms_output.put_line(v_postype);   
    26.   close c_postype3;   
    27. end;  

    cursor c_postype is select pos_type from pos_type_tbl where rownum =1
    这一句是定义了一个最普通的游标，把整个查询已经写死,调用时不可以作任何改变。
    cursor c_postype1 is select pos_type from pos_type_tbl where rownum = v_rownum;
    这一句并没有写死，查询参数由变量v_rownum来决定。需要注意的是v_rownum必须在这个游标定义之前声明。
    cursor c_postype2(p_rownum number) is select pos_type from pos_type_tbl where rownum = p_rownum;
    这一条语句与第二条作用相似，都是可以为游标实现动态的查询。但是它进一步的缩小了参数的作用域范围。但是可读性降低了不少。
    type t_postype is ref cursor ;
    c_postype3 t_postype;
    先定义了一个引用游标类型，然后再声明了一个游标变量。
    open c_postype3 for select pos_type from pos_type_tbl where rownum =1;
    然后再用open for 来打开一个查询。需要注意的是它可以多次使用,用来打开不同的查询。
    从动态性来说，游标变量是最好用的，但是阅读性也是最差的。
    注意，游标的定义只能用使关键字IS，它与AS不通用。

    3.3 游标循环最佳策略
    我们在进行PL/SQL编程时，经常需要循环读取结果集的数据。进行逐行处理，这个过程就需要对游标进行循环。对游标进行循环的方法有多种，我们在此一一分析。
    Java代码 复制代码
    1. create or replace procedure proccycle(p varchar2)   
    2. as    
    3. cursor c_postype is select pos_type, description from pos_type_tbl where rownum < 6;   
    4. v_postype varchar2(20);   
    5. v_description varchar2(50);   
    6. begin   
    7. open c_postype;   
    8.   if c_postype%found then   
    9.     dbms_output.put_line('found true');   
    10.   elsif c_postype%found = false then   
    11.     dbms_output.put_line('found false');   
    12.   else  
    13.     dbms_output.put_line('found null');   
    14.   end if;   
    15.   loop   
    16.    fetch c_postype into v_postype,v_description ;   
    17.    exit when c_postype%notfound;   
    18.    dbms_output.put_line('postype:'||v_postype||',description:'||v_description);   
    19.   end loop;   
    20.   close c_postype;   
    21. dbms_output.put_line('---loop end---');   
    22.   open c_postype;   
    23.     fetch c_postype into v_postype,v_description;   
    24.     while c_postype%found loop   
    25.       dbms_output.put_line('postype:'||v_postype||',description:'||v_description);   
    26.       fetch c_postype into v_postype,v_description ;   
    27.     end loop;   
    28.   
    29.   close c_postype;   
    30. dbms_output.put_line('---while end---');   
    31.   for v_pos in c_postype loop   
    32.     v_postype := v_pos.pos_type;   
    33.     v_description := v_pos.description;   
    34.     dbms_output.put_line('postype:'||v_postype||',description:'||v_description);   
    35.   end loop;   
    36.   dbms_output.put_line('---for end---');   
    37. end;  

    使用游标之前需要开打游标,open cursor，循环完后再关闭游标close cursor.
    这是使用游标应该慎记于心的法则。
    上面的过程演示了游标循环的三种方法。
    在讨论循环方法之前，我们先看看%found和%notfound这些游标的属性。

    Java代码 复制代码
    1. open c_postype;   
    2.  if c_postype%found then   
    3.    dbms_output.put_line('found true');   
    4.  elsif c_postype%found = false then   
    5.    dbms_output.put_line('found false');   
    6.  else  
    7.    dbms_output.put_line('found null');   
    8.  end if;  
    在打开一个游标之后，马上检查它的%found或%notfound属性，它得到的结果即不是true也不是false.而是null.必须执行一条fetch语句后，这些属性才有值。

    第一种使用loop 循环
    Java代码 复制代码
    1. loop   
    2.    fetch c_postype into v_postype,v_description ;   
    3.    exit when c_postype%notfound;   
    4.    ……   
    5. end loop  
    这里需要注意，exit when语句一定要紧跟在fetch之后。必避免多余的数据处理。
    处理逻辑需要跟在exit when之后。这一点需要多加小心。
    循环结束后要记得关闭游标。

    第二种使用while循环。
    Java代码 复制代码
    1.    fetch c_postype into v_postype,v_description;   
    2. while c_postype%found loop   
    3.    ……   
    4.       fetch c_postype into v_postype,v_description ;   
    5. end loop;  

    我们知道了一个游标打开后，必须执行一次fetch语句，游标的属性才会起作用。所以使用while 循环时，就需要在循环之前进行一次fetch动作。
    而且数据处理动作必须放在循环体内的fetch方法之前。循环体内的fetch方法要放在最后。否则就会多处理一次。这一点也要非常的小心。
    总之，使用while来循环处理游标是最复杂的方法。

    第三种 for循环
    Java代码 复制代码
    1. for v_pos in c_postype loop   
    2.    v_postype := v_pos.pos_type;   
    3.    v_description := v_pos.description;   
    4.    …   
    5.  end loop;  
    可见for循环是比较简单实用的方法。
    首先，它会自动open和close游标。解决了你忘记打开或关闭游标的烦恼。
    其它,自动定义了一个记录类型及声明该类型的变量，并自动fetch数据到这个变量中。
    我们需要注意v_pos 这个变量无需要在循环外进行声明，无需要为其指定数据类型。
    它应该是一个记录类型，具体的结构是由游标决定的。
    这个变量的作用域仅仅是在循环体内。
    把v_pos看作一个记录变量就可以了，如果要获得某一个值就像调用记录一样就可以了。
    如v_pos.pos_type
    由此可见，for循环是用来循环游标的最好方法。高效，简洁，安全。
    但遗憾的是，常常见到的却是第一种方法。所以从今之后得改变这个习惯了。

    3.4 select into不可乎视的问题
    我们知道在pl/sql中要想从数据表中向变量赋值，需要使用select into 子句。
    但是它会带动来一些问题，如果查询没有记录时，会抛出no_data_found异常。
    如果有多条记录时，会抛出too_many_rows异常。
    这个是比较糟糕的。一旦抛出了异常，就会让过程中断。特别是no_data_found这种异常，没有严重到要让程序中断的地步，可以完全交给由程序进行处理。
    Java代码 复制代码
    1. create or replace procedure procexception(p varchar2)   
    2. as    
    3.   v_postype varchar2(20);   
    4. begin   
    5.    select pos_type into v_postype from pos_type_tbl where 1=0;   
    6.     dbms_output.put_line(v_postype);   
    7. end;   
    8.       
    执行这个过程
    Java代码 复制代码
    1. SQL> exec procexception('a');   
    2. 报错   
    3. ORA-01403: no data found   
    4. ORA-06512: at "LIFEMAN.PROCEXCEPTION", line 6  
    5. ORA-06512: at line 1  

    处理这个有三个办法
    1． 直接加上异常处理。
    Java代码 复制代码
    1. create or replace procedure procexception(p varchar2)   
    2. as    
    3.   v_postype varchar2(20);   
    4.      
    5. begin   
    6.    select pos_type into v_postype from pos_type_tbl where 1=0;   
    7.     dbms_output.put_line(v_postype);   
    8. exception    
    9.   when no_data_found then   
    10.     dbms_output.put_line('没找到数据');   
    11. end;  
    这样做换汤不换药，程序仍然被中断。可能这样不是我们所想要的。
    2. select into做为一个独立的块，在这个块中进行异常处理
    Java代码 复制代码
    1. create or replace procedure procexception(p varchar2)   
    2. as    
    3.   v_postype varchar2(20);   
    4.      
    5. begin   
    6.   begin   
    7.    select pos_type into v_postype from pos_type_tbl where 1=0;   
    8.     dbms_output.put_line(v_postype);   
    9.  exception    
    10.   when no_data_found then   
    11.     v_postype := '';   
    12.   end;   
    13.   dbms_output.put_line(v_postype);   
    14. end;  
    这是一种比较好的处理方式了。不会因为这个异常而引起程序中断。
    3.使用游标
    Java代码 复制代码
    1. create or replace procedure procexception(p varchar2)   
    2. as    
    3.   v_postype varchar2(20);   
    4.   cursor c_postype is select pos_type  from pos_type_tbl where 1=0;   
    5. begin   
    6.   open c_postype;   
    7.     fetch c_postype into v_postype;   
    8.   close c_postype;   
    9.   dbms_output.put_line(v_postype);   
    10. end;  
    这样就完全的避免了no_data_found异常。完全交由程序员来进行控制了。

    第二种情况是too_many_rows 异常的问题。
    Too_many_rows 这个问题比起no_data_found要复杂一些。
    给一个变量赋值时，但是查询结果有多个记录。
    处理这种问题也有两种情况：
    1． 多条数据是可以接受的，也就是说从结果集中随便取一个值就行。这种情况应该很极端了吧，如果出现这种情况，也说明了程序的严谨性存在问题。
    2． 多条数据是不可以被接受的，在这种情况肯定是程序的逻辑出了问题，也说是说原来根本就不会想到它会产生多条记录。
    对于第一种情况，就必须采用游标来处理，而对于第二种情况就必须使用内部块来处理，重新抛出异常。
    多条数据可以接受,随便取一条，这个跟no_data_found的处理方式一样，使用游标。
    我这里仅说第二种情况，不可接受多条数据，但是不要忘了处理no_data_found哦。这就不能使用游标了，必须使用内部块。
    Java代码 复制代码
    1. create or replace procedure procexception2(p varchar2)   
    2. as    
    3.   v_postype varchar2(20);   
    4.     
    5. begin   
    6.   begin   
    7.     select pos_type into v_postype from pos_type_tbl where rownum < 5;   
    8.   exception   
    9.     when no_data_found then   
    10.       v_postype :=null;   
    11.     when too_many_rows then   
    12.       raise_application_error(-20000,'对v_postype赋值时，找到多条数据');   
    13.   end;   
    14.  dbms_output.put_line(v_postype);   
    15. end;  
    需要注意的是一定要加上对no_data_found的处理，对出现多条记录的情况则继续抛出异常，让上一层来处理。
    总之对于select into的语句需要注意这两种情况了。需要妥当处理啊。

    3.5 在存储过程中返回结果集
    我们使用存储过程都是返回值都是单一的，有时我们需要从过程中返回一个集合。即多条数据。这有几种解决方案。比较简单的做法是写临时表，但是这种做法不灵活。而且维护麻烦。我们可以使用嵌套表来实现.没有一个集合类型能够与java的jdbc类型匹配。这就是对象与关系数据库的阻抗吧。数据库的对象并不能够完全转换为编程语言的对象，还必须使用关系数据库的处理方式。

    Java代码 复制代码
    1. create or replace package procpkg is   
    2.    type refcursor is ref cursor;   
    3.    procedure procrefcursor(p varchar2, p_ref_postypeList  out refcursor);   
    4. end procpkg;   
    5.   
    6. create or replace package body procpkg is   
    7.   procedure procrefcursor(p varchar2, p_ref_postypeList out  refcursor)   
    8.   is   
    9.     v_posTypeList PosTypeTable;   
    10.   begin   
    11.     v_posTypeList :=PosTypeTable();--初始化嵌套表   
    12.     v_posTypeList.extend;   
    13.     v_posTypeList(1) := PosType('A001','客户资料变更');   
    14.     v_posTypeList.extend;   
    15.     v_posTypeList(2) := PosType('A002','团体资料变更');   
    16.     v_posTypeList.extend;   
    17.     v_posTypeList(3) := PosType('A003','受益人变更');   
    18.     v_posTypeList.extend;   
    19.     v_posTypeList(4) := PosType('A004','续期交费方式变更');   
    20.     open p_ref_postypeList for  select * from table(cast (v_posTypeList as PosTypeTable));   
    21.   end;   
    22. end procpkg;  

    在包头中定义了一个游标变量,并把它作为存储过程的参数类型。
    在存储过程中定义了一个嵌套表变量，对数据写进嵌套表中，然后把嵌套表进行�

    查看(398) 评论(0) 收藏 分享 管理

  • C#调用Excel

    2009-03-27 10:55:01

    Excel是微软公司办公自动化套件中的一个软件，他主要是用来处理电子表格。Excel以其功能强大，界面友好等受到了许多用户的欢迎。在设计应用系统时，对于不同的用户，他们对于打印的需求是不一样的，如果要使得程序中的打印功能适用于每一个用户，可以想象程序设计是十分复杂的。由于Excel表格的功能强大，又由于几乎每一台机器都安装了它，如果把程序处理的结果放到Excel表格中，这样每一个用户就可以根据自己的需要在Excel中定制自己的打印。这样不仅使得程序设计简单，而且又满足了诸多用户的要求，更加实用了。那么用Visual C＃如何调用Excel，如何又把数据存放到Excel表格中？本文就来探讨上述问题的解决办法。

    　　Excel对象

    　　微软的Excel对象模型包括了128个不同的对象，从矩形，文本框等简单的对象到透视表，图表等复杂的对象．下面我们简单介绍一下其中最重要，也是用得最多的四个对象。

    　　(1) Application对象。Application对象处于Excel对象层次结构的顶层，表示Excel自身的运行环境。

    　　(2) Workbook对象。Workbook对象直接地处于Application对象的下层，表示一个Excel工作薄文件。

    　　(3) Worksheet对象。Worksheet对象包含于Workbook对象，表示一个Excel工作表。

    　　(4) Range对象。Range对象包含于Worksheet对象，表示Excel工作表中的一个或多个单元格。

     

    　　C#中的受管代码和非受管代码

    　　在.NET公用语言框架内运行的程序为受管代码。受管代码在程序中所有类型都受到严格检查，没有指针，对内存的管理完全由运行系统控制。受控状态下，编写程序更为容易，且更少出错，我们可以花更多的时间在解决实际问题上而不是在计算机语言问题上。相对而言，那些在.NET框架外运行的程序为非受管代码。比如：COM组件、ActiveX组件、Win32 API函数、指针运算等。C#编程中在某些特定情况下，需要运用非受管代码，例如，要利用一个成熟的COM组件，或者调用一个API函数，或者用指针去编写实时/高效程序等。

    　　Visual C#中调用Excel的COM组件

    　　一个.NET组件事实上是一个.NET下的DLL，它包含的不仅是运行程序本身，更重要的是包含这个DLL的描述信息（Meta. Data,即元数据），而一个COM组件是用其类库（TLB）储存其描述信息。这些COM组件都是非受管代码，要在Visual C＃中使用这些非受管代码的COM组件，就必须把他们转换成受管代码的.NET组件。所以在用Visual C＃调用Excel表格之前，必须完成从COM组件的非受管代码到受管代码的类库的转换。

    　　1、将Excel的COM组件转换为.NET组件

    　　在项目中打开Add Reference对话框，选择COM栏，之后在COM列表中找到"Microsoft Excel 9.0 Object Library"（Office 2000），然后将其加入到项目的References中即可。Visual C#.NET会自动产生相应的.NET组件文件，以后即可正常使用。

    　　这个转换形成.NET组件不能单独使用，它不过是以前的COM组件的一个外层包装，在.NET中可以通过这个外层包装去发现原来的COM组件并调用其相应的界面函数。所以它必须与原来的COM组件一起起作用。

    　　2、Visual C＃打开Excel表格

    　　事实上，在C#中使用一个经转换的COM组件和使用任何一个其它.NET组件完全一样。可以用new关键字创建一个经转换的COM组件，然后再像使用任何一个其它C#对象一样使用这个组件对象。

    　　在转换后的.NET组件中定义了一个命名空间Excel，在此命名空间中封装了一个类Application，这个类和启动Excel表格有非常重要的关系，在Visual C＃中，只需要下列三行代码就可以完成打开Excel表格的工作，具体如下：


    Excel.Application excel = new Excel.Application ()；//引用Excel对象
    excel.Application.Workbooks.Add ( true )；//引用Excel工作簿
    excel.Visible = true ；//使Excel可视


    　　但此时的Excel表格是一个空的表格，没有任何内容，下面就来介绍如何往Excel表格中输入数据。

    　　3、往Excel表格中输入数据

    　　在命名空间"Excel"中，还定义了一个类"Cell"，这个类所代表的就是Excel表格中的一个单元格。通过给"Cell"赋值，从而实现往Excel表格中输入相应的数据，下列代码功能是打开Excel表格，并且往表格输入一些数据。


    Excel.Application excel = new Excel.Application () ；
    excel.Application.Workbooks.Add ( true ) ；
    excel.Cells[ 1 , 1 ] = "First Row First Column" ；
    excel.Cells[ 1 , 2 ] = "First Row Second Column" ；
    excel.Cells[ 2 , 1 ] = "Second Row First Column" ；
    excel.Cells[ 2 , 2 ] = "Second Row Second Column" ；
    excel.Visible = true ; 

     

    　　4、实例

    　　下面实例在C#中连接Oracle数据库(Name),从表(TableName)中读取数据,并写入Excel。


    string cnString="Provider=msdaora.1;Data source=Name; ";
    cnString=cnString+"user id=UserName;password=Password";
    try
    {
    　OleDbConnection cn=new OleDbConnection (cnString);
    　cn.Open ();
    　try
    　{
    　　string s="select * from Name.TableName";
    　　OleDbCommand cmd=new OleDbCommand (s,cn);
    　　OleDbDataReader dr=cmd.ExecuteReader ();
    　　Excel.Application xlApp = new Excel.Application();
    　　if(xlApp==null){MessageBox.Show ("Can't open Excel!");return;}
    　　xlApp.Application .Workbooks .Add (true);
    　　int row=2,fieldcount;
    　　fieldcount=dr.FieldCount ;
    　　for(int col=0;col<fieldcount;col++) xlApp.Cells [1,col+1]=dr.GetName(col);
    　　while (dr.Read ())
    　　{
    　　　for(int col=0;col<fieldcount;col++)
    　　　　xlApp.Cells [row,col+1]=dr.GetValue(col).ToString();
    　　　　row++;
    　　}
    　　xlApp.Visible =true;
    　　xlApp=null;
    　}
    　catch(Exception ex ){MessageBox.Show (ex.Message );}
    　finally {cn.Close();}
    }
    catch(Exception ex){MessageBox.Show (ex.Message );}
    }
    }


    　　5、安装一个使用COM组件的.NET程序

    　　如果要将这样的程序安装运行在另一台机器上，那么除了安装运行程序外，还做三件事。

    　　首先，是安装.NET运行系统。因为任何一个.NET程序都不能离开.NET运行系统去独立运行。

    　　其次，所调用的COM组件必须要安装在目标机器上。本例中大多数目标机器上都装有Microsoft Office的Excel，一般不会有这个问题。但如果是另一个用户自定义的COM组件，那么这个COM组件在运行.NET程序之前必须先安装好。

    　　最后，转换后的.NET组件DLL文件要安装在目标机器上。因为.NET组件不需要在Windows Registry中注册，所以最简单的方法是将.NET组件DLL文件拷贝到运行程序目录下。如果此.NET组件被多个.NET程序共享，可以将其安装在.NET公用组件区中，从而可被任何一个.NET组件使用。只有当一个.NET组件参与了事务处理时，才需要将它注册为一个COM+组件。因为.NET仍然用传统的COM+机制来处理事务的提交、回滚等。

    查看(656) 评论(0) 收藏 分享 管理

  • Web.config详解

    2009-03-25 10:05:06

    转自http://www.doorle.cn/blog/article.asp?id=923

    一、认识Web.config文件
    Web.config 文件是一个XML文本文件，它用来储存 ASP.NET Web 应用程序的配置信息（如最常用的设置ASP.NET Web 应用程序的身份验证方式），它可以出现在应用程序的每一个目录中。当你通过.NET新建一个Web应用程序后，默认情况下会在根目录自动创建一个默认的Web.config文件，包括默认的配置设置，所有的子目录都继承它的配置设置。如果你想修改子目录的配置设置，你可以在该子目录下新建一个Web.config文件。它可以提供除从父目录继承的配置信息以外的配置信息，也可以重写或修改父目录中定义的设置。
    (一).Web.Config是以XML文件规范存储,配置文件分为以下格式
    1.配置节处理程序声明
    特点： 位于配置文件的顶部，包含在<configSections>标志中。
    2.特定应用程序配置
    特点: 位于<appSetting>中。 可以定义应用程序的全局常量设置等信息.
    3.配置节设置
    特点: 位于<system.Web>节中，控制Asp.net运行时的行为.
    4.配置节组
    特点: 用<sectionGroup>标记，可以自定义分组，可以放到<configSections>内部或其它<sectionGroup>标记的内部.
    (二).配置节的每一节
    1.<configuration>节
    根元素，其它节都是在它的内部.
    2.<appSetting>节
    此节用于定义应用程序设置项。对一些不确定设置，还可以让用户根据自己实际情况自己设置
    用法:
    I.
    <appSettings>
    <add key="Conntction" value="server=192.168.85.66;userid=sa;password=;database=Info;"/>
    <appSettings>
    定义了一个连接字符串常量，并且在实际应用时可以修改连接字符串，不用修改程式代码.
    II.<appSettings>
    <add key="ErrPage" value="Error.aspx"/>
    <appSettings>
    定义了一个错误重定向页面.
    3.<compilation>节
    格式:
    <compilation
    defaultLanguage="c#"
    debug="true"
    />
    I.default language: 定义后台代码语言,可以选择C#和VB.net两种语言.
    IIdebug : 为true时，启动aspx调试； 为false不启动aspx调试，因而可以提高应用程序运行
    时的性能。 一般程序员在开发时设置为true,交给客户时设置为false.
    4.<customErrors>节
    格式:
    <customErrors
    mode="RemoteOnly"
    defaultRedirect="error.aspx"
    <error statusCode="440" redirect="err440page.aspx"/>
    <error statusCode="500" redirect="err500Page.aspx"/>
    />
    I.mode : 具有On,Off,RemoteOnly 3种状态。On表示始终显示自定义的信息; Off表示始终显示详细的asp.net错误信息; RemoteOnly表示只对不在本地Web服务器上运行的用户显示自定义信息.
    II.defaultRedirect: 用于出现错误时重定向的URL地址. 是可选的
    III.statusCode: 指明错误状态码，表明一种特定的出错状态.
    IV. redirect:错误重定向的URL.
    5.<globalization>节
    格式:
    <globalization
    requestEncoding="utf-8"
    responseEncoding="utf-8"
    fileEncoding="utf-8"
    />
    I.requestEncoding: 它用来检查每一个发来请求的编码.
    II.responseEncoding: 用于检查发回的响应内容编码.
    III.fileEncoding: 用于检查aspx,asax等文件解析的默认编码.
    6.<sessionState>节
    格式:
    <sessionState
    mode="InProc"
    stateConnectionString="tcpip=127.0.0.1:42424"
    sqlConnectionString="data source=127.0.0.1;Trusted_Connection=yes"
    cookieless="false"
    timeout="20"
    />
    I.mode: 分为off,Inproc,StateServer,SqlServer几种状态
    这里有详细介绍此属性:
    II. stateConnectionString :指定Asp.net应用程序存储远程会话状态的服务器名，默认为本机
    III.sqlConnectionString: 当用会话状态数据库时，在这里设置连接字符串
    IV. Cookieless: 设置为true时，表示不使用cookie会话状态来标识客户； 否则，相反.
    V. TimeOut: 用来定义会话状态存储的时间，超过期限，将自动终止会话.
    7.<authentication>节
    格式:
    <authentication mode="Forms">
    <forms name=".ASPXUSERDEMO" loginUrl="Login.aspx" protection="All" timeout="30"/>
    </authentication>
    <authorization>
    <deny users="?"/>
    </authorization>
    I.Windows: 使用IIS验证方式
    II.Forms: 使用基于窗体的验证方式
    III.Passport: 采用Passport cookie验证模式
    IV.None: 不采用任何验证方式
    里面内嵌Forms节点的属性涵义:
    I.Name: 指定完成身份验证的Http cookie的名称.
    II.LoginUrl: 如果未通过验证或超时后重定向的页面URL，一般为登录页面，让用户重新登录
    III.Protection: 指定 cookie数据的保护方式.
    可设置为: All None Encryption Validation四种保护方式
    a. All表示加密数据，并进行有效性验证两种方式
    b. None表示不保护Cookie.
    c. Encryption表示对Cookie内容进行加密
    d. validation表示对Cookie内容进行有效性验证
    IV. TimeOut: 指定Cookie的失效时间. 超时后要重新登录.

    在运行时对Web.config文件的修改不需要重启服务就可以生效（注：<processModel> 节例外）。当然Web.config文件是可以扩展的。你可以自定义新配置参数并编写配置节处理程序以对它们进行处理。

    web.config配置文件（默认的配置设置）以下所有的代码都应该位于
    <configuration>
    <system.web>
    和
    </system.web>
    </configuration>
    之间，出于学习的目的下面的示例都省略了这段XML标记。



    1、<authentication> 节
    作用：配置 ASP.NET 身份验证支持（为Windows、Forms、PassPort、None四种）。该元素只能在计算机、站点或应用程序级别声明。< authentication> 元素必需与<authorization> 节配合使用。



    示例：

    以下示例为基于窗体（Forms）的身份验证配置站点，当没有登陆的用户访问需要身份验证的网页，网页自动跳转到登陆网页。
    <authentication mode="Forms" >
    <forms loginUrl="logon.aspx" name=".FormsAuthCookie"/>
    </authentication>
    其中元素loginUrl表示登陆网页的名称，name表示Cookie名称。

    2、<authorization> 节
    作用：控制对 URL 资源的客户端访问（如允许匿名用户访问）。此元素可以在任何级别（计算机、站点、应用程序、子目录或页）上声明。必需与<authentication> 节配合使用。



    示例：以下示例禁止匿名用户的访问
    <authorization>
       <deny users="?"/>
    </authorization>
    注：你可以使用user.identity.name来获取已经过验证的当前的用户名；可以使用web.Security.FormsAuthentication.RedirectFromLoginPage方法将已验证的用户重定向到用户刚才请求的页面.具体的

    3、<compilation>节
    作用：配置 ASP.NET 使用的所有编译设置。默认的debug属性为“True”.在程序编译完成交付使用之后应将其设为False（Web.config文件中有详细说明，此处省略示例）



    4、<customErrors>
    作用：为 ASP.NET 应用程序提供有关自定义错误信息的信息。它不适用于 XML Web services 中发生的错误。

    示例：当发生错误时，将网页跳转到自定义的错误页面。
    <customErrors defaultRedirect="ErrorPage.aspx" mode="RemoteOnly">
    </customErrors>
    其中元素defaultRedirect表示自定义的错误网页的名称。mode元素表示：对不在本地 Web 服务器上运行的用户显示自定义(友好的)信息。



    5、<httpRuntime>节
    作用：配置 ASP.NET HTTP 运行库设置。该节可以在计算机、站点、应用程序和子目录级别声明。



    示例：控制用户上传文件最大为4M，最长时间为60秒，最多请求数为100
    <httpRuntime maxRequestLength="4096" executionTimeout="60" appRequestQueueLimit="100"/>

    6、 <pages>
    作用：标识特定于页的配置设置（如是否启用会话状态、视图状态，是否检测用户的输入等）。<pages>可以在计算机、站点、应用程序和子目录级别声明。



    示例：不检测用户在浏览器输入的内容中是否存在潜在的危险数据（注：该项默认是检测，如果你使用了不检测，一要对用户的输入进行编码或验证)，在从客户端回发页时将检查加密的视图状态，以验证视图状态是否已在客户端被篡改。(注：该项默认是不验证）
    <pages buffer="true" enableViewStateMac="true" validateRequest="false"/>

    7、<sessionState>
    作用：为当前应用程序配置会话状态设置（如设置是否启用会话状态，会话状态保存位置）。



    示例：
    <sessionState mode="InProc" cookieless="true" timeout="20"/>
    </sessionState>
    注：
    mode="InProc"表示：在本地储存会话状态（你也可以选择储存在远程服务器或SAL服务器中或不启用会话状态）
    cookieless="true"表示：如果用户浏览器不支持Cookie时启用会话状态(默认为False）
    timeout="20"表示：会话可以处于空闲状态的分钟数

    8、<trace>
    作用：配置 ASP.NET 跟踪服务，主要用来程序测试判断哪里出错。



    示例：以下为Web.config中的默认配置：
    <trace enabled="false" requestLimit="10" pageOutput="false" traceMode="SortByTime" localOnly="true" />
    注：
    enabled="false"表示不启用跟踪；
    requestLimit="10"表示指定在服务器上存储的跟踪请求的数目
    pageOutput="false"表示只能通过跟踪实用工具访问跟踪输出；
    traceMode="SortByTime"表示以处理跟踪的顺序来显示跟踪信息
    localOnly="true" 表示跟踪查看器 (trace.axd) 只用于宿主 Web 服务器

    自定义Web.config文件配置

    自定义Web.config文件配置节过程分为两步。
    1.在在配置文件顶部 <configSections> 和 </configSections>标记之间声明配置节的名称和处理该节中配置数据的 .NET Framework 类的名称。
    2.是在 <configSections> 区域之后为声明的节做实际的配置设置。



    示例：创建一个节存储数据库连接字符串
    <configuration>
    　 <configSections>
    　 <section name="appSettings" type="System.Configuration.NameValueFileSectionHandler, System, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
    </configSections>
    　 <appSettings>
    　　 <add key="scon" value="server=a;database=northwind;uid=sa;pwd=123"/>
    　 </appSettings>
    　 <system.web>
    　　 ......
    　 </system.web>
    </configuration>

    访问Web.config文件 你可以通过使用ConfigurationSettings.AppSettings 静态字符串集合来访问 Web.config 文件示例：获取上面例子中建立的连接字符串。例如：
    protected static string Isdebug = ConfigurationSettings.AppSettings["debug"]





    二、web.config中的session配置详解
    打开某个应用程序的配置文件Web.config后，我们会发现以下这段：
    < sessionState
    　　mode="InProc"
    　　stateConnectionString="tcpip=127.0.0.1:42424"
    　　sqlConnectionString="data source=127.0.0.1;Trusted_Connection=yes"
    　　cookieless="false"
    　　timeout="20"
    />
    　　这一段就是配置应用程序是如何存储Session信息的了。我们以下的各种操作主要是针对这一段配置展开。让我们先看看这一段配置中所包含的内容的意思。sessionState节点的语法是这样的：
    < sessionState mode="Off|InProc|StateServer|SQLServer"
                 cookieless="true|false"
                 timeout="number of minutes"
                 stateConnectionString="tcpip=server:port"
                 sqlConnectionString="sql connection string"
                 stateNetworkTimeout="number of seconds"
    />

    必须有的属性是 属性 选项 描述
    mode 设置将Session信息存储到哪里
    Ø         Off 设置为不使用Session功能，
    Ø         InProc 设置为将Session存储在进程内，就是ASP中的存储方式，这是默认值，
    Ø         StateServer 设置为将Session存储在独立的状态服务中，
    Ø         SQLServer 设置将Session存储在SQL Server中。





    可选的属性是： 属性 选项 描述
    Ø         cookieless 设置客户端的Session信息存储到哪里，
    Ø         ture 使用Cookieless模式，
    Ø         false 使用Cookie模式，这是默认值，
    Ø         timeout 设置经过多少分钟后服务器自动放弃Session信息，默认为20分钟。
    stateConnectionString 设置将Session信息存储在状态服务中时使用的服务器名称和端口号，例如："tcpip=127.0.0.1:42424”。当mode的值是StateServer是，这个属性是必需的。
    sqlConnectionString 设置与SQL Server连接时的连接字符串。例如"data source= localhost;Integrated Security=SSPI;Initial Catalog=northwind"。当mode的值是 SQLServer时，这个属性是必需的。
    stateNetworkTimeout 设置当使用StateServer模式存储Session状态时，经过多少秒空闲后，断开Web服务器与存储状态信息的服务器的TCP/IP连接的。默认值是10秒钟。





    ASP.NET中客户端Session状态的存储
    　　在我们上面的Session模型简介中，大家可以发现Session状态应该存储在两个地方，分别是客户端和服务器端。客户端只负责保存相应网站的SessionID，而其他的Session信息则保存在服务器端。在ASP中，客户端的SessionID实际是以Cookie的形式存储的。如果用户在浏览器的设置中选择了禁用Cookie，那末他也就无法享受Session的便利之处了，甚至造成不能访问某些网站。为了解决以上问题，在 ASP.NET中客户端的Session信息存储方式分为：Cookie和Cookieless两种。
    　　ASP.NET中，默认状态下，在客户端还是使用Cookie存储Session信息的。如果我们想在客户端使用Cookieless的方式存储Session信息的方法如下：
    　　找到当前Web应用程序的根目录，打开Web.Config文件，找到如下段落：
    < sessionState
    　　mode="InProc"
    　　stateConnectionString="tcpip=127.0.0.1:42424"
    　　sqlConnectionString="data source=127.0.0.1;Trusted_Connection=yes"
    　　cookieless="false"
    　　timeout="20"
    />
    　　这段话中的cookieless="false"改为：cookieless="true"，这样，客户端的Session信息就不再使用 Cookie存储了，而是将其通过URL存储。关闭当前的IE，打开一个新IE，重新访问刚才的Web应用程序，就会看到类似下面的样子：
    其中，http://localhost/MyTestApplication/(ulqsek45heu3ic2a5zgdl245) /default.aspx中黑体标出的就是客户端的Session ID。注意，这段信息是由IIS自动加上的，不会影响以前正常的连接。



    ASP.NET中服务器端Session状态的存储 准备工作：
    　　为了您能更好的体验到实验现象，您可以建立一个叫做SessionState.aspx的页面，然后把以下这些代码添加到< body>< /body>中。
    < scriptrunat="server">
    Sub Session_Add(sender As Object, e As EventArgs)
    　 Session("MySession") = text1.Value
    　 span1.InnerHtml = "Session data updated! < P>Your session contains: < font color=red>" & Session("MySession"). ToString() & "< /font>"
    End Sub
    Sub CheckSession(sender As Object, eAs EventArgs)
    　 If (Session("MySession")Is Nothing) Then
    　　　 span1.InnerHtml = "NOTHING, SESSION DATA LOST!"
    　 Else
    　　　 span1.InnerHtml = "Your session contains: < font color= red>" & Session("MySession").ToString() & "<   /font>"
    End If
    End Sub
    < /script>
    < formrunat="server"id="Form2">
    　 < inputid="text1"type="text"runat="server"name="text1">
    　 < inputtype="submit"runat="server"OnServerClick="Session_Add"
    　　　　　 value="Add to Session State " id="Submit1"name="Submit1">
    　 < inputtype="submit"runat="server"OnServerClick="CheckSession"
    　　　　　 value=" View Session State " id="Submit2"name="Submit2">
    < /form>
    < hrsize="1">
    < fontsize="6">< spanid="span1"runat="server" />< /font>
    　　这个SessionState.aspx的页面可以用来测试在当前的服务器上是否丢失了Session信息。





    将服务器Session信息存储在进程中
    　　让我们来回到Web.config文件的刚才那段段落中：
    < sessionState
    　　mode="InProc"
    　　stateConnectionString="tcpip=127.0.0.1:42424"
    　　sqlConnectionString="data source=127.0.0.1;Trusted_Connection=yes"
    　　cookieless="false"
    　　timeout="20"
    />
    　　当mode的值是InProc时，说明服务器正在使用这种模式。
    　　这种方式和以前ASP中的模式一样，就是服务器将Session信息存储在IIS进程中。当IIS关闭、重起后，这些信息都会丢失。但是这种模式也有自己最大好处，就是性能最高。应为所有的Session信息都存储在了IIS的进程中，所以IIS能够很快的访问到这些信息，这种模式的性能比进程外存储Session信息或是在SQL Server中存储Session信息都要快上很多。这种模式也是ASP.NET的默认方式。
    　　好了，现在让我们做个试验。打开刚才的SessionState.aspx页面，随便输入一些字符，使其存储在Session中。然后，让我们让IIS重起。注意，并不是使当前的站点停止再开始，而是在IIS中本机的机器名的节点上点击鼠标右键，选择重新启动IIS。(想当初使用NT4时，重新启动IIS必须要重新启动计算机才行，微软真是@#$%^&)返回到SessionState.aspx页面中，检查刚才的Session信息，发现信息已经丢失了。



    将服务器Session信息存储在进程外
    　　首先，让我们来打开管理工具->服务，找到名为：ASP.NET State Service的服务，启动它。实际上，这个服务就是启动一个要保存Session信息的进程。启动这个服务后，你可以从Windows任务管理器->进程中看到一个名为 aspnet_state.exe的进程，这个就是我们保存Session信息的进程。
    　　然后，回到Web.config文件中上述的段落中，将mode的值改为StateServer。保存文件后的重新打开一个IE，打开 SessionState.aspx页面，保存一些信息到Session中。这时，让我们重起IIS，再回到SessionState.aspx页面中查看刚才的Session信息，发现没有丢失。
    　　实际上，这种将Session信息存储在进程外的方式不光指可以将信息存储在本机的进程外，还可以将Session信息存储在其他的服务器的进程中。这时，不光需要将mode的值改为StateServer，还需要在stateConnectionString中配置相应的参数。例如你的计算你是192.168.0.1，你想把Session存储在IP为192.168.0.2的计算机的进程中，就需要设置成这样： stateConnectionString="tcpip=192.168.0.2:42424"。当然，不要忘记在192.168.0.2的计算机中装上.NET Framework，并且启动ASP.NET State Services服务。



    将服务器Session信息存储在SQL Server中
    　　首先，还是让我们来做一些准备工作。启动SQL Server和SQL Server代理服务。在SQL Server中执行一个叫做 InstallSqlState.sql的脚本文件。这个脚本文件将在SQL Server中创建一个用来专门存储Session信息的数据库，及一个维护Session信息数据库的SQL Server代理作业。我们可以在以下路径中找到那个文件：
    [system drive]\winnt\Microsoft.NET\Framework\[version]\
    　　然后打开查询分析器，连接到SQL Server服务器，打开刚才的那个文件并且执行。稍等片刻，数据库及作业就建立好了。这时，你可以打开企业管理器，看到新增了一个叫ASPState的数据库。但是这个数据库中只是些存储过程，没有用户表。实际上Session信息是存储在了tempdb 数据库的ASPStateTempSessions表中的，另外一个ASPStateTempApplications表存储了ASP中 Application对象信息。这两个表也是刚才的那个脚本建立的。另外查看管理->SQL Server代理->作业，发现也多了一个叫做ASPState_Job_DeleteExpiredSessions的作业，这个作业实际上就是每分钟去ASPStateTempSessions 表中删除过期的Session信息的。
    　　接着，我们返回到Web.config文件，修改mode的值改为SQLServer。注意，还要同时修改sqlConnectionString的值，格式为：
    sqlConnectionString="data source=localhost; Integrated Security=SSPI;"
    　　其中data source是指SQL Server服务器的IP地址，如果SQL Server与IIS是一台机子，写127.0.0.1 就行了。Integrated Security=SSPI的意思是使用Windows集成身份验证，这样，访问数据库将以ASP.NET的身份进行，通过如此配置，能够获得比使用userid=sa;password=口令的SQL Server验证方式更好的安全性。当然，如果SQL Server运行于另一台计算机上，你可能会需要通过Active Directory域的方式来维护两边验证的一致性。
    　　同样，让我们做个试验。向SessionState.aspx中添加Session信息，这时发现Session信息已经存在 SQL Server中了，即使你重起计算机，刚才的Session信息也不会丢失。现在，你已经完全看见了Session信息到底是什么样子的了，而且又是存储在SQL Server中的，能干什么就看你的发挥了。

    总结
    　　通过这篇文章，你可以看到在Session的管理和维护上，ASP.NET比ASP有了很大的进步，我们可以更加随意的挑选适合的方法了。对于企业级的应用来说，这无疑对于服务器的同步、服务器的稳定性、可靠性都是有利的。相信在强大的微软支持下，新一代的电子商务平台将会搭建的更好！
            同时，大家也会发现，在这个整个技术中包括了操作系统、Web服务及数据库多种技术的整合。我相信，也许Windows没有Unix稳定， IIS没有Apache稳定，SQL Server也没有Oracle强大，但是，谁可以将他们如此完美的联动到一起呢？所以说，虽然微软每一方面都不是太强，但是如果把微软的东西都整合到一起，谁敢说他不强大呢？微软就是微软！



    三、Asp.net 关于form认证的一般设置
    asp.net 关于form认证的一般设置：
    1: 在web.config中，加入form认证；
       <authentication mode="Forms">
                <forms name="auth" loginUrl="index.aspx" timeout="30"></forms>
    </authentication>
    <authorization>
            <deny users="?" />
    </authorization>
    2: 如果有注册页面时还应该允许匿名用户调用注册页面进行注册;
    以下代码应该在<configuration><system.web>之间,而不应该包含到<system.web>..</system.web>之间;
    ----------------表示允许 匿名用户对 userReg.aspx页面进行访问.
    <location path="userReg.aspx">
      <system.web>
         <authorization>
             <allow users="?" />
         </authorization>
      </system.web>
    </location>
    3 在登录成功后要创建身份验证票, 表明已经通过认证的合法用户;
    if(登陆成功)

    System.Web.Security.FormsAuthentication.SetAuthCookie(用户名称, false);
    　　四、访问Web.config文件
    　　你可以通过使用ConfigurationSettings.AppSettings 静态字符串集合来访问 Web.config 文件示例：获取上面例子中建立的连接字符串。例如：

    protected static string Isdebug = ConfigurationSettings.AppSettings["scon"]

    查看(505) 评论(0) 收藏 分享 管理

  • .Net中堆与栈的区别

    2009-03-19 21:45:42

    .Net中堆与栈的区别

    原文出处：http://www.c-sharpcorner.com/UploadFile/rmcochran/csharp_memory01122006130034PM/csharp_memory.aspx

    尽管在.NET framework下我们并不需要担心内存管理和垃圾回收(Garbage Collection)，但是我们还是应该了解它们，以优化我们的应用程序。同时，还需要具备一些基础的内存管理工作机制的知识，这样能够有助于解释我们日常程序编写中的变量的行为。在本文中我将讲解栈和堆的基本知识，变量类型以及为什么一些变量能够按照它们自己的方式工作。

    在.NET framework环境下，当我们的代码执行时，内存中有两个地方用来存储这些代码。假如你不曾了解，那就让我来给你介绍栈(Stack)和堆(Heap)。栈和堆都用来帮助我们运行代码的，它们驻留在机器内存中，且包含所有代码执行所需要的信息。


    * 栈vs堆：有什么不同？

    栈负责保存我们的代码执行（或调用）路径,而堆则负责保存对象（或者说数据，接下来将谈到很多关于堆的问题）的路径。

    可以将栈想象成一堆从顶向下堆叠的盒子。当每调用一次方法时，我们将应用程序中所要发生的事情记录在栈顶的一个盒子中,而我们每次只能够使用栈顶的那个盒子。当我们栈顶的盒子被使用完之后，或者说方法执行完毕之后，我们将抛开这个盒子然后继续使用栈顶上的新盒子。堆的工作原理比较相似，但大多数时候堆用作保存信息而非保存执行路径，因此堆能够在任意时间被访问。与栈相比堆没有任何访问限制，堆就像床上的旧衣服，我们并没有花时间去整理，那是因为可以随时找到一件我们需要的衣服，而栈就像储物柜里堆叠的鞋盒，我们只能从最顶层的盒子开始取，直到发现那只合适的。

    单击显示全图，Ctrl+滚轮缩放图片

    以上图片并不是内存中真实的表现形式，但能够帮助我们区分栈和堆。

    栈是自行维护的，也就是说内存自动维护栈，当栈顶的盒子不再被使用，它将被抛出。相反的，堆需要考虑垃圾回收，垃圾回收用于保持堆的整洁性，没有人愿意看到周围都是赃衣服，那简直太臭了！


    * 栈和堆里有些什么？

    当我们的代码执行的时候，栈和堆中主要放置了四种类型的数据：值类型(Value Type)，引用类型(Reference Type)，指针(Pointer)，指令(Instruction)。

    1.值类型：

    在C#中，所有被声明为以下类型的事物被称为值类型：

    • bool 
    • byte 
    • char 
    • decimal 
    • double 
    • enum 
    • float 
    • int 
    • long 
    • sbyte 
    • short 
    • struct 
    • uint 
    • ulong 
    • ushort

    2.引用类型：

    所有的被声明为以下类型的事物被称为引用类型：
    • class 
    • interface 
    • delegate 
    • object 
    • string

    3.指针：

    在内存管理方案中放置的第三种类型是类型引用，引用通常就是一个指针。我们不会显示的使用指针，它们由公共语言运行时（CLR）来管理。指针（或引用）是不同于引用类型的，是因为当我们说某个事物是一个引用类型时就意味着我们是通过指针来访问它的。指针是一块内存空间，而它指向另一个内存空间。就像栈和堆一样，指针也同样要占用内存空间，但它的值是一个内存地址或者为空。

    单击显示全图，Ctrl+滚轮缩放图片

    4.指令：

    在后面的文章中你会看到指令是如何工作的...


    * 如何决定放哪儿?

    这里有一条黄金规则:

    1. 引用类型总是放在堆中。(够简单的吧?)

    2. 值类型和指针总是放在它们被声明的地方。(这条稍微复杂点，需要知道栈是如何工作的，然后才能断定是在哪儿被声明的。)

    就像我们先前提到的，栈是负责保存我们的代码执行(或调用)时的路径。当我们的代码开始调用一个方法时,将放置一段编码指令(在方法中)到栈上,紧接着放置方法的参数，然后代码执行到方法中的被“压栈”至栈顶的变量位置。通过以下例子很容易理解...

    下面是一个方法（Method）:
     
     
    1. <STRONG class=k>public</STRONG> <STRONG class=k>int</STRONG> AddFive(<STRONG class=k>int</STRONG> pValue)   
    2. {   
    3.     <STRONG class=k>int</STRONG> result;   
    4.     result = pValue + 5;   
    5.     <STRONG class=k>return</STRONG> result;   
    6. }  

              
    现在就来看看在栈顶发生了些什么，记住我们所观察的栈顶下实际已经压入了许多别的内容。

    首先方法（只包含需要执行的逻辑字节，即执行该方法的指令，而非方法体内的数据）入栈，紧接着是方法的参数入栈。（我们将在后面讨论更多的参数传递）

    单击显示全图，Ctrl+滚轮缩放图片

    接着，控制（即执行方法的线程）被传递到堆栈中AddFive()的指令上，

    单击显示全图，Ctrl+滚轮缩放图片

    当方法执行时，我们需要在栈上为“result”变量分配一些内存，

    单击显示全图，Ctrl+滚轮缩放图片

    The method finishes execution and our result is returned.
    方法执行完成，然后方法的结果被返回。

    单击显示全图，Ctrl+滚轮缩放图片

    通过将栈指针指向AddFive()方法曾使用的可用的内存地址，所有在栈上的该方法所使用内存都被清空，且程序将自动回到栈上最初的方法调用的位置(在本例中不会看到)。

    单击显示全图，Ctrl+滚轮缩放图片

    在这个例子中，我们的"result"变量是被放置在栈上的，事实上，当值类型数据在方法体中被声明时，它们都是被放置在栈上的。

    值类型数据有时也被放置在堆上。记住这条规则--值类型总是放在它们被声明的地方。好的，如果一个值类型数据在方法体外被声明，且存在于一个引用类型中，那么它将被堆中的引用类型所取代。


    来看另一个例子：

    假如我们有这样一个MyInt类（它是引用类型因为它是一个类类型）：
     
     
    1. <STRONG class=k>public</STRONG> <STRONG class=k>class</STRONG> MyInt   
    2. {   
    3.     <STRONG class=k>public</STRONG> <STRONG class=k>int</STRONG> MyValue;   
    4. }  

    然后执行下面的方法:
     
    1. <STRONG class=k>public</STRONG> MyInt AddFive(<STRONG class=k>int</STRONG> pValue)   
    2. {   
    3.     MyInt result = <STRONG class=k>new</STRONG> MyInt();   
    4.     result.MyValue = pValue + 5;   
    5.     <STRONG class=k>return</STRONG> result;   
    6. }  

    就像前面提到的，方法及方法的参数被放置到栈上，接下来，控制被传递到堆栈中AddFive()的指令上。
    单击显示全图，Ctrl+滚轮缩放图片

    接着会出现一些有趣的现象...

    因为"MyInt"是一个引用类型,它将被放置在堆上,同时在栈上生成一个指向这个堆的指针引用。
    单击显示全图，Ctrl+滚轮缩放图片

    在AddFive()方法被执行之后，我们将清空...
    单击显示全图，Ctrl+滚轮缩放图片

    我们将剩下孤独的MyInt对象在堆中（栈中将不会存在任何指向MyInt对象的指针!）
    单击显示全图，Ctrl+滚轮缩放图片

    这就是垃圾回收器（后简称GC）起作用的地方。当我们的程序达到了一个特定的内存阀值，我们需要更多的堆空间的时候，GC开始起作用。GC将停止所有正在运行的线程，找出在堆中存在的所有不再被主程序访问的对象，并删除它们。然后GC会重新组织堆中所有剩下的对象来节省空间，并调整栈和堆中所有与这些对象相关的指针。你肯定会想到这个过程非常耗费性能，所以这时你就会知道为什么我们需要如此重视栈和堆里有些什么，特别是在需要编写高性能的代码时。

    Ok... 这太棒了, 当它是如何影响我的？

    Good question.  

    当我们使用引用类型时，我们实际是在处理该类型的指针，而非该类型本身。当我们使用值类型时，我们是在使用值类型本身。听起来很迷糊吧？

    同样，例子是最好的描述。

    假如我们执行以下的方法：
     
     
    1. <STRONG class=k>public</STRONG> <STRONG class=k>int</STRONG> ReturnValue()   
    2. {   
    3.     <STRONG class=k>int</STRONG> x = <STRONG class=k>new</STRONG> <STRONG class=k>int</STRONG>();   
    4.     x = 3;   
    5.     <STRONG class=k>int</STRONG> y = <STRONG class=k>new</STRONG> <STRONG class=k>int</STRONG>();   
    6.     y = x;   
    7.     y = 4;   
    8.     <STRONG class=k>return</STRONG> x;   
    9. }  

    我们将得到值3，很简单，对吧？

    假如我们首先使用MyInt类
    <STRONG class=k>public</STRONG> <STRONG class=k>class</STRONG> MyInt   
    1. {   
    2.     <STRONG class=k>public</STRONG> <STRONG class=k>int</STRONG> MyValue;   
    3. }  

    接着执行以下的方法：
     
     
    1. <STRONG class=k>public</STRONG> <STRONG class=k>int</STRONG> ReturnValue2()   
    2. {   
    3.     MyInt x = <STRONG class=k>new</STRONG> MyInt();   
    4.     x.MyValue = 3;   
    5.     MyInt y = <STRONG class=k>new</STRONG> MyInt();   
    6.     y = x;   
    7.     y.MyValue = 4;   
    8.     <STRONG class=k>return</STRONG> x.MyValue;   
    9. }  

    我们将得到什么？...    4!

    为什么？...  x.MyValue怎么会变成4了呢？...  看看我们所做的然后就知道是怎么回事了：

    在第一例子中，一切都像计划的那样进行着：
     
     
    1. <STRONG class=k>public</STRONG> <STRONG class=k>int</STRONG> ReturnValue()   
    2. {   
    3.     <STRONG class=k>int</STRONG> x = 3;   
    4.     <STRONG class=k>int</STRONG> y = x;   
    5.     y = 4;   
    6.     <STRONG class=k>return</STRONG> x;   
    7. }  

    单击显示全图，Ctrl+滚轮缩放图片

    在第二个例子中，我们没有得到"3"是因为变量"x"和"y"都同时指向了堆中相同的对象。
     
    1. <STRONG class=k>public</STRONG> <STRONG class=k>int</STRONG> ReturnValue2()   
    2. {   
    3.     MyInt x;   
    4.     x.MyValue = 3;   
    5.     MyInt y;   
    6.     y = x;   
    7.     y.MyValue = 4;   
    8.     <STRONG class=k>return</STRONG> x.MyValue;   
    9. }  

    单击显示全图，Ctrl+滚轮缩放图片

    希望以上内容能够使你对C#中的值类型和引用类型的基本区别有一个更好的认识，并且对指针及指针是何时被使用的有一定的基本了解。在系列的下一个部分，我们将深入内存管理并专门讨论方法参数。 

    查看(871) 评论(0) 收藏 分享 管理

  • web界面测试用例

    2009-03-19 14:24:24

    转自卧龙公子的空间：http://www.51testing.com/?161964/action_viewspace_itemid_76943.html

    界面测试用例

    一、文本框、按钮等控件测试51Testing软件测试网K_$\7b+K)DK

    1、文本框的测试51Testing软件测试网#DUS0W1ft"MP

    如何对文本框进行测试：51Testing软件测试网"]_)I,gb#w

    a、输入正常的字母或数字；
    hygk4e160281b、输入已存在的文件的名称；
    "N e-H r%[160281c、输入超长字符。例如在“名称”框中输入超过允许边界个数的字符，假设最多255个字符，尝试输入256个字符，检查程序能否正确处理；51Testing软件测试网4|w P/nMG
    d、输入默认值，空白，空格；
    Zh!i^*W;l&q2sy160281e、若只允许输入字母，尝试输入数字；反之，尝试输入字母；
    e!A/@5P.W5co`M160281f、利用复制，粘贴等操作强制输入程序不允许的输入数据；
    o}y6PkuIv160281g、输入特殊字符集，例如，NUL及\n等；51Testing软件测试网:BU4KV Xf#@k `
    h、输入超过文本框长度的字符或文本，检查所输入的内容是否正常显示；51Testing软件测试网(kcY0j,j XU6J(V
    i、输入不符合格式的数据，检查程序是否正常校验，如程序要求输入年月日格式为yy/mm/dd，实际输入yyyy/mm/dd，程序应该给出错误提示。    51Testing软件测试网;R!dV` UcJ

    在测试过程中所用到的测试方法：

    e u1~;^4A+V160281

    1、输入非法数据；51Testing软件测试网7?9e|*{1r?
    2、输入默认值；
    #v g+vt6x0w!pJ1602813、输入特殊字符集；
    { C B'j.bq8K d+J5E S-I7X1602814、输入使缓冲区溢出的数据；51Testing软件测试网z{"HV2pnY
    5、输入相同的文件名；

    yraK,l160281

    2、命令按钮控件的测试51Testing软件测试网 Y E"d } k MmN

    测试方法：51Testing软件测试网g%Xv8G Gw

    a、点击按钮正确响应操作。如单击确定，正确执行操作；单击取消，退出窗口；
    X{7tPg5]4Rf160281b、对非法的输入或操作给出足够的提示说明，如输入月工作天数为32时，单击“确定”后系统应提示：天数不能大于31；51Testing软件测试网jfBAVMi
    c、对可能造成数据无法恢复的操作必须给出确认信息，给用户放弃选择的机会；    51Testing软件测试网_PGf1sP(?"A

    3、单选按钮控件的测试

    z _&|V$QX!v160281

    测试方法：

    .x)o'Qnt(q160281

    a、一组单选按钮不能同时选中，只能选中一个；51Testing软件测试网%S?.ukCkg
    b、逐一执行每个单选按钮的功能。分别选择了“男”、“女”后，保存到数据库的数据应该相应的分别为“男”、“女”；
    4X"l f8^g eHEX160281c、一组执行同一功能的单选按钮在初始状态时必须有一个被默认选中，不能同时为空。
    :K.E7M#foop16028151Testing软件测试网(S rDj*gN6v2y ?
    4、up－down控件文本框的测试

    #n W8H1N{160281

    测试方法：

    @9L,Y5F@+d160281

    a、直接输入数字或用上下箭头控制，如在“数目”中直接输入10，或者单击向上的箭头，使数目变为10；51Testing软件测试网:ba Tk^ W
    b、利用上下箭头控制数字的自动循环，如当最多数字为253时，单击向上箭头，数目自动变为1；反之亦适用；
    0Tw _$x.?k c160281c、直接输入超边界值，系统应该提示重新输入；51Testing软件测试网+y+KSf/H)}b
    d、输入默认值，空白。如“插入”数目为默认值，点击“确定”；或删除默认值，使内容为空，单击“确定”进行测试；51Testing软件测试网mE\%a%z}DM
    e、输入字符。此时系统应提示输入有误。    51Testing软件测试网?!nQ%S9[J_,f

    5、组合列表框的测试

    w P9a-S G"xp160281

    测试方法：

    )^#mc[7j(P[6P9l0_B SY~160281

    a、条目内容正确，其详细条目内容可以根据需求说明确定；
    7{ kbR W9Wa:p8r6T160281b、逐一执行列表框中每个条目的功能；51Testing软件测试网]N4|9B_:\*H
    c、检查能否向组合列表框输入数据。

    Hf'wnb$N6S160281

    6、复选框的测试

    4j,| o`pMo [u D160281

    测试方法：51Testing软件测试网p&[ o+rqC2@7O$[

    a、多个复选框可以被同时选中；
    }[ daUO160281b、多个复选框可以被部分选中；51Testing软件测试网/Vz0^+C:Y)Q(Dy-E
    c、多个复选框可以都不被选中；51Testing软件测试网5J*pI#A-CUb"a-m
    d、逐一执行每个复选框的功能。    51Testing软件测试网h@"SZ5Z

    7、列表框控件的测试

    8C1_8a Kuf4{z,v_160281

    测试方法：51Testing软件测试网j*I5M9sd,K

    a、条目内容正确：同组合列表框类似，根据需求说明书确定列表的各项内容正确，没有丢失或错误；
    Bf8K I1\%r0o160281b、列表框的内容较多时要使用滚动条；51Testing软件测试网B X&?*s9[_l
    c、列表框允许多选时，要分别检查shift选中条目，按ctrl选中条目和直接用鼠标选中多项条目的情况；    51Testing软件测试网q Q un?o%L

    8、滚动条控件的测试

    2p(O:J,w}bM*|160281

    要注意一下几点：51Testing软件测试网CO cP Yf

    a、滚动条的长度根据显示信息的长度或宽度及时变换，这样有利于用户了解显示信息的位置和百分比，如word中浏览100页文档，浏览到50页时，滚动条位置应处于中间；51Testing软件测试网2Z3x t E7}J*P7D
    b、拖动滚动条，检查屏幕刷新情况，并查看是否有乱码；
    ThkXf160281c、单击滚动条；
    :xM!y*MLd ru%T160281d、用滚轮控制滚动条；51Testing软件测试网:v T Sx%goV
    e、滚动条的上下按钮。    51Testing软件测试网%V%f$w!O(n4yG&vV

    9、各种控件在窗体中混和使用时的测试51Testing软件测试网3p3^)eTIy-T

    a、控件间的相互作用；
    -@ zv_Tm0gGZ*QA160281b、tab键的顺序，一般是从上到下，从左到右；51Testing软件测试网H`&ux:EW m-N9?
    c、热键的使用，逐一测试；
    tGf&b tEH3U160281d、enter键和esc键的使用。    51Testing软件测试网0Yr R)z`M

    在测试中，应遵循由简入繁的原则，先进行单个控件功能的测试，确保实现无误后，再进行多个控件的的功能组合的测试。51Testing软件测试网w/{U4_tm`3``;M

    ps：密码输入框测试时要特别注意进行字母大写输入的测试。二、查找替换操作

    8W;P$Iy(NZ160281

    案例演示：打开word中的“替换”对话框。

    n0Eb G:jJ4T*B-B3W160281

    测试本功能有通过测试和失败测试两种情况：51Testing软件测试网!WT'J4wj5]'q

    通过测试：51Testing软件测试网9I W eX uh)M!V

    1、输入内容直接查找、或查找全部；51Testing软件测试网I;D?G)Tw
    2、在组合框中寻找已经查找过的内容、再次查找并确认文档的内容正确，如已经查找过“测试用例”、再次进入不用重新输入查找内容、直接在文档中搜寻就可以。    51Testing软件测试网k.pF,Ak8LQ_ r

    失败测试：51Testing软件测试网`[&M `#O_/j6a

    1、输入过长或过短的查询字符串。如假设查询的字符串长度为1到255，那么，输入0、1、2、256、255和254进行测试；
    q5z\U;GUF1602812、输入特殊字符集。如在word中^g代表图片、^代表分栏符、可以输入这类特殊字符测试；

    0x)_6\-EU P+^/N6n160281

    替换测试大体相同。

    :@ w!BZ-q`Uc6T160281

    关于编辑操作窗口的功能测试的用例：

    sh#H(D]160281

    1、关闭查找替换窗口。不执行任何操作、直接退出；51Testing软件测试网8cN}LV R[n p(aVI\
    2、附件和选项测试。假如设定“精确搜寻”、“向后”搜索等附件选项等等来测试；51Testing软件测试网6GL_:{_Q
    3、控件间的相互作用。如搜寻内容为空时、按钮“搜寻全部”、“搜寻”、“全部替换”、“替换”都为灰色。51Testing软件测试网`xdTeoK6x'T@
    4、热键、Tab键。回车键的使用。

    ][8Z O4rKft160281

    插入操作

    2em0c_5t-]&N.v2m9zr160281

    1、插入文件

    ABq8Oe3X160281

    测试的情况：51Testing软件测试网9Q"k/S.q/QYCiV

    a、插入文件；51Testing软件测试网L`m2M,e0n%V8[5Mq
    b、插入图像；51Testing软件测试网t U[.sida e
    c、在文档中插入文档本身；
    k-f"?| T$Ra:J160281d、移除插入的源文件；51Testing软件测试网 m:p8HcwIc.X~d m
    e、更换插入的源文件的内容。

    `g8x!F+iA5H160281

    2、链接文件51Testing软件测试网tF0@uzsx

    测试方法：

    bvC(a%g9t$x160281

    a、插入链接文件；51Testing软件测试网0MmKh#I&_Op|E1Qp
    b、在文档中链接文档本身；51Testing软件测试网a_h2v#Sp1i
    c、移除插入的源文件：
    md.vCt'a` R:g)Jc160281d、更换插入的源文件的内容。    51Testing软件测试网 eQ8zq9v

    3、插入对象

    H/EE]-|L,\"O160281

    要测试的内容：

    N&zma8~5A160281

    a、插入程序允许的对象、如在word中插入excel工作表；
    S3X+P5HiKp;NmV160281b、修改所插入对象的内容。插入的对象仍能正确显示；51Testing软件测试网2B+^/t/I/k4[K
    c、卸载生成插入对象的程序、如在word中插入excel工作表后卸载excel、工作表仍正常使用。

    `!`+b T*V:b6lf/g160281

    编辑操作

    u rM*SYh Z160281

    编辑操作包括剪切、复制、粘贴操作。

    _ @ K/_wlZ(d(nbg160281

    测试剪切操作的方法

    +ou@h)s0a;b z160281

    a、对文本、文本框、图文框进行剪切；
    t C8h+rEs7k2m3PF2l160281b、剪切图像；51Testing软件测试网I3` gd4l'y6p
    c、文本图像混合剪切。    51Testing软件测试网j;` X$o {K+oQ6P

    复制操作方法与剪切类似。

    NrRuSaJ160281

    测试时，主要是对粘贴操作的测试方法是：

    ,}Na+Z _bM160281

    a、粘贴剪切的文本、文本框及图文框；51Testing软件测试网X;c`qt"Eg5s
    b、粘贴所剪切的图像；51Testing软件测试网(XtW"D\#]].E
    c、剪切后，在不同的程序中粘贴；51Testing软件测试网-}.[7n S2sv,G `[ O
    d、多次粘贴同一内容，如剪切后，在程序中连续粘贴3次；51Testing软件测试网2I6c8N3dk
    e、利用粘贴操作强制输入程序所不允许输入的数据。

    a/["c(`7LlwHg3P160281

    三、界面测试用例的设计方法

    +`RoGmrg:e160281

    1、窗体51Testing软件测试网x:k|UHyfg}*Q6M

    测试窗体的方法：51Testing软件测试网+y%~3W;KO/g1P(Bu#E4fE

    a、窗体大小，大小要合适，控件布局合理；51Testing软件测试网rj bSR+gM%g
    b、移动窗体。快速或慢速移动窗体，背景及窗体本身刷新必须正确；51Testing软件测试网.u0IS:J%]gIo)v
    c、缩放窗体，窗体上的控件应随窗体的大小变化而变化；
    (U9OJ0P&W&i E!b[*u160281d、显示分辨率。必须在不同的分辨率的情况下测试程序的显示是否正常。

    R!~A\?160281

    进行测试时还要注意状态栏是否显示正确，工具栏的图标执行操作是否有效，是否与菜单懒中图标显示一致；错误信息内容是否正确、无错别字且明确等等。

    Sh;d"?crG160281

    2、控件51Testing软件测试网?{KLvX%`g2N

    测试方法：51Testing软件测试网g'UW+wa R

    a、窗体或控件的字体和大小要一致；
    :Cw @ A a pPT160281b、注意全角、半角混合；51Testing软件测试网\ [9Q*]Am,E!q%y
    c、无中英文混合。

    W(cT4C'FHq160281

    四、菜单51Testing软件测试网-["]C]'[

    进行测试时要注意：

    @(H@*iU7u,w4e160281

    a、选择菜单是否可以正常工作、并与实际执行内容一致；
    0\,j] ~BO_"}@ `160281b、是否有错别字；
    D)?U?m*`d160281c、快捷键是否重复；
    uD Y9O:g$\7l160281d、热键是否重复；51Testing软件测试网v?9@:c%?a
    e、快捷键与热键操作是否有效；51Testing软件测试网7X[6QG"t0siD)Nw
    f、是否存在中英文混合；
    Uv#d\"y P,E0W ]160281g、菜单要与语境相关、如、不同权限的用户登陆一个应用程序、不同级别的用户可以看到不同级别的菜单并使用不同级别的功能；51Testing软件测试网O.j6uYO
    h、鼠标右键快捷菜单。    51Testing软件测试网6j"BE'mwU eFM

    特殊属性51Testing软件测试网&TyoF k

    1、安装界面应有公司介绍或产品介绍、有公司的图标；
    T*]q:ccih n1602812、主界面及大多数界面最好有公司图标；
    z3aR.]m U#jR,u1602813、选择“帮助”->“关于”命令、应看见相关版权和产品信息。

    查看(523) 评论(1) 收藏 分享 管理

Open Toolbar