精华内容
下载资源
问答
  • 在实际项目开发中,业务逻辑层的处理...SQL池是SQL容器,用于存放业务逻辑层抛过来的SQL语句。SQL池主要提供以下几种方法: 1)internal string Pop(),从池中取出SQL。 2)internal void Push(string item),增加一个S
  • 在实际项目开发中,业务逻辑层的处理速度...好,下面我就为大家介绍一种方法:构建SQL池,分离业务逻辑层和数据访问层,让业务逻辑层从低效的数据库操作解脱,以提高系统整体性能。 (一)SQL池  SQL池是SQL容...

     在实际项目开发中,业务逻辑层的处理速度往往很快,特别是在开发Socket通信服务的时候,网络传输很快,但是一旦加上数据库操作,性能一落千丈,数据库操作的效率往往成为一个系统整体性能的瓶颈。面对这问题,我们怎么办呢?好,下面我就为大家介绍一种方法:构建SQL池,分离业务逻辑层和数据访问层,让业务逻辑层从低效的数据库操作解脱,以提高系统整体性能。

    (一)SQL池

      SQL池是SQL容器,用于存放业务逻辑层抛过来的SQL语句。SQL池主要提供以下几种方法:

    1)internal string Pop(),从池中取出SQL。

    2)internal void Push(string item),增加一个SQL到池中。

    3)internal string[] Clear(),清空SQL池,清空前,返回SQL池中所有SQL语句。

      特别提醒一下,SQL池是面向多线程的,所以必须对公共资源SQL采取锁机制。这里采用互斥锁,当业务逻辑层线程往SQL池中抛入SQL语句时,禁止SQL执行线程执行SQL语句,反之,当SQL执行线程执行SQL语句时,也不允许业务逻辑层线程往SQL池中抛入SQL语句。为什么要这么做?因为SQL执行线程是批量执行SQL语句,在批量执行SQL语句前,会从池中取出所有SQL语句,如果此时业务逻辑层线程往SQL池中抛入SQL语句,则会导致这些SQL语句丢失,得不到执行。

      下面是SQL池代码:

     

    01 using System;
    02 using System.Collections.Generic;
    03 using System.Linq;
    04 using System.Text;
    05 using System.Threading;
    06   
    07 namespace Test1
    08 {
    09     sealed class SQLPool
    10     {
    11         //互斥锁
    12         public static Mutex mutexSQLPool = new Mutex();
    13   
    14         //SQL池
    15         Stack<string> pool;
    16   
    17         /// <summary>
    18         /// 初始化SQL池
    19         /// </summary>
    20         internal SQLPool()
    21         {
    22             this.pool = new Stack<string>();
    23         }
    24   
    25   
    26         /// <summary>
    27         /// 获取SQL池数量
    28         /// </summary>
    29         internal Int32 Count
    30         {
    31             get { return this.pool.Count; }
    32         }
    33   
    34   
    35         /// <summary>
    36         /// 从池中取出SQL
    37         /// </summary>
    38         /// <returns></returns>
    39         internal string Pop()
    40         {
    41             lock (this.pool)
    42             {
    43                 return this.pool.Pop();
    44             }
    45         }
    46   
    47   
    48         /// <summary>
    49         /// 增加一个SQL到池中
    50         /// </summary>
    51         /// <param name="item"></param>
    52         internal void Push(string item)
    53         {
    54             if (item.Trim() == "")
    55             {
    56                 throw new ArgumentNullException("Items added to a SQLPool cannot be null");
    57             }
    58   
    59             //此处向SQL池中push SQL必须与Clear互斥
    60             mutexSQLPool.WaitOne();
    61             try
    62             {
    63                 this.pool.Push(item);    //此处如果出错,则不会执行ReleaseMutex,将会死锁
    64             }
    65             catch
    66             
    67             }
    68             mutexSQLPool.ReleaseMutex();
    69         }
    70   
    71   
    72         /// <summary>
    73         /// 清空SQL池
    74         /// 清空前,返回SQL池中所有SQL语句,
    75         /// </summary>
    76         internal string[] Clear()
    77         {
    78             string[] array = new string[] { };
    79   
    80             //此处必须与Push互斥
    81             mutexSQLPool.WaitOne();
    82             try
    83             {
    84                 array = this.pool.ToArray();     //此处如果出错,则不会执行ReleaseMutex,将会死锁
    85                 this.pool.Clear();
    86             }
    87             catch
    88             
    89             }
    90             mutexSQLPool.ReleaseMutex();
    91   
    92             return array;
    93         }
    94     }
    95 }

     

    (二)SQL池管理

      SQL池管理主要用于管理SQL池,向业务逻辑层线程和SQL执行线程提供接口。

      业务逻辑层线程调用 public void PushSQL(string strSQL) 方法,用于向SQL池抛入SQL语句。

      SQL执行线程调用 public void ExecuteSQL(object obj) 方法,用于批量执行SQL池中的SQL语句。

      注意,SQL池管理类采用单例模型,为什么要采用单例模型?因为SQL池只能存在一个实例,无论是业务逻辑层线程还是SQL执行线程,仅会操作这一个实例,否则,将会导致SQL池不唯一,SQL执行无效。

      下面是SQL池管理类代码:

     

    01 using System;
    02 using System.Collections.Generic;
    03 using System.Linq;
    04 using System.Text;
    05   
    06 namespace Test1
    07 {
    08     class SQLPoolManage
    09     {
    10         //单例模型
    11         public static readonly SQLPoolManage sqlPoolManage = new SQLPoolManage();
    12   
    13         #region 属性
    14         SQLPool poolOfSQL;
    15         #endregion
    16   
    17   
    18         #region 构造函数
    19         /// <summary>
    20         /// 初始化
    21         /// </summary>
    22         public SQLPoolManage()
    23         {
    24             this.poolOfSQL = new SQLPool();
    25         }
    26         #endregion
    27   
    28   
    29         #region 方法
    30         /// <summary>
    31         /// 将SQL语句加入SQL池中
    32         /// </summary>
    33         /// <param name="strSQL"></param>
    34         public void PushSQL(string strSQL)
    35         {
    36             this.poolOfSQL.Push(strSQL);
    37         }
    38   
    39   
    40         /// <summary>
    41         /// 每隔一段时间,触发ExecuteSQL
    42         /// ExecuteSQL用于执行SQL池中的SQL语句
    43         /// </summary>
    44         /// <param name="obj"></param>
    45         public void ExecuteSQL(object obj)
    46         {
    47             if (this.poolOfSQL.Count > 0)
    48             {
    49                 string[] array = this.poolOfSQL.Clear();
    50                 //遍历array,执行SQL
    51                 for (int i = 0; i < array.Length; i++)
    52                 {
    53                     if (array[i].ToString().Trim() != "")
    54                     {
    55                         try
    56                         {
    57                             //数据库操作
    58                             //......
    59                         }
    60                         catch
    61                         
    62                         }
    63                     }
    64                 }
    65             }
    66         }
    67         #endregion
    68   
    69     }
    70 }

     

     

    (三)定时触发SQL执行线程

      总结有以下三种方法,具体请参见http://www.cnblogs.com/tianzhiliang/archive/2010/08/31/1813928.html

    方法一:调用线程执行方法,在方法中实现死循环,每个循环Sleep设定时间;

    方法二:使用System.Timers.Timer类;

    方法三:使用System.Threading.Timer;

      代码如下:

     

    01 using System;
    02 using System.Collections.Generic;
    03 using System.Linq;
    04 using System.Text;
    05   
    06 using System.Threading;
    07   
    08 namespace Test1
    09 {
    10   
    11     class Program
    12     {
    13         static void Main(string[] args)
    14         {
    15             //向SQL池中抛入SQL语句
    16             SQLPoolManage.sqlPoolManage.PushSQL("delete from tbl_test where id = 1");
    17   
    18             //定时触发SQL执行线程
    19             System.Threading.Timer threadTimer = new System.Threading.Timer(new System.Threading.TimerCallback(SQLPoolManage.sqlPoolManage.ExecuteSQL), null, 0, 100);
    20   
    21             Console.ReadLine();
    22         }
    23     }
    24 }

    转载于:https://www.cnblogs.com/majier/archive/2011/09/05/2781827.html

    展开全文
  • Windows服务定时执行sql

    2018-08-18 10:55:59
    C#开发的windows服务程序,使用frameworks4.0框架,在app.config里配置好数据库连接,间隔时间(秒),要执行sql命令,在log.txt里记录服务执行记录。
  • c#实现用SQL池(多线程),定时批量执行SQL语句  在实际项目开发中,业务逻辑层的处理速度往往很快,特别是在开发Socket通信服务的时候,网络传输很快,但是一旦加上数据库操作,性能一落千丈,数据库操作的...

    c#实现用SQL池(多线程),定时批量执行SQL语句

      在实际项目开发中,业务逻辑层的处理速度往往很快,特别是在开发Socket通信服务的时候,网络传输很快,但是一旦加上数据库操作,性能一落千丈,数据库操作的效率往往成为一个系统整体性能的瓶颈。面对这问题,我们怎么办呢?好,下面我就为大家介绍一种方法:构建SQL池,分离业务逻辑层和数据访问层,让业务逻辑层从低效的数据库操作解脱,以提高系统整体性能。

    (一)SQL池

      SQL池是SQL容器,用于存放业务逻辑层抛过来的SQL语句。SQL池主要提供以下几种方法:

    1)internal string Pop(),从池中取出SQL。

    2)internal void Push(string item),增加一个SQL到池中。

    3)internal string[] Clear(),清空SQL池,清空前,返回SQL池中所有SQL语句。

      特别提醒一下,SQL池是面向多线程的,所以必须对公共资源SQL采取锁机制。这里采用互斥锁,当业务逻辑层线程往SQL池中抛入SQL语句时,禁止SQL执行线程执行SQL语句,反之,当SQL执行线程执行SQL语句时,也不允许业务逻辑层线程往SQL池中抛入SQL语句。为什么要这么做?因为SQL执行线程是批量执行SQL语句,在批量执行SQL语句前,会从池中取出所有SQL语句,如果此时业务逻辑层线程往SQL池中抛入SQL语句,则会导致这些SQL语句丢失,得不到执行。

      下面是SQL池代码:

     

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    
    namespace Test1
    {
        sealed class SQLPool
        {
            //互斥锁
            public static Mutex mutexSQLPool = new Mutex();
    
            //SQL池
            Stack<string> pool;
    
            /// <summary>
            /// 初始化SQL池
            /// </summary>
            internal SQLPool()
            {
                this.pool = new Stack<string>();
            }
    
    
            /// <summary>
            /// 获取SQL池数量
            /// </summary>
            internal Int32 Count
            {
                get { return this.pool.Count; }
            }
    
    
            /// <summary>
            /// 从池中取出SQL
            /// </summary>
            /// <returns></returns>
            internal string Pop()
            {
                lock (this.pool)
                {
                    return this.pool.Pop();
                }
            }
    
    
            /// <summary>
            /// 增加一个SQL到池中
            /// </summary>
            /// <param name="item"></param>
            internal void Push(string item)
            {
                if (item.Trim() == "")
                {
                    throw new ArgumentNullException("Items added to a SQLPool cannot be null");
                }
    
                //此处向SQL池中push SQL必须与Clear互斥
                mutexSQLPool.WaitOne();
                try
                {
                    this.pool.Push(item);    //此处如果出错,则不会执行ReleaseMutex,将会死锁
                }
                catch
                { 
                }
                mutexSQLPool.ReleaseMutex();
            }
    
    
            /// <summary>
            /// 清空SQL池
            /// 清空前,返回SQL池中所有SQL语句,
            /// </summary>
            internal string[] Clear()
            {
                string[] array = new string[] { };
    
                //此处必须与Push互斥
                mutexSQLPool.WaitOne();
                try
                {
                    array = this.pool.ToArray();     //此处如果出错,则不会执行ReleaseMutex,将会死锁
                    this.pool.Clear();
                }
                catch
                { 
                }
                mutexSQLPool.ReleaseMutex();
    
                return array;
            }
        }
    }
    
    

     

    (二)SQL池管理

      SQL池管理主要用于管理SQL池,向业务逻辑层线程和SQL执行线程提供接口。

      业务逻辑层线程调用 public void PushSQL(string strSQL) 方法,用于向SQL池抛入SQL语句。

      SQL执行线程调用 public void ExecuteSQL(object obj) 方法,用于批量执行SQL池中的SQL语句。

      注意,SQL池管理类采用单例模型,为什么要采用单例模型?因为SQL池只能存在一个实例,无论是业务逻辑层线程还是SQL执行线程,仅会操作这一个实例,否则,将会导致SQL池不唯一,SQL执行无效。

      下面是SQL池管理类代码:

     

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace Test1
    {
        class SQLPoolManage
        {
            //单例模型
            public static readonly SQLPoolManage sqlPoolManage = new SQLPoolManage();
    
            #region 属性
            SQLPool poolOfSQL;
            #endregion
    
    
            #region 构造函数
            /// <summary>
            /// 初始化
            /// </summary>
            public SQLPoolManage()
            {
                this.poolOfSQL = new SQLPool();
            }
            #endregion
    
    
            #region 方法
            /// <summary>
            /// 将SQL语句加入SQL池中
            /// </summary>
            /// <param name="strSQL"></param>
            public void PushSQL(string strSQL)
            {
                this.poolOfSQL.Push(strSQL);
            }
    
    
            /// <summary>
            /// 每隔一段时间,触发ExecuteSQL
            /// ExecuteSQL用于执行SQL池中的SQL语句
            /// </summary>
            /// <param name="obj"></param>
            public void ExecuteSQL(object obj)
            {
                if (this.poolOfSQL.Count > 0)
                {
                    string[] array = this.poolOfSQL.Clear();
                    //遍历array,执行SQL
                    for (int i = 0; i < array.Length; i++)
                    {
                        if (array[i].ToString().Trim() != "")
                        {
                            try
                            {
                                //数据库操作
                                //......
                            }
                            catch
                            { 
                            }
                        }
                    }
                }
            }
            #endregion
    
        }
    }
    
    

     

     

    (三)定时触发SQL执行线程

      总结有以下三种方法,具体请参见http://www.cnblogs.com/tianzhiliang/archive/2010/08/31/1813928.html:

    方法一:调用线程执行方法,在方法中实现死循环,每个循环Sleep设定时间;

    方法二:使用System.Timers.Timer类;

    方法三:使用System.Threading.Timer;

      代码如下:

     

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    using System.Threading;
    
    namespace Test1
    {
    
        class Program
        {
            static void Main(string[] args)
            {
                //向SQL池中抛入SQL语句
                SQLPoolManage.sqlPoolManage.PushSQL("delete from tbl_test where id = 1");
    
                //定时触发SQL执行线程
                System.Threading.Timer threadTimer = new System.Threading.Timer(new System.Threading.TimerCallback(SQLPoolManage.sqlPoolManage.ExecuteSQL), null, 0, 100);
    
                Console.ReadLine();
            }
        }
    }
    
    
    展开全文
  • 在实际项目开发中,业务逻辑层的...好,下面我就为大家介绍一种方法:构建SQL池,分离业务逻辑层和数据访问层,让业务逻辑层从低效的数据库操作解脱,以提高系统整体性能。 (一)SQL池  SQL池是SQL容器,用于存放

    在实际项目开发中,业务逻辑层的处理速度往往很快,特别是在开发Socket通信服务的时候,网络传输很快,但是一旦加上数据库操作,性能一落千丈,数据库操作的效率往往成为一个系统整体性能的瓶颈。面对这问题,我们怎么办呢?好,下面我就为大家介绍一种方法:构建SQL池,分离业务逻辑层和数据访问层,让业务逻辑层从低效的数据库操作解脱,以提高系统整体性能。

    (一)SQL池

      SQL池是SQL容器,用于存放业务逻辑层抛过来的SQL语句。SQL池主要提供以下几种方法:

    1)internal string Pop(),从池中取出SQL。

    2)internal void Push(string item),增加一个SQL到池中。

    3)internal string[] Clear(),清空SQL池,清空前,返回SQL池中所有SQL语句。

      特别提醒一下,SQL池是面向多线程的,所以必须对公共资源SQL采取锁机制。这里采用互斥锁,当业务逻辑层线程往SQL池中抛入SQL语句时,禁止SQL执行线程执行SQL语句,反之,当SQL执行线程执行SQL语句时,也不允许业务逻辑层线程往SQL池中抛入SQL语句。为什么要这么做?因为SQL执行线程是批量执行SQL语句,在批量执行SQL语句前,会从池中取出所有SQL语句,如果此时业务逻辑层线程往SQL池中抛入SQL语句,则会导致这些SQL语句丢失,得不到执行。

      下面是SQL池代码:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
     
    namespace Test1
    {
        sealed class SQLPool
        {
            //互斥锁
            public static Mutex mutexSQLPool = new Mutex();
     
            //SQL池
            Stack<string> pool;
     
            /// <summary>
            /// 初始化SQL池
            /// </summary>
            internal SQLPool()
            {
                this.pool = new Stack<string>();
            }
     
     
            /// <summary>
            /// 获取SQL池数量
            /// </summary>
            internal Int32 Count
            {
                get { return this.pool.Count; }
            }
     
     
            /// <summary>
            /// 从池中取出SQL
            /// </summary>
            /// <returns></returns>
            internal string Pop()
            {
                lock (this.pool)
                {
                    return this.pool.Pop();
                }
            }
     
     
            /// <summary>
            /// 增加一个SQL到池中
            /// </summary>
            /// <param name="item"></param>
            internal void Push(string item)
            {
                if (item.Trim() == "")
                {
                    throw new ArgumentNullException("Items added to a SQLPool cannot be null");
                }
     
                //此处向SQL池中push SQL必须与Clear互斥
                mutexSQLPool.WaitOne();
                try
                {
                    this.pool.Push(item);    //此处如果出错,则不会执行ReleaseMutex,将会死锁
                }
                catch
                { 
                }
                mutexSQLPool.ReleaseMutex();
            }
     
     
            /// <summary>
            /// 清空SQL池
            /// 清空前,返回SQL池中所有SQL语句,
            /// </summary>
            internal string[] Clear()
            {
                string[] array = new string[] { };
     
                //此处必须与Push互斥
                mutexSQLPool.WaitOne();
                try
                {
                    array = this.pool.ToArray();     //此处如果出错,则不会执行ReleaseMutex,将会死锁
                    this.pool.Clear();
                }
                catch
                { 
                }
                mutexSQLPool.ReleaseMutex();
     
                return array;
            }
        }
    }
     

    (二)SQL池管理

      SQL池管理主要用于管理SQL池,向业务逻辑层线程和SQL执行线程提供接口。

      业务逻辑层线程调用 public void PushSQL(string strSQL) 方法,用于向SQL池抛入SQL语句。

      SQL执行线程调用 public void ExecuteSQL(object obj) 方法,用于批量执行SQL池中的SQL语句。

      注意,SQL池管理类采用单例模型,为什么要采用单例模型?因为SQL池只能存在一个实例,无论是业务逻辑层线程还是SQL执行线程,仅会操作这一个实例,否则,将会导致SQL池不唯一,SQL执行无效。

      下面是SQL池管理类代码:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
     
    namespace Test1
    {
        class SQLPoolManage
        {
            //单例模型
            public static readonly SQLPoolManage sqlPoolManage = new SQLPoolManage();
     
            #region 属性
            SQLPool poolOfSQL;
            #endregion
     
     
            #region 构造函数
            /// <summary>
            /// 初始化
            /// </summary>
            public SQLPoolManage()
            {
                this.poolOfSQL = new SQLPool();
            }
            #endregion
     
     
            #region 方法
            /// <summary>
            /// 将SQL语句加入SQL池中
            /// </summary>
            /// <param name="strSQL"></param>
            public void PushSQL(string strSQL)
            {
                this.poolOfSQL.Push(strSQL);
            }
     
     
            /// <summary>
            /// 每隔一段时间,触发ExecuteSQL
            /// ExecuteSQL用于执行SQL池中的SQL语句
            /// </summary>
            /// <param name="obj"></param>
            public void ExecuteSQL(object obj)
            {
                if (this.poolOfSQL.Count > 0)
                {
                    string[] array = this.poolOfSQL.Clear();
                    //遍历array,执行SQL
                    for (int i = 0; i < array.Length; i++)
                    {
                        if (array[i].ToString().Trim() != "")
                        {
                            try
                            {
                                //数据库操作
                                //......
                            }
                            catch
                            { 
                            }
                        }
                    }
                }
            }
            #endregion
     
        }
    }
     

     

    (三)定时触发SQL执行线程

      总结有以下三种方法,具体请参见http://www.cnblogs.com/tianzhiliang/archive/2010/08/31/1813928.html

    方法一:调用线程执行方法,在方法中实现死循环,每个循环Sleep设定时间;

    方法二:使用System.Timers.Timer类;

    方法三:使用System.Threading.Timer;

      代码如下:

     

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
     
    using System.Threading;
     
    namespace Test1
    {
     
        class Program
        {
            static void Main(string[] args)
            {
                //向SQL池中抛入SQL语句
                SQLPoolManage.sqlPoolManage.PushSQL("delete from tbl_test where id = 1");
     
                //定时触发SQL执行线程
                System.Threading.Timer threadTimer = new System.Threading.Timer(new System.Threading.TimerCallback(SQLPoolManage.sqlPoolManage.ExecuteSQL), null, 0, 100);
     
                Console.ReadLine();
            }
        }
    }

    展开全文
  • 在实际项目开发中,业务逻辑层的处理速度...好,下面我就为大家介绍一种方法:构建SQL池,分离业务逻辑层和数据访问层,让业务逻辑层从低效的数据库操作解脱,以提高系统整体性能。 (一)SQL池  SQL池是SQL容器...

    在实际项目开发中,业务逻辑层的处理速度往往很快,特别是在开发Socket通信服务的时候,网络传输很快,但是一旦加上数据库操作,性能一落千丈,数据库操作的效率往往成为一个系统整体性能的瓶颈。面对这问题,我们怎么办呢?好,下面我就为大家介绍一种方法:构建SQL池,分离业务逻辑层和数据访问层,让业务逻辑层从低效的数据库操作解脱,以提高系统整体性能。

    (一)SQL池

      SQL池是SQL容器,用于存放业务逻辑层抛过来的SQL语句。SQL池主要提供以下几种方法:

    1)internal string Pop(),从池中取出SQL。

    2)internal void Push(string item),增加一个SQL到池中。

    3)internal string[] Clear(),清空SQL池,清空前,返回SQL池中所有SQL语句。

      特别提醒一下,SQL池是面向多线程的,所以必须对公共资源SQL采取锁机制。这里采用互斥锁,当业务逻辑层线程往SQL池中抛入SQL语句时,禁止SQL执行线程执行SQL语句,反之,当SQL执行线程执行SQL语句时,也不允许业务逻辑层线程往SQL池中抛入SQL语句。为什么要这么做?因为SQL执行线程是批量执行SQL语句,在批量执行SQL语句前,会从池中取出所有SQL语句,如果此时业务逻辑层线程往SQL池中抛入SQL语句,则会导致这些SQL语句丢失,得不到执行。

      下面是SQL池代码:

     

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
      
    namespace Test1
    {
        sealed class SQLPool
        {
            //互斥锁
            public static Mutex mutexSQLPool = new Mutex();
      
            //SQL池
            Stack<string> pool;
      
            /// <summary>
            /// 初始化SQL池
            /// </summary>
            internal SQLPool()
            {
                this.pool = new Stack<string>();
            }
      
      
            /// <summary>
            /// 获取SQL池数量
            /// </summary>
            internal Int32 Count
            {
                get { return this.pool.Count; }
            }
      
      
            /// <summary>
            /// 从池中取出SQL
            /// </summary>
            /// <returns></returns>
            internal string Pop()
            {
                lock (this.pool)
                {
                    return this.pool.Pop();
                }
            }
      
      
            /// <summary>
            /// 增加一个SQL到池中
            /// </summary>
            /// <param name="item"></param>
            internal void Push(string item)
            {
                if (item.Trim() == "")
                {
                    throw new ArgumentNullException("Items added to a SQLPool cannot be null");
                }
      
                //此处向SQL池中push SQL必须与Clear互斥
                mutexSQLPool.WaitOne();
                try
                {
                    this.pool.Push(item);    //此处如果出错,则不会执行ReleaseMutex,将会死锁
                }
                catch
                
                }
                mutexSQLPool.ReleaseMutex();
            }
      
      
            /// <summary>
            /// 清空SQL池
            /// 清空前,返回SQL池中所有SQL语句,
            /// </summary>
            internal string[] Clear()
            {
                string[] array = new string[] { };
      
                //此处必须与Push互斥
                mutexSQLPool.WaitOne();
                try
                {
                    array = this.pool.ToArray();     //此处如果出错,则不会执行ReleaseMutex,将会死锁
                    this.pool.Clear();
                }
                catch
                
                }
                mutexSQLPool.ReleaseMutex();
      
                return array;
            }
        }
    }

     

    (二)SQL池管理

      SQL池管理主要用于管理SQL池,向业务逻辑层线程和SQL执行线程提供接口。

      业务逻辑层线程调用 public void PushSQL(string strSQL) 方法,用于向SQL池抛入SQL语句。

      SQL执行线程调用 public void ExecuteSQL(object obj) 方法,用于批量执行SQL池中的SQL语句。

      注意,SQL池管理类采用单例模型,为什么要采用单例模型?因为SQL池只能存在一个实例,无论是业务逻辑层线程还是SQL执行线程,仅会操作这一个实例,否则,将会导致SQL池不唯一,SQL执行无效。

      下面是SQL池管理类代码:

     

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
      
    namespace Test1
    {
        class SQLPoolManage
        {
            //单例模型
            public static readonly SQLPoolManage sqlPoolManage = new SQLPoolManage();
      
            #region 属性
            SQLPool poolOfSQL;
            #endregion
      
      
            #region 构造函数
            /// <summary>
            /// 初始化
            /// </summary>
            public SQLPoolManage()
            {
                this.poolOfSQL = new SQLPool();
            }
            #endregion
      
      
            #region 方法
            /// <summary>
            /// 将SQL语句加入SQL池中
            /// </summary>
            /// <param name="strSQL"></param>
            public void PushSQL(string strSQL)
            {
                this.poolOfSQL.Push(strSQL);
            }
      
      
            /// <summary>
            /// 每隔一段时间,触发ExecuteSQL
            /// ExecuteSQL用于执行SQL池中的SQL语句
            /// </summary>
            /// <param name="obj"></param>
            public void ExecuteSQL(object obj)
            {
                if (this.poolOfSQL.Count > 0)
                {
                    string[] array = this.poolOfSQL.Clear();
                    //遍历array,执行SQL
                    for (int i = 0; i < array.Length; i++)
                    {
                        if (array[i].ToString().Trim() != "")
                        {
                            try
                            {
                                //数据库操作
                                //......
                            }
                            catch
                            
                            }
                        }
                    }
                }
            }
            #endregion
      
        }
    }

     

     

    (三)定时触发SQL执行线程

      总结有以下三种方法,具体请参见http://www.cnblogs.com/tianzhiliang/archive/2010/08/31/1813928.html

    方法一:调用线程执行方法,在方法中实现死循环,每个循环Sleep设定时间;

    方法二:使用System.Timers.Timer类;

    方法三:使用System.Threading.Timer;

      代码如下:

     

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
      
    using System.Threading;
      
    namespace Test1
    {
      
        class Program
        {
            static void Main(string[] args)
            {
                //向SQL池中抛入SQL语句
                SQLPoolManage.sqlPoolManage.PushSQL("delete from tbl_test where id = 1");
      
                //定时触发SQL执行线程
                System.Threading.Timer threadTimer = new System.Threading.Timer(new System.Threading.TimerCallback(SQLPoolManage.sqlPoolManage.ExecuteSQL), null, 0, 100);
      
                Console.ReadLine();
            }
        }
    }

    转载于:https://www.cnblogs.com/wangshenhe/archive/2013/02/19/2916427.html

    展开全文
  • 在实际项目开发中,业务逻辑层的处理...好,下面我就为大家介绍一种方法:构建SQL池,分离业务逻辑层和数据访问层,让业务逻辑层从低效的数据库操作解脱,以提高系统整体性能。 (一)SQL池  SQL池是SQL容器,...
  • 在实际项目开发中,业务逻辑层的...好,下面我就为大家介绍一种方法:构建SQL池,分离业务逻辑层和数据访问层,让业务逻辑层从低效的数据库操作解脱,以提高系统整体性能。 (一)SQL池  SQL池是SQL容器,用于存放
  • 在实际项目开发中,业务逻辑层的处理速度往往很快,特别是在开发Socket通信服务的时候,...构建SQL池,分离业务逻辑层和数据访问层,让业务逻辑层从低效的数据库操作解脱,以提高系统整体性能。 (一)SQL池  S
  • 在实际项目开发中,业务逻辑层的处理...好,下面我就为大家介绍一种方法:构建SQL池,分离业务逻辑层和数据访问层,让业务逻辑层从低效的数据库操作解脱,以提高系统整体性能。 (一)SQL池  SQL池是SQL容器,
  •  Windows10 + VS2015 + SQL Server2014 + .NET Framework4.5 + C# +WCF 问题:  业务功能需要,做了一个windows应用程序供主程序点击按钮调用,但这只是有特别需要时的可操作入口,需求是最好做成定时触发自动...
  • 实现计划任务的方法也有很多,可以采用SQLAgent执行存储过程来实现,也可以采用Windows任务调度程序来实现,也可以使用Windows服务来完成我们的计划任务,这些方法都是很好的解决方案。但是,对于Web应用程序来说,...
  • 在业务复杂的应用程序中...实现计划任务的方法也有很多,可以采用SQLAgent执行存储过程来实现,也可以采用Windows任务调度程序来实现,也可以使用Windows服务来完成我们的计划任务,这些方法都是很好的解决方案。但...
  • 包括一个后台定时执行检查的服务、写文本日志功能、加密解密功能、发送邮件功能、一个XML的配置文件和读取XML配置内容功能、服务的安装和删除功能。 我先说明,我不在这里研究SQL Server为什么有假死这样的现象,...
  • C#如何在程序里定时启动任务在业务复杂的应用程序中,有时候会要求一个或者多个任务在一定的时间或者一定的时间间隔内计划进行,比如定时备份或同步数据库,定时发送电子邮件等,我们称之为计划任务。实现计划任务的...
  • 实现计划任务的方法也有很多,可以采用SQLAgent执行存储过程来实现,也可以采用Windows任务调度程序来实现,也可以使用Windows服务来完成我们的计划任务,这些方法都是很好的解决方案。但是,对于Web应用程序来说,...
  • 实现计划任务的方法也有很多,可以采用SQLAgent执行存储过程来实现,也可以采用Windows任务调度程序来实现,也可以使用Windows服务来完成我们的计划任务,这些方法都是很好的解决方案。但是,对于Web应用程序来说,...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 135
精华内容 54
关键字:

c#定时执行sql

c# 订阅