流水號獲取的解決方案

　　流水號的獲取在單機版的程序中只需要簡單的遞增就可以解決。但是在分布式系統中存在多個客戶端同時請求同一個流水號的問題，如果處理不好容易導致多個客戶端獲得同一個流水號。

解決方案一

　　在Oracle數據庫中有專門的序列管理sequence，具體的介紹在網上可以找到很多。但是在實際使用中存在很多的問題：

　　　　1、如果有很多個不同的序列，並且在需要根據時間變化（每天0點重置）時處理起來很麻煩。

　　　　2、隨時間增加數據庫中的序列越來越多。

　　　　3、在首次創建一個序列的時候需要激活后才能正常使用。

　　所以果斷放棄了這個方案。

解決方案二

　　大體的思路：在數據庫中專門建一個表存儲各類的序列，在服務器端創建一個服務專門提供各類序列當前的流水號。客戶端通過這個服務來獲取序列，不能直接去數據庫中查

　　第1步：在數據庫中專門創建一個新的表用來存儲這些序列。表結構如下：

　　　　1、FLAG(標志碼 主鍵)：代表序列的標志

　　　　2、Sequence(當前的流水號)：默認為0

　　　　3、UpdateTime(更新時間):根據自己的需要來創建

　　第2步：先創建一些接口

　　　　1、數據服務的接口　　　　　　

 public interface IDataOperator
    {
        int ExecuteNonQuery(List<string> list);
        int ExecuteNonQuery(string strSql);
        int ExecuteNonQuery(List<string> list, ref string strError);
        int ExecuteNonQuery(string strSql, ref string strError);
        T ExecuteScalar<T>(string strSql);
        T ExecuteScalar<T>(string strSql, ref string strError);
        DataSet GetDataSet(string strSql);
        DataSet GetDataSet(string strSql, ref string strError);
        DataTable GetDataTable(string strSql);
        DataTable GetDataTable(string strSql, ref string strError);
    }

　　　　2、流水號的接口

  public interface ISequence
    {
        int GetNext(string strFlag);
    }

　第3步：在服務器端創建一個服務，這個服務有兩個功能。我這邊客戶端和服務端的通信用的是Remoting技術。這里就不展示相關的代碼了。

　　　　1、做客戶端的數據中轉，直接和數據庫服務器之間通信，

  public class SqlServer : MarshalByRefObject,IDataOperator
    {
        #region 私有字段
        private string strConn;
        #endregion
        /// <summary>
        /// 構造器
        /// </summary>
        public SqlServer ()
        {
                        strConn = string.Format(@"User ID={0};Password={1};Data Source={2};Pooling=true;Min Pool Size=0;Max Pool Size={3};",
                                   “”,
                                 “”,
                                  “”
                                 “”;
            
        }
        /// <summary>
        /// 打開數據庫連接
        /// </summary>
        /// <param name="strError">返回錯誤信息</param>
        /// <returns></returns>
        public bool OpenTest(ref string strError)
        {
            bool blResult = false;
            try
            {
                using (SqlConnection conn = new SqlConnection(strConn))
                {
                    conn.Open();
                    conn.Close();
                }
                blResult = true;
            }
            catch(Exception ex)
            {
                strError = ex.Message;
            }
            return blResult;
        }
        /// <summary>
        /// 執行一個SQL語句集合返回操作成功數
        /// </summary>
        /// <param name="strsql"></param>
        /// <param name="parameter"></param>
        /// <returns></returns>
        public int   ExecuteNonQuery(List<string> list, ref string strError)
        {
            int intResult = 0;
            int i = 0;
            if (list.Count > 0)
            {
                try
                {
                    using (SqlConnection conn = new SqlConnection(strConn))
                    {
                      
                        conn.Open();
                        SqlTransaction tran = conn.BeginTransaction();

                        try
                        {
                            using (SqlCommand cmd = conn.CreateCommand())
                            {
                                cmd.Transaction = tran;
                                for (i = 0; i < list.Count; i++)
                                {
                                   cmd.CommandText = list[i].Trim(); 
                                    intResult+= cmd.ExecuteNonQuery();
                                }
                                tran.Commit();
                            }
                          
                        }
                        catch (Exception ex)
                        {
                            try
                            {
                                intResult = -1;
                                tran.Rollback();

                                strError =
                                    string.Format("{0}個操作回滾成功!{1}\r\n ErrSQL:\r\n   {2}",
                                      i, ex.Message, list[i]);
                            }
                            catch(Exception ex2)
                            {
                                intResult = -2;
                                strError =
                                      string.Format("{0}個操作回滾失敗!{1}\r\n ErrSQL:\r\n   {2}",
                                        i, ex2.Message, list[i]);
                            }
                        }
                        finally
                        {
                            conn.Close();
                        }
                    }
                }
                catch (SqlException ex)
                {

                    strError = ex.Message;
                }
               
            }
            else
            {
                strError = string.Format("ExecuteNonQuery(List<string> list)：未傳入需要執行的SQL語句");
            }
            return intResult;

        }
        /// <summary>
        /// 執行一個SQL語句集合返回操作成功數
        /// </summary>
        /// <param name="strsql"></param>
        /// <param name="parameter"></param>
        /// <returns></returns>
        public int  ExecuteNonQuery(List<string> list)
        {
            int intResult = 0;
            int i = 0;
            if (list.Count > 0)
            {
                using (SqlConnection conn = new SqlConnection(strConn))
                {
                    conn.Open();
                    SqlTransaction tran = conn.BeginTransaction();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        try
                        {
                            cmd.Transaction = tran;
                            for (i = 0; i < list.Count; i++)
                            {
                                cmd.CommandText = list[i].Trim(); 
                                intResult += cmd.ExecuteNonQuery();
                            }
                            tran.Commit();
                        }
                        catch (Exception ex)
                        {
                            try
                            {
                                intResult = -1;
                                tran.Rollback();
                                PubLibrary.WriteTxt(
                                    string.Format("{0}個操作回滾成功!{1}\r\n ErrSQL:\r\n   {2}",
                                      i, ex.Message, list[i]));
                            }
                            catch (Exception ex2)
                            {
                                intResult = -2;
                                PubLibrary.WriteTxt(
                                      string.Format("{0}個操作回滾失敗!{1}\r\n ErrSQL:\r\n   {2}",
                                        i, ex2.Message, list[i]));
                            }
                        }
                        finally
                        {
                            conn.Close();
                        }

                    }
                  
                }
            }
            else
            {
                PubLibrary.WriteTxt("ExecuteNonQuery(List<string> list)：未傳入需要執行的SQL語句");
                //throw new SystemException(string.Format("ExecuteNonQuery(List<string> list)：未傳入需要執行的SQL語句"));
            }
            return intResult;
        }
        /// <summary>
        /// 返回操作成功數
        /// </summary>
        /// <param name="strSql"></param>
        /// <returns></returns>
        public int ExecuteNonQuery(string strSql)
        {
            int intResult = 0;
            try
            {
                using (SqlConnection conn = new SqlConnection(strConn))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandText = strSql;

                        intResult = cmd.ExecuteNonQuery();
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                PubLibrary.WriteTxt(ex.Message);
            }
            finally
            {
                //conn.Close();
            }

            return intResult;
        }
        /// <summary>
        /// 返回操作成功數
        /// </summary>
        /// <param name="strSql"></param>
        /// <returns></returns>
        public int ExecuteNonQuery(string strSql, ref string strError)
        {
            int intResult =0;
            try
            {
                using (SqlConnection conn = new SqlConnection(strConn))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandText = strSql;

                        intResult = cmd.ExecuteNonQuery();
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                strError = ex.Message;
            }
            finally
            { 
               
               
            }

            return intResult; 

        }
        /// <summary>
        /// 返回紀錄集第一行第一列的數據
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="strSql"></param>
        /// <returns></returns>
        public T ExecuteScalar<T>(string strSql)
        {
            T temp = default(T);
            try
            {
                using (SqlConnection conn = new SqlConnection(strConn))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {

                        cmd.CommandText = strSql;

                        object o = cmd.ExecuteScalar();
                        if (o != null && o != DBNull.Value)
                        {
                            temp = (T)Convert.ChangeType(o, typeof(T));
                        }
                    }
                    conn.Close();
                }


            }
            catch (SqlException ex)
            {
                PubLibrary.WriteTxt(ex.Message);
            }
            finally
            {
               
            }
            return temp;

        }

        /// <summary>
        /// 返回紀錄集第一行第一列的數據
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="strSql"></param>
        /// <param name="strError"></param>
        /// <returns></returns>
        public T ExecuteScalar<T>(string strSql, ref string strError)
        {

            T temp = default(T);
            try
            {
                using (SqlConnection conn = new SqlConnection(strConn))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {

                        cmd.CommandText = strSql;

                        object o = cmd.ExecuteScalar();
                        if (o != null && o != DBNull.Value)
                        {
                            temp = (T)Convert.ChangeType(o, typeof(T));
                        }
                    }
                    conn.Close();
                }
            }
            catch (SqlException ex)
            {
                strError = ex.Message;
            }
            finally
            {
                
            }
            return temp;
        }
        /// <summary>
        /// 獲取數據集
        /// </summary>
        /// <param name="strSql"></param>
        /// <returns></returns>
        public DataSet GetDataSet(string strSql)
        {

            DataSet ds = new DataSet();
            try
            {
                using (SqlConnection conn = new SqlConnection(strConn))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandText = strSql;
                        SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                        adapter.Fill(ds);
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                PubLibrary.WriteTxt(ex.Message);
            }
            finally
            {
               
            }
            return ds;
        }

        /// <summary>
        /// 獲取數據集
        /// </summary>
        /// <param name="strSql"></param>
        /// <param name="strError"></param>
        /// <returns></returns>
        public DataSet GetDataSet(string strSql,ref string strError)
        {
            DataSet ds = new DataSet();
            try
            {
                using (SqlConnection conn = new SqlConnection(strConn))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandText = strSql;
                        SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                        adapter.Fill(ds);
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                strError = ex.Message;
            }
           
            return ds;
        }

        /// <summary>
        /// 獲取第一張數據表
        /// </summary>
        /// <param name="strSql"></param>
        /// <returns></returns>
        public DataTable GetDataTable(string strSql)
        {            
            DataTable dt = new DataTable();
            try
            {
                using (SqlConnection conn = new SqlConnection(strConn))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandText = strSql;

                        SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                        DataSet ds = new DataSet();
                        adapter.Fill(ds);
                        if (ds != null && ds.Tables.Count > 0)
                        {
                            dt = ds.Tables[0];
                        }
                    }
                    conn.Close();
                }

            }
            catch (Exception ex)
            {
                PubLibrary.WriteTxt(ex.Message);
            }
           
                    
            return dt;
        }

        /// <summary>
        /// 獲取第一張數據表
        /// </summary>
        /// <param name="strSql"></param>
        /// <param name="strError"></param>
        /// <returns></returns>
        public DataTable GetDataTable(string strSql,ref string strError)
        {
            DataTable dt = new DataTable();
            try
            {
                using (SqlConnection conn = new SqlConnection(strConn))
                {
                    conn.Open();
                    using (SqlCommand cmd = conn.CreateCommand())
                    {
                        cmd.CommandText = strSql;
                        SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                        DataSet ds = new DataSet();
                        adapter.Fill(ds);
                        if (ds != null && ds.Tables.Count > 0)
                        {
                            dt = ds.Tables[0];
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                strError = ex.Message;
            }
            finally
            {
               
            }
            return dt;
        }

       
    }

　　　　2、創建流水號的類， “_nextTen += 10;//如果流水號獲取很頻繁這個值可以設大一點”這里相當於一個緩存機制，以減少對數據庫的訪問量。可以根據實際需求來增大或減少。這里要注意一點如果服務有重啟會有部分流水號丟失。如果是對流水號的連續性要求高的最好設置為1，但是這樣對數據庫的訪問量會非常大。會導致獲取流水號的平均時間增加，我的測試（普通台式電腦做服務器同時有30個進程在獲取同一個流水號）是在10個緩存的情況下平均時間是10ms以內。

public class BCSequence
    {
        private string _strFlag;
       IDataOperator dataOperator;
       public BCSequence(IDataOperator dataOperator)
        {
            this.dataOperator = dataOperator;
        }
       public BCSequence(string strFlag, int intSequence, IDataOperator dataOperator)
       {
           this._strFlag = strFlag;
           this._intSequence = intSequence;
           this._nextTen = intSequence;
           this.dataOperator = dataOperator;

       }

        public string StrFlag
        {
            get { return _strFlag; }
            set { _strFlag = value; }
        }
        int _intSequence;
        int _nextTen
        {
            get;
            set;
        }
     

        /// <summary>
        /// 流水號保存不了則返回-1
        /// </summary>
        public int Next
        {
            get
            {
                if (_intSequence >= _nextTen)
                {
                    _nextTen += 10;//如果流水號獲取很頻繁這個值可以設大一點
                    if (SaveInfo() <= 0)
                    {
                        _nextTen -= 10;//保存失敗必須將值變回10否則會出現重碼的情況 
                        return -1;

                    }
                }
                _intSequence++;
                return _intSequence;
            }
        }
        public int SaveInfo()
        {
            int intResult = -1;
            try
            {
                string strSql = string.Format(@"Select Count(*) from  HT_Barcode_Sequence where Flag='{0}'", StrFlag);
             
                intResult = dataOperator.ExecuteScalar<int>(strSql);
               if (intResult == 0)
                {
                    strSql =
                        string.Format(@"Insert into HT_Barcode_Sequence(Flag,Sequence,Update_Time)values('{0}',{1},Now())",
                        _strFlag, _nextTen);
                }
                else
                {
                    strSql =
                           string.Format(@"Update HT_Barcode_Sequence set Sequence={0},Update_Time=Now() where Flag='{1}'",
                           _nextTen, _strFlag);
                }
                intResult = dataOperator.ExecuteNonQuery(strSql);
            }
            catch (Exception ex)
            {
                //PubLibrary.WriteTxt(ex.Message);
            }

            return intResult;

        }
        public static BCSequence CreatSeq(string strFlag, IDataOperator dataOperator)
        {
            BCSequence BCSeq = null;
            try
            {
                //PBSSQLServer pbssql = new PBSSQLServer();
                string strSql = string.Format(@"Select Flag,Sequence,Update_Time from HT_Barcode_Sequence where Flag='{0}'",
                    strFlag);
                using (DataTable dt = dataOperator.GetDataTable(strSql))
                {
                    if (dt != null && dt.Rows.Count > 0)
                    {
                        int intSequence = DataConvert.DbToInt(dt.Rows[0]["Sequence"]);
                        BCSeq = new BCSequence(strFlag, intSequence,dataOperator);
                    }
                    else
                    {
                        BCSeq = new BCSequence(strFlag, 0,dataOperator);
                        if (BCSeq.SaveInfo() <= 0)
                        {
                            BCSeq = null;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                //PubLibrary.WriteTxt(ex.Message);
            }

            return BCSeq;
        }
      
      
    }

　　　　3、管理所有的流水號，客戶端要獲取流水號需要依靠這個服務

 public  class BarcodeSequence:MarshalByRefObject,ISequence
    {
       
       public BarcodeSequence()
       {
         
       }
       /// <summary>
       /// 
       /// </summary>
       /// <param name="strFlag"></param>
       /// <returns>返回相應標志碼的流水號,如果數據庫交互出現問題得不到標志碼的流水號，或創建不了標志碼。則返回-2</returns>
       public int GetNext(string strFlag)
       {
           BCSequence bs = Get(strFlag);
           if (bs == null)
           {
               bs = Creat(strFlag);
               //將新創建的標志碼類放入隊列的工作交給創建器
           }
           if (bs != null)
           {
               return bs.Next;
           }
           else  //如果數據庫交互出現問題得不到標志碼的流水號，或創建不了標志碼。則返回-2
           {
               return -2;
           }
       }
       /// <summary>
       /// 標志碼生成器
       /// </summary>
       /// <param name="strFlag"></param>
       /// <returns></returns>
       public BCSequence Creat(string strFlag)
       {
           lock (PubLibrary.CreatObj)
           {
               BCSequence bs = Get(strFlag);
               if (bs == null)
               {
                   bs= BCSequence.CreatSeq(strFlag,new SQLServer());

                   if (bs != null)
                   {
                       PubLibrary.lstSeq.Add(bs);
                   }
               }
               return bs;
           }

       }

       /// <summary>
       /// 獲取標志碼列表中對應的標志碼
       /// </summary>
       /// <param name="strFlag">要查詢的標志碼</param>
       /// <returns></returns>
       public BCSequence Get(string strFlag)
       {
           BCSequence bs = null;
           foreach (BCSequence bcbs in PubLibrary.lstSeq)
           {
               if (bcbs.StrFlag == strFlag)
               {

                   bs = bcbs;
                   break;
               }
           }
           return bs;
       }

    }

　　　　還有一個靜態類專門存儲現在在使用的一些流水號列表等信息

  public class PubLibrary
    {

        public static object CreatObj=new object();
        ///// <summary>
        ///// 提供給服務內部的類查詢數據使用的SQLServer
        ///// </summary>
        //public static SQLServer pbsSQL = new SQLServer();

        public static List<BCSequence> lstSeq = new List<BCSequence>();

        public static void RegistRemotingObject()
        {
          
            string strServicename = "";
            string strChannelType ="";
            int intChannelNo =Convert.ToInt32("");;
            string strCallType = "SingleCall";
            int intInitialLeaseTime = Convert.ToInt32("");
            int intSponsorshipTimeout =Convert.ToInt32("");
            int intRenewOnCallTime =Convert.ToInt32("");
            string strSeqServicename ="";
            string strSeqChannelType = "";
            int intSeqChannelNo = Convert.ToInt32("");
            string strSeqInfo = "";
            string strSeqCallType = "SingleCall";
            int intSeqInitialLeaseTime = Convert.ToInt32("");
            int intSeqSponsorshipTimeout = Convert.ToInt32("");
            int intSeqRenewOnCallTime = Convert.ToInt32("");
            try
            {
                CreateRemotingObject<SQLServer>(intChannelNo, strCallType, strServicename, strChannelType, intInitialLeaseTime, intSponsorshipTimeout, intRenewOnCallTime);
                PubLibrary.WriteTxt(string.Format("已經注冊類型SQLServer {0},{1},{2},{4},{5},{6}",intChannelNo, strCallType, strServicename, strChannelType, intInitialLeaseTime, intSponsorshipTimeout, intRenewOnCallTime ));

                CreateRemotingObject<BarcodeSequence>(intSeqChannelNo, strSeqCallType, strSeqServicename, strSeqChannelType, intSeqInitialLeaseTime, intSeqSponsorshipTimeout, intSeqRenewOnCallTime);
                PubLibrary.WriteTxt(string.Format("已經注冊類型BarcodeSequence {0},{1},{2},{4},{5},{6}", intSeqChannelNo, strSeqCallType, strSeqServicename, strSeqChannelType, intSeqInitialLeaseTime, intSeqSponsorshipTimeout, intSeqRenewOnCallTime));
                          
            }
            catch (Exception ex)
            {
                PubLibrary.WriteTxt(ex.Message);
            }
        }

        /// <summary>
        /// 清除遠程對象
        /// </summary>
        public static void ClearRemotingObject()
        {
            try
            {
             MES.EI.RemotingOperation.UnregisterChannel();
            }
            catch (Exception ex)
            {
                PubLibrary.WriteTxt(ex.Message);
            }
        }

        /// <summary>
        /// 以Append的模式往指定的文本文件寫入文本信息
        /// </summary>
        /// <param name="Info" >信息</param>
        public static void WriteTxt(string Info)
        {
            string filename = Service.StartPath + "Error_" + System.DateTime.Now.ToString("yyyyMMdd") + ".txt";

            if (filename.Substring(filename.Length - 3).ToUpper() == "TXT")
            {
                lock (typeof(PubLibrary))
                {
                    System.IO.FileStream s = System.IO.File.Open(filename, System.IO.FileMode.Append);
                    System.IO.StreamWriter w = new System.IO.StreamWriter(s);
                    w.WriteLine(System.DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss") + ":" + Info);
                    w.Close();
                }
            }
            else
            {
                throw new ApplicationException(filename + " isn't a txt file.");
            }
        }
        /// <summary>
        /// 把相關信息寫入事件日志
        /// </summary>
        /// <param name="Info">信息</param>
        /// <param name="type">事件類型</param>
        public static void WriteEvent(string Info, System.Diagnostics.EventLogEntryType type)
        {
            Service.ServiceLog.WriteEntry(Info, type);
        }

        /// <summary>
        /// 根據指定參數創建遠程對象
        /// </summary>
        /// <typeparam name="T">Remoting服務的數據類型</typeparam>
        /// <param name="Port">端口</param>
        /// <param name="CallType">激活類型</param>
        /// <param name="RemotingServerName">遠程服務名稱</param>
        /// <param name="ChannelType">通道類型</param>
        /// <param name="InitialLeaseTime">租約的初始時間</param>
        /// <param name="SponsorshipTimeout">等待主辦方返回租約續訂時間的時間</param>
        /// <param name="RenewOnCallTime">對象重新調用時增加的生存期</param>
        private static void CreateRemotingObject<T>(int Port, string CallType, string RemotingServerName, string ChannelType,
            int InitialLeaseTime, int SponsorshipTimeout, int RenewOnCallTime)
        {
            try
            {
                RemotingChannelType[] channeltypes = RemotingServerInfo.GetChannelTypeFromString(ChannelType);

                if (channeltypes != null && channeltypes.Length > 0)
                {
                    RemotingServerInfo remotinginfo = new RemotingServerInfo
                        (Port, CallType, RemotingServerName, channeltypes);

                    RemotingEventInfo eventinfo = new RemotingEventInfo
                        (HTPBSService.ServiceLog, System.Diagnostics.EventLogEntryType.Information,
                        InitialLeaseTime, SponsorshipTimeout, RenewOnCallTime);

                    RemotingOperation.CreateRemotingServerFullDeserialization<T>(remotinginfo, eventinfo);
                }
            }
            catch (System.Exception ex)
            {
                PubLibrary.WriteTxt(
                    string.Format("{0}:服務不能啟動,因為{1} {2}", DateTime.Now.ToString(), ex.Message, ex.StackTrace));
            }
        }
    }

　　第4步：創建客戶端

public class SqlSequence :IClientSequence
    {
        ISequence se;
        private string strMachineNo;
        private int intChannelNo;
        private string strServiceName;    
        /// <summary>
        /// 構造器
        /// </summary>
        /// <param name="MachineNo">服務器電腦名</param>
        /// <param name="ChannelNo">服務端口</param>
        /// <param name="ServiceName">服務名</param>
        public SqlSequence(string MachineNo, int ChannelNo, string ServiceName)
        {
            this.strMachineNo = MachineNo;
            this.intChannelNo = ChannelNo;
            this.strServiceName = ServiceName;
        }
       /// <summary>
       /// 打開到遠程服務器的通道
       /// </summary>
       /// <returns></returns>
       public bool OpenRemoting()
       {
           try
           {
               RemotingClientInfo clientinfo;
               clientinfo = new RemotingClientInfo(strMachineNo,
                         intChannelNo,
                        strServiceName,
                        RemotingChannelType.Tcp);
               GetRemotingVoucher(ref clientinfo);
               se = RemotingOperation.CreateRemotingClient<ISequence>(clientinfo);

               return true;
           }
           catch (Exception ex)
           {
               //PubLibrary.WriteTxt(ex.Message);
               return false;
           }
       }


       public bool GetNext(string strFlag, out int index, ref string strError)
       {
           bool blResult = false;
            index = -1;
            try
            {
                index = se.GetNext(strFlag);
                if (index != -1)
                {
                    blResult = true;
                }
                else
                {
                    strError = "服務端出現錯誤無法獲取流水號";
                }
            }
            catch (Exception ex)
            {

                if (ex.Message.Contains("由於目標計算機積極拒絕"))
                {

                    string strName = System.Net.Dns.GetHostEntry(ex.Message.Split(' ')[1].Split(':')[0]).HostName.Split('.')[0];
                    strError = "由於服務器[" + strName + "]上的噴碼服務已停止\r\n\r\n暫時無法噴印,請聯系管理員開啟噴碼服務";
                }
                else
                {
                    strError = ex.Message;
                }
               
            }
           return blResult;
       }
       /// <summary>
       /// 指定遠程連接時客戶端信息
       /// </summary>
       /// <param name="clientinfo"></param>
       private void GetRemotingVoucher(ref RemotingClientInfo clientinfo)
       {
           //clientinfo.IsTrusty = true;
           //if (!clientinfo.IsTrusty)
           //{
           clientinfo.IsTrusty = false;
           clientinfo.UserName = "BMES";
           clientinfo.Password = "Battery123";
           clientinfo.Domain = "";
           //}
       }

       /// <summary>
       /// 關閉遠程通道
       /// </summary>
       public void CloseRemoting()
       {

           RemotingOperation.UnregisterChannel();

           se = null;
       }
    }

　　第5步：測試　　　

SqlSequence　BSeq = new SqlSequence(strSeqMachineName, intSeqChannel, strSeqServerName);

 　　 string strFlag ="";

  　　int index = 0;

　　　if(　BSeq.GetNext(strFlag, out index, ref strError))

         {

            //成功

      }

        else

        {

            //失敗

      }