C# IOrder.getSQLContextInfo方法代码示例

        /// <summary>
        /// This is the business logic for placing orders, handling txs.
        /// StockTrader allows the user to select whether to use System.Transactions
        /// or use ADO.NET Provider-supplied transactions for order placement (buy, sell); and new user registrations.
        /// The best choice for performance will vary based on the backend database being used with the 
        /// application. 
        /// </summary>
        /// <param name="orderType">Buy or sell type.</param>
        /// <param name="userID">User id to create/submit order for.</param>
        /// <param name="holdingID">Holding id to sell.</param>
        /// <param name="symbol">Stock symbol to buy.</param>
        /// <param name="quantity">Shares to buy.</param>
        public OrderDataModel placeOrder(string orderType, string userID, int holdingID, string symbol, double quantity)
        {
            OrderDataModel order = null;
            HoldingDataModel holding = new HoldingDataModel();
            switch (Settings.TRANSACTION_MODEL)
            {
                case (StockTraderUtility.TRANSACTION_MODEL_SYSTEMDOTTRANSACTION_TRANSACTION):
                    {
                        //This short try/catch block is introduced to deal with idle-timeout on SQL Azure
                        //connections.  It may not be required in the near future, but as of publication
                        //SQL Azure disconnects idle connections after 30 minutes.  While command retry-logic
                        //in the DAL automatically deals with this, when performing a tx, with the BSL handling
                        //tx boundaries, we want to go into the tx with known good connections.  The try/catch below
                        //ensures this.
                        try
                        {
                            dalOrder = Trade.DALFactory.Order.Create(Settings.DAL);
                            dalOrder.Open(Settings.TRADEDB_SQL_CONN_STRING);
                            dalOrder.getSQLContextInfo();
                        }
                        catch { }
                        finally { dalOrder.Close(); }
                        System.Transactions.TransactionOptions txOps = new TransactionOptions();
                        txOps.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
                        txOps.Timeout = TimeSpan.FromSeconds(Settings.SYSTEMDOTTRANSACTION_TIMEOUT);
                        //Start our System.Transactions tx with the options set above.
                        using (TransactionScope tx = new TransactionScope(TransactionScopeOption.Required, txOps))
                        {
                            dalOrder.Open(Settings.TRADEDB_SQL_CONN_STRING);
                            try
                            {
                                //Business Step 1:  create the order header.
                                order = createOrder(orderType, userID, holdingID, symbol, quantity, ref holding);

                                //Business Step 2:  Determine which order processing mode to use,
                                //and either process order right away (sync) and in-process with 
                                //calling ASP.NET Web app; or interface with the
                                //async WCF Order Processing Service (cooler) via a service-to-service call,
                                //distributed/remote.
                                if (Settings.ORDER_PROCESSING_MODE != StockTraderUtility.OPS_INPROCESS)
                                {
                                    //Fire up our async client;  we follow the same model here as with the
                                    //StockTrader Web App in that we do not talk 'directly' to the generated proxy
                                    //for the service; rather we channel all calls through a single 
                                    //class that then talks to the service proxy.  This will aid in more
                                    //easily knowing where communication and proxy logic sits; and make changes to services
                                    //you might want to interface with vs. littering proxy calls throughout the
                                    //business tier itself.
                                    TradeOrderServiceAsyncClient asyncclient = new TradeOrderServiceAsyncClient(Settings.ORDER_PROCESSING_MODE, new Settings());
                                       asyncclient.processOrderASync(order);
                                }
                                else
                                {
                                    processOrderSync(order, holding);
                                }

                                //Commit!
                                tx.Complete();
                                return order;
                            }
                            //If per chance you are doing step-through debugging through here and are getting a
                            // "TRANSACTION HAS ABORTED" exception and do not know why,
                            //it's quite likely you are hitting the 15-second timeout we set in
                            //ConfigurationSettings for the System.Transaction options so its just doing what we told it to. 
                            //Simply adjust timeout higher, recompile if you need to.
                            catch
                            {
                                throw;
                            }
                            finally
                            {
                                dalOrder.Close();
                            }
                        }
                    }
               
                //Repeat for ADO.NET transactions config option case. 
                case (StockTraderUtility.TRANSACTION_MODEL_ADONET_TRANSACTION):
                    {
                        if (Settings.ORDER_PROCESSING_MODE == StockTraderUtility.OPS_SELF_HOST_MSMQ)
                            goto case StockTraderUtility.TRANSACTION_MODEL_SYSTEMDOTTRANSACTION_TRANSACTION;
                        dalOrder.Open(Settings.TRADEDB_SQL_CONN_STRING);
                        dalOrder.BeginADOTransaction();
                        try
                        {
                            //Business Step 1:  create the order header.
                            order = createOrder(orderType, userID, holdingID, symbol, quantity, ref holding);

//.........这里部分代码省略.........

        /// <summary>
        /// SubmitOrder service operation is a service operation that processes order messages from the client
        /// coming in via TCP, HTTP, or a non-transacted (volatile) MSMQ WCF binding from either the BSL or another remote instance
        /// </summary>
        /// <param name="order">Order to submit.</param>
        public void SubmitOrder(OrderDataModel order)
        {
           System.Transactions.TransactionOptions txOps = new TransactionOptions();
           txOps.IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
           txOps.Timeout = TimeSpan.FromSeconds(Settings.SYSTEMDOTTRANSACTION_TIMEOUT);
           try
           {
               dalOrder = Trade.DALFactory.Order.Create(Settings.DAL);
               dalOrder.Open(Settings.TRADEDB_SQL_CONN_STRING);
               dalOrder.getSQLContextInfo();
           }
           catch { }
           finally { dalOrder.Close(); }
           //  Start our System.Transactions tx with the options set above.
           using (TransactionScope tx = new TransactionScope(TransactionScopeOption.Required, txOps))
            {
                try
                {
                    processOrder(order);

                    //Complete transaction scope!
                    tx.Complete();
                }
                catch (Exception e)
                {
                    string innerException = null;
                    if (e.InnerException != null)
                         innerException = e.InnerException.ToString();
                    ConfigUtility.writeErrorConsoleMessage("Error Completing Order! Exception: " + e.ToString() + "\nInner Exception: " + innerException,EventLogEntryType.Error,true, new Settings());
                    throw;
                }
            }
        return;
        }