默认情况下用户创建的任务栈大小是由参数Task stack size决定的。
    如果觉得每个任务都分配同样大小的栈空间不方便的话，可以采用自定义任务栈的方式创建任务。采用自定义方式更灵活些

    由于Cortex-M3和M4内核具有双堆栈指针，MSP主堆栈指针和PSP进程堆栈指针，或者叫PSP任务堆栈指针也是可以的。

    在RTX操作系统中，主堆栈指针MSP是给系统栈空间使用的，进程堆栈指针PSP是给任务栈使用的。
    也就是说，在RTX任务中，所有栈空间的使用都是通过PSP指针进行指向的。一旦进入了中断函数已经可能发生的中断嵌套都是用的MSP指针

    实际应用中系统栈空间分配多大，主要是看可能发生的中断嵌套层数，下面我们就按照最坏执行情况进行考虑，所有的寄存器都需要入栈，此时分为两种情况：
    64字节 对于Cortex-M3内核和未使用FPU（浮点运算单元）功能的Cortex-M4内核在发生中断时需要将16个通用寄存器全部入栈，每个寄存器占用4个字节，也就是16*4 = 64字节的空间。 可能发生几次中断嵌套就是要64乘以几即可。当然，这种是最坏执行情况，也就是所有的寄存器都入栈。 （注：任务执行的过程中发生中断的话，有8个寄存器是自动入栈的，这个栈是任务栈，进入中断以后其余寄存器入栈以及发生中断嵌套都是用的系统栈）。
    200字节 对于具有FPU（浮点运算单元）功能的Cortex-M4内核，如果在任务中进行了浮点运算，那么在发生中断的时候除了16个通用寄存器需要入栈，还有34个浮点寄存器也是要入栈的，也就是(16+34)*4 = 200字节的空间。当然，这种是最坏执行情况，也就是所有的寄存器都入栈。（注：任务执行的过程中发送中断的话，有8个通用寄存器和18个浮点寄存器是自动入栈的，这个栈是任务栈，进入中断以后其余通用寄存器和浮点寄存器入栈以及发生中断嵌套都是用的系统栈。）。

os_sys_init()

  1. void os_sys_init (
    2. 

  2.     void (*task)(void) );  /* 操作系统启动后执行的任务 */

函数描述:

    该方法初始化并启动操作系统内核.
    参数为系统初始化完成之后启动的任务的指针. 内核给予该任务默认的优先级1.

注意要点:

    该函数在 rtl.h中定义.
    该方法必须在主函数中调用main.
    该任务使用默认的堆栈大小,该大小在 rtx_config.c中为任务定义.

返回值:

    该函数不返回,函数会直接开始执行参数中指向的方法.

演示:

  1. #include <rtl.h>
    2. 

    3. 

  3. void main (void) {
    4. 

  4.   os_sys_init (task1);  /* start the kernel     */
    5. 

  5.   while(1);             /* will never come here */
    6. 

  6. }

os_sys_init_prio

  1. void os_sys_init_prio (
    2. 

  2.     void (*task)(void),   /* Task to start */
    3. 

  3.     U8 priority);         /* Task priority (1-254) */

函数描述:

    该函数初始化并启动RTX内核.
    task指针指向启动后系统执行的第一个任务.
    优先级参数设置系统启动之后的第一个执行的任务的优先级. 默认优先级为1. 优先级0为空闲任务保留. 如果设置参数值为0,他会自动被参数1取代. 优先级255同样被保留.
    该函数定义在rtl.h.

注意要点:

    该函数必须在main函数中被调用. 
    该任务使用默认的堆栈大小,该大小在 rtx_config.c中为任务定义. 
    优先级255表示最重要任务,优先级越高,任务越重要.

返回值:

    函数不返回,直接开始执行参数中指定的方法任务

演示:

  1. #include <rtl.h>
    2. 

    3. 

  3. void main (void) {
    4. 

  4.   os_sys_init_prio (task1, 10);
    5. 

  5.   while(1);
    6. 

  6. }

os_sys_init_user

  1. void os_sys_init_user (
    2. 

  2.     void (*task)(void),    /* Task to start */
    3. 

  3.     U8    priority,        /* Task priority (1-254) */
    4. 

  4.     void* stack,           /* Task stack */
    5. 

  5.     U16   size);           /* Stack size */

函数描述:

    初始化并启动操作系统内核. 当启动任务需要比较大的堆栈的时候使用该函数,可以自定义堆栈.
    task参数指向系统启动后执行的第一个任务的指针.
    优先级参数设置系统启动之后的第一个执行的任务的优先级. 默认优先级为1. 优先级0为空闲任务保留. 如果设置参数值为0,他会自动被参数1取代. 优先级255同样被保留.
    stack参数指向启动任务将使用的堆栈的开头.
    size表明任务堆栈的大小.
    该函数定义在rtl.h.

该函数定义在rtl.h.注意要点:

    T该函数必须在main函数中被调用. 
    任务栈空间必须8字节对齐，可以将任务栈数组定义成uint64_t类型即可(unsigned long long). 
    默认的堆栈大小,该大小在 rtx_config.c中为任务定义.
    优先级255表示最重要任务,优先级越高,任务越重要.

返回值:

    函数不返回,直接开始执行参数中指定的方法任务.

演示:

  1. static U64 stk1[400/8];    /* 400-byte stack */
    2. 

    3. 

  3. void main (void) {
    4. 

  4.   os_sys_init_user (task1, 10, &stk1, sizeof(stk1));
    5. 

  5.   while(1);
    6. 

  6. }

os_tsk_create

  1. OS_TID os_tsk_create (
    2. 

  2.     void (*task)(void),    /* Task to create */
    3. 

  3.     U8    priority );      /* Task priority (1-254) */

函数描述:

    该任务创建一个任务,任务指向task指针指向的方法,函数将动态的创建一个任务表示符TID,并将该任务放到系统就绪任务队列中. 
    优先级参数设置系统启动之后的第一个执行的任务的优先级. 默认优先级为1. 优先级0为空闲任务保留. 如果设置参数值为0,他会自动被参数1取代. 优先级255同样被保留. 
    如果新创建的了任务优先级高于当前正在执行的任务,将引发一次调度,系统执行更高优先级的任务.
    该函数定义在rtl.h.

注意要点:

    该API创建的任务使用rtx_config.c定义的堆栈大小创建任务.
    优先级255表示最重要任务,优先级越高,任务越重要.

返回值:

   该函数返回创建的任务的标识符TID. 如果函数调用失败,将会返回0.

演示:

  1. OS_TID tsk1, tsk2;
    2. 

    3. 

  3. __task void task1 (void) {
    4. 

  4.    ..
    5. 

  5.   tsk2 = os_tsk_create (task2, 1);
    6. 

  6.    ..
    7. 

  7. }
    8. 

    9. 

  9. __task void task2 (void) {
    10. 

  10.    ..
    11. 

  11. }

os_tsk_create_ex

  1. OS_TID os_tsk_create_ex (
    2. 

  2.     void (*task)(void *),    /* Task to create */
    3. 

  3.     U8    priority,          /* Task priority (1-254) */
    4. 

  4.     void* argv );            /* Argument to the task */

函数描述:

    该任务创建一个任务,任务指向task指针指向的方法,函数将动态的创建一个任务表示符TID,并将该任务放到系统就绪任务队列中. 该函数是os_tsk_create的扩展方法,可以支持先task指针指定的任务发送一个参数argv.
    优先级参数设置系统启动之后的第一个执行的任务的优先级. 默认优先级为1. 优先级0为空闲任务保留. 如果设置参数值为0,他会自动被参数1取代. 优先级255同样被保留. .
    argv参数在创建的任务被启动的时候,被系统传递给该任务. 该函数对于同一方法的多个任务的模式下比较实用.
    该函数定义在rtl.h.

注意要点:

    函数定义任务的时候使用rtx_config.c中指定的任务堆栈大小

返回值:

    该函数返回创建的任务的标识符TID. 如果函数调用失败,将会返回0.

演示:

  1. #include <rtl.h>
    2. 

    3. 

  3. OS_TID tsk1, tsk2_0, tsk2_1;
    4. 

  4. int param[2] = {0, 1};
    5. 

    6. 

  6. __task void task1 (void) {
    7. 

  7.    ..
    8. 

  8.   tsk2_0 = os_tsk_create_ex (task2, 1, &param[0]);
    9. 

  9.   tsk2_1 = os_tsk_create_ex (task2, 1, &param[1]);
    10. 

  10.    ..
    11. 

  11. }
    12. 

    13. 

  13. __task void task2 (void *argv) {
    14. 

  14.    ..
    15. 

  15.   switch (*(int *)argv) {
    16. 

  16.     case 0:
    17. 

  17.       printf("This is a first instance of task2.\n");
    18. 

  18.       break;
    19. 

  19.     case 1:
    20. 

  20.       printf("This is a second instance of task2.\n");
    21. 

  21.       break;
    22. 

  22.   }
    23. 

  23.    ..
    24. 

  24. }

os_tsk_create_user

  1. OS_TID os_tsk_create_user(
    2. 

  2.     void (*task)(void),    /* Task to create */
    3. 

  3.     U8    priority,        /* Task priority (1-254) */
    4. 

  4.     void* stk,             /* Pointer to the task's stack */
    5. 

  5.     U16   size );          /* Number of bytes in the stack */

函数描述:

    该任务创建一个任务,任务指向task指针指向的方法,函数将动态的创建一个任务表示符TID,并将该任务放到系统就绪任务队列中. 该函数支持为任务定义私有堆栈区. 在任务需要一个大的堆栈的时候该函数比较实用.
    优先级参数设置系统启动之后的第一个执行的任务的优先级. 默认优先级为1. 优先级0为空闲任务保留. 如果设置参数值为0,他会自动被参数1取代. 优先级255同样被保留.如果新创建的了任务优先级高于当前正在执行的任务,将引发一次调度,系统执行更高优先级的任务.
    第3个参数是任务栈地址.   第4个参数是任务栈大小,单位是字节.
    该函数定义在rtl.h.

注意要点:

    任务栈空间必须8字节对齐，可以将任务栈数组定义成uint64_t类型即可 (unsigned long long). 

返回值:

    该函数返回创建的任务的标识符TID. 如果函数调用失败,将会返回0.

演示:

  1. OS_TID tsk1,tsk2;
    2. 

  2. static U64 stk2[400/8];
    3. 

    4. 

  4. __task void task1 (void) {
    5. 

  5.    ..
    6. 

  6.   /* Create task 2 with a bigger stack */
    7. 

  7.   tsk2 = os_tsk_create_user (task2, 1, &stk2, sizeof(stk2));
    8. 

  8.    ..
    9. 

  9. }
    10. 

    11. 

  11. __task void task2 (void) {
    12. 

  12.   /* We need a bigger stack here. */
    13. 

  13.   U8 buf[200];
    14. 

  14.    ..
    15. 

  15. }

os_tsk_create_user_ex

  1. OS_TID os_tsk_create_user_ex (
    2. 

  2.     void (*task)(void *),    /* Task to create */
    3. 

  3.     U8    priority,          /* Task priority (1-254) */
    4. 

  4.     void* stk,               /* Pointer to the task's stack */
    5. 

  5.     U16   size,              /* Size of stack in bytes */
    6. 

  6.     void* argv );            /* Argument to the task */

函数描述:

    该任务创建一个任务,任务指向task指针指向的方法,函数将动态的创建一个任务表示符TID,并将该任务放到系统就绪任务队列中. 该函数支持为任务定义私有堆栈区. 在任务需要一个大的堆栈的时候该函数比较实用.同时还可以向任务传递一个argv参数.
    优先级参数设置系统启动之后的第一个执行的任务的优先级. 默认优先级为1. 优先级0为空闲任务保留. 如果设置参数值为0,他会自动被参数1取代. 优先级255同样被保留.如果新创建的了任务优先级高于当前正在执行的任务,将引发一次调度,系统执行更高优先级的任务.
    第3个参数是任务栈地址.   第4个参数是任务栈大小,单位是字节.
    argv参数在创建的任务被启动的时候,被系统传递给该任务. 该函数对于同一方法的多个任务的模式下比较实用.

注意要点:

    任务栈空间必须8字节对齐，可以将任务栈数组定义成uint64_t类型即可 (unsigned long long). 

返回值:

    该函数返回创建的任务的标识符TID. 如果函数调用失败,将会返回0.

演示:

  1. #include <rtl.h>
    2. 

    3. 

  3. OS_TID tsk1,tsk2_0,tsk2_1;
    4. 

  4. static U64 stk2[2][400/8];
    5. 

    6. 

  6. __task void task1 (void) {
    7. 

  7.    ..
    8. 

  8.   /* Create task 2 with a bigger stack */
    9. 

  9.   tsk2_0 = os_tsk_create_user_ex (task2, 1,
    10. 

  10.                                   &stk2[0], sizeof(stk2[0]),
    11. 

  11.                                   (void *)0);
    12. 

  12.   tsk2_1 = os_tsk_create_user_ex (task2, 1,
    13. 

  13.                                   &stk2[1], sizeof(stk2[1]),
    14. 

  14.                                   (void *)1);
    15. 

  15.    ..
    16. 

  16. }
    17. 

    18. 

  18. __task void task2 (void *argv) {
    19. 

  19.   /* We need a bigger stack here. */
    20. 

  20.   U8 buf[200];
    21. 

    22. 

  22.    ..
    23. 

  23.   switch ((int)argv) {
    24. 

  24.     case 0:
    25. 

  25.       printf("This is a first instance of task2.\n");
    26. 

  26.       break;
    27. 

  27.     case 1:
    28. 

  28.       printf("This is a second instance of task2.\n");
    29. 

  29.       break;
    30. 

  30.   }
    31. 

  31.    ..
    32. 

  32. }

os_tsk_delete

  1. OS_RESULT os_tsk_delete (
    2. 

  2.     OS_TID task_id );    /* Id of the task to delete */

函数描述:

    当任务完成所有工作并不再想要的时候,可以调用该函数停止并删除任务,依靠task_id来停止并删除任务

注意要点:

    如果task_id为0,则当前正在执行的任务被停止和删除. 程序将执行就绪队列中的下一个就绪任务.

返回值:

    如果任务删除成功，函数返回OS_R_OK，其余所有情况返回OS_R_NOK，比如所写的任务ID不存在.

演示:

  1. #include <rtl.h>
    2. 

  2. OS_TID tsk3;
    3. 

    4. 

  4. __task void task2 (void) {
    5. 

  5.   tsk3 = os_tsk_create (task3, 0);
    6. 

  6.    ..
    7. 

  7.   if (os_tsk_delete (tsk3) == OS_R_OK) {
    8. 

  8.     printf("\n'task 3' deleted.");
    9. 

  9.   }
    10. 

  10.   else {
    11. 

  11.     printf ("\nFailed to delete 'task 3'.");
    12. 

  12.   }
    13. 

  13. }
    14. 

    15. 

  15. __task void task3 (void) {
    16. 

  16.    ..
    17. 

  17. }

os_tsk_delete_self

  1. #include <rtl.h>
    2. 

    3. 

  3. void os_tsk_delete_self (void);

函数描述:

    该函数停止并删除当前正在执行的任务,程序将执行就绪队列中的下一个就绪任务.

注意要点:

    该函数没有返回.,程序将执行就绪队列中的下一个就绪任务

返回值:

    该函数没有返回.,程序将执行就绪队列中的下一个就绪任务.

演示:

  1. #include <rtl.h>
    2. 

    3. 

  3. __task void task2 (void) {
    4. 

  4.    ..
    5. 

  5.   os_tsk_delete_self();
    6. 

  6. }

os_tsk_pass

  1. #include <rtl.h>
    2. 

    3. 

  3. void os_tsk_pass (void);

函数描述:

    该函数将切换到和当前任务优先级相同的就绪队列中的其他任务. 如果就绪队列中没有相同优先级的任务, 当前任务将继续执行且没有任务切换发生。

注意要点:

    可以用该方法在相同优先级的几个任务之间切换.

返回值:

    None

演示:

  1. #include <rtl.h>
    2. 

    3. 

  3. OS_TID tsk1;
    4. 

    5. 

  5. __task void task1 (void) {
    6. 

  6.    ..
    7. 

  7.   os_tsk_pass();
    8. 

  8.    ..
    9. 

  9. }

os_tsk_prio

  1. OS_RESULT os_tsk_prio (
    2. 

  2.     OS_TID task_id,       /* ID of the task */
    3. 

  3.     U8     new_prio );    /* New priority of the task (1-254) */

函数描述:

    该函数将修改task_id指定的任务的优先级.
    如果新设置的优先级比当前执行的任务的优先级高,那么任务切换将会切换到task_id指定的任务并执行,同时优先级被修改. 如果低,那么依然执行当前任务.
    如果task_id为0,修改的优先级是当前运行任务的优先级.

注意要点:

    新优先级的取值为1-254.
    新的优先级将一直保持直到你再次修改它. 
    优先级0是idle任务的优先级,如果设置某个任务优先级为0,程序将自动修改为1,255是保留优先级,也是一样的. 
    优先级数值越大,优先级越高.

返回值:

    返回值如下所示:

演示:

  1. #include <RTL.h>
    2. 

    3. 

  3. OS_TID tsk1,tsk2;
    4. 

    5. 

  5. __task void task1 (void) {
    6. 

  6.    ..
    7. 

  7.   os_tsk_prio_self (5);
    8. 

    9. 

  9.   /* Changing the priority of task2 will cause a task switch. */
    10. 

  10.   os_tsk_prio(tsk2, 10);
    11. 

  11.    ..
    12. 

  12. }
    13. 

    14. 

  14. __task void task2 (void) {
    15. 

  15.    ..
    16. 

  16.   /* Change priority of this task will cause task switch. */
    17. 

  17.   os_tsk_prio_self (1);
    18. 

  18.    ..
    19. 

  19. }

os_tsk_prio_self

  1. #include <rtl.h>
    2. 

    3. 

  3. OS_RESULT os_tsk_prio_self (
    4. 

  4.     U8 new_prio );    /* New priority of task (1-254) */

函数描述:

    修改当前运行任务的优先级为新的优先级.

注意要点:

    新优先级的取值为1-254.
    新的优先级将一直保持直到你再次修改它. 
    优先级0是idle任务的优先级,如果设置某个任务优先级为0,程序将自动修改为1,255是保留优先级,也是一样的. 
    优先级数值越大,优先级越高.. 

返回值:

    该函数始终返回 OS_R_OK.

演示:

  1. #include <rtl.h>
    2. 

    3. 

  3. OS_TID tsk1;
    4. 

    5. 

  5. __task void task1 (void) {
    6. 

  6.    ..
    7. 

  7.   os_tsk_prio_self(10);  /* Increase its priority, for the critical section */
    8. 

  8.    ..                    /* This is a critical section */
    9. 

  9.    ..
    10. 

  10.   os_tsk_prio_self(2);   /* Decrease its priority at end of critical section */
    11. 

  11.    ..
    12. 

  12. }

os_tsk_self

  1. #include <rtl.h>
    2. 

    3. 

  3. OS_TID os_tsk_self (void);

函数描述:

    该函数将返回当前运行任务的标识符,也就是TID.

注意要点:

    无

返回值:

    返回当前执行任务的TID标识符.

演示:

  1. #include <rtl.h>
    2. 

    3. 

  3. OS_TID tsk1;
    4. 

    5. 

  5. __task void task1 (void) {
    6. 

  6.   tsk1 = os_tsk_self();
    7. 

  7.    ..
    8. 

  8. }

isr_tsk_get

  1. #include <rtl.h>
    2. 

    3. 

  3. OS_TID isr_tsk_get (void);

函数描述:

    该函数返回当前正在运行的中断任务的标识符TID.

注意要点:

    该函数只能在ISR任务中调用.

返回值:

    该函数返回当前正在运行的中断任务的标识符TID.

演示:

  1. #include <rtl.h>
    2. 

    3. 

  3. void os_error (U32 err_code) {
    4. 

  4.   /* This function is called when a runtime error is detected. */
    5. 

  5.   OS_TID err_task;
    6. 

    7. 

  7.   switch (err_code) {
    8. 

  8.     case OS_ERR_STK_OVF:
    9. 

  9.       /* Identify the task with stack overflow. */
    10. 

  10.       err_task = isr_tsk_get();
    11. 

  11.       break;
    12. 

  12.     case OS_ERR_FIFO_OVF:
    13. 

  13.       break;
    14. 

  14.     case OS_ERR_MBX_OVF:
    15. 

  15.       break;
    16. 

  16.   }
    17. 

  17.   for (;;);
    18. 

  18. }










































RTX任务管理的更多相关文章

  1. RTX——第7章 任务管理

    以下内容转载自安富莱电子: http://forum.armfly.com/forum.php 单任务系统学习多任务系统之前,我们先来回顾下单任务系统的编程框架,即裸机时的编程框架. 裸机编程主要是采 ...

  2. RTX基础教程目录

    以下RTX教程转载自安富莱电子论坛: http://forum.armfly.com/forum.php?mod=viewthread&tid=16909&extra=page%3D1 ...

  3. RTX——第13章 事件标志组

    以下内容转载自安富莱电子: http://forum.armfly.com/forum.php 前面的章节我们已经讲解了任务管理和时间管理,从本章节开始讲解任务间的通信和同步机制.首先讲解任务间的通信 ...

  4. PHP实现RTX发送消息提醒

    RTX是腾讯公司推出的企业级即时通信平台,大多数公司都在使用它,但是我们很多时候需要将自己系统或者产品的一些通知实时推送给RTX,这就需要用到RTX的服务端SDK,建议先去看看RTX的SDK开发文档( ...

  5. BPM任务管理解决方案分享

    一.方案概述任务是企业管理者很多意志的直接体现,对于非常规性事务较多的企业,经常存在各类公司下达的各种任务跟进难.监控难等问题,任务不是完成效果不理解,就是时间超期,甚至很多公司管理层下达的任务都不了 ...

  6. 用Excel做出比肩任务管理软件的操作技巧

    用Excel做出比肩任务管理软件的操作技巧 在项目管理中,网上有各种各样的工具可以选择,到底用哪个,曾一度困扰着我.我是一个有轻度强迫症的人,总是喜欢试用各种各样的系统,以比较他们之间的不同,试图选择 ...

  7. [No00008D]腾讯通RTX联系方式批量获取

    公司用的RTX让我一直很不爽,QQ比RTX好多少为啥不让用,微信都有企业版了为啥还用腾讯通?终于今天发现唯一的好处是可以从服务器上拉公司妹子们的联系方式!!当然,我要这些联系方式,只是为了联tiao系 ...

  8. Quartz.NET总结（五）基于Quartz.net 的开源任务管理平台

    前面总结了很多,关于Quartz.net 的文章,介绍了如何使用Quartz.net.不清楚的朋友,可以看我之前的系列文章,http://www.cnblogs.com/zhangweizhong/c ...

  9. .NET轻量级任务任务管理类

    概述 最近做项目总是遇到服务跑批等需求,一直想写个任务管理的DLL,现在整理了一下思路,编写了一个DLL类库,使用方便.只要调用的子类继承服务基类便可以实现任务的整体调度.先看看页面效果: 使用方式 ...

随机推荐

  1. Cocos Creator 节点

    //节点从创建到节点挂载一些过程 1.JS中节点使用: a.创建:在properties中定义节点(可能包括节点的默认值和类型): b.挂载:在相应的方法中获取节点获取相应节点,挂载到父元素 例== ...

  2. python控制流

    1. if...elif...else: 语法: if 判断条件: 语句... elif 判断条件: 语句... else: 语句... #elif语句可以有0个或多个 2. while和for循环: ...

  3. Spring IOC基础使用

    先下载.导入核心jar包 编写Book类和CollectionUse类 package MyPackageOne; public class Book { private String title; ...

  4. HDU 4786 Fibonacci Tree 最小生成树

    Fibonacci Tree 题目连接: http://acm.hdu.edu.cn/showproblem.php?pid=4786 Description Coach Pang is intere ...

  5. linux之测试硬盘速度篇

    作业三:dd命令测试硬盘速度 [root@localhost 桌面]# dd if=/dev/sdc2 of=/a.txt bs=2M count=2 记录了0+1 的读入 记录了0+1 的写出 10 ...

  6. mvc中使用Pagination，对其进行再封装

    对其进行再次封装: (function($) { $["fn"]["easyPaging"] = function(o) { if (!o.pageSelect ...

  7. jQuery 学习(2)——jQuery选择器

    1.jQuery为元素添加CSS样式如下: <div id="tt1">单个样式:css()内"属性名称","value"< ...

  8. Dijskstra算法

    #include <iostream> #include <cstdio> #include <queue> #include <vector> usi ...

  9. 如何修改IE浏览器的User-Agent用户代理字符串信息

    每款浏览器都有一个专属的 User-Agent 字符串信息, 通过 User-Agent 网站可以检测用户所使用的浏览器版本.某些网站为了让用户获得更好的浏览体验,通过检测用户的浏览器版本,以确认用户 ...

  10. Class：DbConnectionManipulator.cs

    ylbtech-Class:DbConnectionManipulator.cs 1.返回顶部 1.DbConnectionManipulator.cs using System; using Sys ...