外_匯_邦 WaiHuiBang.com 1.MetaTrader 4客戶端中 "交易運作" 的概念
來自MetaEditor參考文檔的一段話:
來自智能交易和腳本的交易，只能夠提供一個並在交易作業中開啟 (來自智能交易和腳本的自動交易作業)。www.emoneybtc.com這就是為什麼如果智能交易業務作業忙，其他的智能交易或腳本在此刻不能調用函數生成錯誤146 (ERR_TRADE_CONTEXT_BUSY)。
換句話說，只有一個智能交易（腳本）可以准時交易。所以其他智能交易嘗試開始交易將被錯誤 146停止。文章將會找到問題的解決方案。

2. 函數 IsTradeAllowed()
這是最簡單的方法是使用名稱為IsTradeAllowed()的函數找出交易作業忙。
來自 MetaEditor參考文檔的一段話:
"bool IsTradeAllowed()
如果智能交易允許交易，返回TRUE 。否則，返回FALSE。
這就意味著如果函數 IsTradeAllowed()返回TRUE只有一個可以嘗試交易。
在交易業務之前必須檢測完成。

函數錯誤使用范例：

1. int start()
2.   {
3.     // 檢測交易作業
4.     if(!IsTradeAllowed())
5.       {
6.         // 如果函數IsTradeAllowed() 返回FALSE, 通知用戶
7.         Print("交易作業忙。智能交易不能開倉!");
8.         // 並且中止交易業務。當下一個替克進入將重新開始 
9.         // 進入
10.         return(-1);
11.       }
12.     else
13.       {
14.         // 如果函數IsTradeAllowed()返回TRUE，通知用戶 
15.         // 並繼續運行
16.         Print("交易作業空閒!開始運作...");
17.       }
18.     // 現在檢測市場
19.     ...
20.     // 計算止損和贏利水平和標准手
21.     ...
22.     // 開倉
23.     if(OrderSend(...) < 0) 
24.         Alert("開倉錯誤 # ", GetLastError());
25.     return(0);
26.   }

復制代碼
在這個范例中，在start() 函數開始時檢測交易運作狀態。這是個錯誤想法: 在我們的智能交易計算的時間內交易作業會被其他智能交易占據(需要進入市場，止損和贏利，標准手等等)。這些情況，接受開倉將失敗。

函數適當應用范例：

1. int start()
2.   {
3.     // 現在檢測市場
4.     ...
5.     // 計算止損和贏利水平，標准手數
6. ...
7.     // 現在檢測交易作業
8.     if(!IsTradeAllowed())
9.       {
10.         Print("交易作業忙! 智能交易不能開倉!");
11.         return(-1);
12.       }
13.     else
14.         Print("交易作業正常! 嘗試開倉...");
15.     //如果檢測正常,開倉
16.     if(OrderSend(...) < 0) 
17.         Alert("錯誤開倉 # ", GetLastError());
18.     return(0);
19.   }

復制代碼
在開倉之前立即檢測交易作業狀態，並且可能在兩種動作行為之間插入其他的智能交易 .
這種方法存在兩點不足:
智能交易在接收到明確結果檢測狀態的同時,將嘗試開始交易.
如果檢測失敗,智能交易將嘗試使用下一個替克交易; 將會延誤.
解決第二種不足很簡單:等待交易作業空閒即可.隨後,在其他智能交易結束後,智能交易將立即開始交易.

范例如下:

1. int start()
2.   {
3.     // 現在檢測是否進入市場
4.     ...
5.     // 計算贏利/止損水平和標准手數
6.     ...
7.     // 檢測交易作業是否空閒
8.     if(!IsTradeAllowed())
9.       {
10.         Print("交易作業忙!等待空閒...");
11.         // 無限循環
12.         while(true)
13.           {
14.             // 如果智能交易被用戶停止,停止業務
15.             if(IsStopped()) 
16.               { 
17.                 Print("智能交易被用停止!"); 
18.                 return(-1); 
19.               }
20.             // 如果交易作業空閒,開始交易
21.             if(IsTradeAllowed())
22.               {
23.                 Print("交易作業空閒!");
24.                 break;
25.               }
26.             // 如果沒有條件設置循環, "等待" 0.1秒
27.             // 並且檢測重新開始
28.             Sleep(100);
29.           }
30.       }
31.     else
32.         Print("交易作業空閒!嘗試開倉...");
33.     // 嘗試開倉
34.     if(OrderSend(...) < 0) 
35.         Alert("錯誤開倉 # ", GetLastError());
36.     return(0);
37.   }

復制代碼
這種情況出現,我們可以指出以下錯誤:
函數 IsTradeAllowed()不僅僅能夠顯現交易作業的狀態，同樣可以在無限循環中以“隱藏”開啟/關閉；如果從圖表中手動移除，將停止運作。
如果智能交易等待交易作業空閒，在這個時間裡，價格會改變並且可能用這個價格交易 - 數據需要刷新開倉重新計算。

糾正的錯誤代碼將會是以下:

1. // 智能交易等待交易的時間time (in seconds) whithin which the expert will wait until the trade 
2. // 交易作業空閒(如果忙)
3. int MaxWaiting_sec = 30;
4. int start()
5.   {
6.     // 現在檢驗是否進入市場
7.     ...
8.     // 計算止損，贏利和標准手數
9.     ...
10.     // 檢測交易作業是否空閒
11.     if(!IsTradeAllowed())
12.       {
13.         int StartWaitingTime = GetTickCount();
14.         Print("交易作業忙!等待空閒...");
15.         // 無限循環
16.         while(true)
17.           {
18.             // 如過用戶中止智能交易，停止業務
19.             if(IsStopped()) 
20.               { 
21.                 Print("智能交易被用戶中止!"); 
22.                 return(-1); 
23.                }
24.             // 如果等待時間超過命名變量 
25.             // MaxWaiting_sec, 停止業務
26.             if(GetTickCount() - StartWaitingTime > MaxWaiting_sec * 1000) 
27.               {
28.                 Print("標准限定(" + MaxWaiting_sec + " sec)超過!");
29.                 return(-2);
30.               }
31.             // 如果交易作業空閒,
32.             if(IsTradeAllowed())
33.               {
34.                 Print("交易作業空閒!");
35.                 // 刷新市場信息
36.                 RefreshRates();
37.                 // 重新計算止損和贏利水平
38.                 ...
39.                 // 離開循環狀態並開始交易             
40.                 break;
41.               }
42.             // 如過沒有條件離開,請 "等待"  0.1秒 
43.             // 並且重新開始檢測
44.             Sleep(100);
45.           }
46.       }
47.     else
48.         Print("交易作業空閒!嘗試開倉...");
49.  
50.     // 嘗試開倉
51.     if(OrderSend(...) < 0) 
52.         Alert("錯誤開倉 # ", GetLastError());
53.  
54.     return(0);
55.   }
56.  

復制代碼
對於上面的范例，我們還可以添加:
刷新市場信息(RefreshRates())並且重新計算止損和贏利水平
在超過最大時間限定等待後 MaxWaiting_sec,智能交易將停止業務
以上的這些代碼你已經可以使用到你的智能交易中。

現在讓我們來談談在單獨函數中的檢測。這將簡化在智能交易中的簡化和用法。

1. /////////////////////////////////////////////////////////////////////////////////
2. // int _IsTradeAllowed( int MaxWaiting_sec = 30 )
3. //
4. // 函數檢測交易作業狀態. R返回代碼:
5. //  1 - 交易作業空閒, 允許交易
6. //  0 - 交易作業忙,但是將空閒。刷新市場信息後允許交易。
7. // -1 - 交易作業忙,用戶中止等待(智能交易從圖表中刪除,終端刪除,圖表周期/貨幣對改變等等)
8. // -2 - 交易作業忙,達到最大等待限度 (MaxWaiting_sec). 
9. //      智能交易禁止交易(檢測 "Allow live trading" ).
10. //
11. // MaxWaiting_sec - 函數將等待的時間 
12. // 直到交易作業控點(如果交易作業忙）.默認值,30.
13. /////////////////////////////////////////////////////////////////////////////////
14. int _IsTradeAllowed(int MaxWaiting_sec = 30)
15.   {
16.     // 檢測交易作業是否空閒
17.     if(!IsTradeAllowed())
18.       {
19.         int StartWaitingTime = GetTickCount();
20.         Print("交易作業忙!等待空閒...");
21.         // 無限循環
22.         while(true)
23.           {
24.             // 如果智能交易被用戶中止，停止業務
25.             if(IsStopped()) 
26.               { 
27.                 Print("智能交易被用戶中止!"); 
28.                 return(-1); 
29.               }
30.             // 如果等待時間超出指定
31.             // MaxWaiting_sec 變量 ，停止業務
32.             if(GetTickCount() - StartWaitingTime > MaxWaiting_sec * 1000)
33.               {
34.                 Print("等待限度超過 (" + MaxWaiting_sec + " сек.)!");
35.                 return(-2);
36.               }
37.             // 如果交易作業空閒
38.             if(IsTradeAllowed())
39.               {
40.                 Print("交易作業空閒!");
41.                 return(0);
42.               }
43.             // 如果沒有條件離開循環狀態，請"等待" 0.1秒 
44.             // 並且重新開始檢測           Sleep(100);
45.           }
46.       }
47.     else
48.       {
49.         Print("交易作業空閒!");
50.         return(1);
51.       }
52.   }

復制代碼

對於智能交易使用函數的一個模板:

1. int start()
2.   {
3.     // 現在檢測是否進入市場
4.     ...
5.     // 計算止損，贏利水平和標准手數
6.     ...
7.     // 檢測交易作業是否空閒
8.     int TradeAllow = _IsTradeAllowed();
9.     if(TradeAllow < 0) 
10.       { 
11.         return(-1); 
12.       }
13.     if(TradeAllow == 0)
14.       {
15.         RefreshRates();
16.         // 重新計算贏利水平和止損水平
17.         ...
18.       }
19.     // 開倉
20.     if(OrderSend(...) < 0) 
21.         Alert("錯誤開倉 # ", GetLastError());
22.     return(0);
23.   }

復制代碼
由此我們得出以下結論:
函數 IsTradeAllowed()很方便使用，並且對於兩到三個智能交易同時運行同樣適用。雖然存在一些不足，當很多智能交易同時運行時會出現錯誤 146。如果"Allow live trading" 禁止，同樣可能出現智能交易"hanging" 。
這就是為什麼我們考慮解決方案-整體變量作為一個 "信號旗"的原因。

3.客戶終端的整體變量
首先是概念:
客戶終端的整體變量是所有智能交易，腳本和指標的變量通道。這就意味著整體變量可以由一個智能交易創建，其他的智能交易同樣可以使用 。
在 MQL4中提供了以下函數的整體變量:
GlobalVariableCheck() - 檢測已經存在的整體變量
GlobalVariableDel() - 刪除整體變量
GlobalVariableGet() - 獲取整體變量值
GlobalVariableSet() - 創建或修改整體變量
GlobalVariableSetOnCondition() - 用戶改變整體變量的指定值。不同於 GlobalVariableSet()，新值將被設定。這個函數是一個創建semaphore的關鍵。
GlobalVariablesDeleteAll() - 刪除所有整體變量 (我們不敢想象它的實用性:）)
為什麼使用 GlobalVariableSetOnCondition()，而不是聯合函數 GlobalVariableGet()和 GlobalVariableSet()呢? 同樣的原因:兩個函數之前可能重合。這樣其他的智能交易則不能插入。這就不使用的原因。

4. 信號旗的基本理念
智能交易准備交易應該檢測信號旗的狀態。如果信號旗顯示 "紅色" (整體變量 = 1),意味著其他智能交易在運行中，這樣需要等待。如果顯示“綠色” (整體變量 = 0),交易可以立即開始 (但不要忘記對其他智能交易設定"紅色")。
由此，我們創建了2個函數:一個設定"紅色"，另一個設定“綠色”。事實上，他們類似。我們嘗試地制定了函數的次序(函數TradeIsBusy() 和函數TradeIsNotBusy()) 並且賦予實踐。

5. 函數TradeIsBusy()
像我們前面所講的，這個函數的主要功能是使智能交易等待直至“綠色”顯現，並且將其切換成“紅色”。另外，我們需要檢驗是否存在整體變量，並且進行創建。如果不存在。這個檢測會從智能交易的函數init() 中進行邏輯性地執行。 但是隨後可能被用戶刪除並且不會有智能交易進行運行。這就是我們將它放置到創建函數中的原因。
所有的這些整體變量的運行都需要伴隨信息的展示和錯誤的生成。 應該記住"hanging":函數的業務時間需要限定。
這就是我們最終得到的：

1. /////////////////////////////////////////////////////////////////////////////////
2. // int TradeIsBusy( int MaxWaiting_sec = 30 )
3. //
4. // 函數還原TradeIsBusy 值0 - 1.
5. // 在開啟時如果TradeIsBusy = 1 ，函數等待直至 TradeIsBusy 為 0, 
6. // 隨後還原
7. // 如果TradeIsBusy沒有任何整體變量，函數將會自己創建。
8. // 返回代碼:
9. //  1 - 成功編譯。TradeIsBusy整體變量值指定為 1
10. // -1 - TradeIsBusy = 1 函數在此刻開啟，等待用戶中止
11. //      (智能交易從圖表中移除，終端被停止，圖表周期/貨幣對被改變等等)
12. // -2 - TradeIsBusy = 1 函數在此刻開啟，等待限定超時
13. //      (MaxWaiting_sec)
14. /////////////////////////////////////////////////////////////////////////////////
15. int TradeIsBusy( int MaxWaiting_sec = 30 )
16.   {
17.     // 測試時，沒有理由劃分交易作業 - 只是終止 
18.     // 此函數
19.     if(IsTesting()) 
20.         return(1);
21.     int _GetLastError = 0, StartWaitingTime = GetTickCount();
22.     //+------------------------------------------------------------------+
23.     //| 檢測整體變量是否存在，如果沒有，創建整體變量    |
24.     //+------------------------------------------------------------------+
25.     while(true)
26.       {
27.         // 如果智能交易被用戶中止，停止業務
28.         if(IsStopped()) 
29.           { 
30.             Print("智能交易被用戶中止!"); 
31.             return(-1); 
32.           }
33.         // 如果等待時間超過指定限定時間 
34.         // MaxWaiting_sec, 停止業務
35.         if(GetTickCount() - StartWaitingTime > MaxWaiting_sec * 1000)
36.           {
37.             Print("等待時間(" + MaxWaiting_sec + " sec)超出!");
38.             return(-2);
39.           }
40.         // 檢測整體變量是否存在
41.         // 如果不存在離開循環模式，進行改變
42.         // TradeIsBusy值
43.         if(GlobalVariableCheck( "TradeIsBusy" )) 
44.             break;
45.         else
46.         // 如果GlobalVariableCheck 返回FALSE, 意味著整體變量不存在或者  
47.         // 檢測中生成錯誤
48.           {
49.             _GetLastError = GetLastError();
50.             // 如果仍然有錯誤信息顯示，等待0.1 秒， 
51.             //重新開始檢測
52.             if(_GetLastError != 0)
53.              {
54.               Print("TradeIsBusy()-GlobalVariableCheck("TradeIsBusy")-Error #",
55.                     _GetLastError );
56.               Sleep(100);
57.               continue;
58.              }
59.           }
60.         // 如果沒有錯誤，意味著沒有整體變量，嘗試創建
61.         // 整體變量
62.         //如果 the GlobalVariableSet > 0, 說明整體變量成功創建。 
63.         // 離開函數
64.         if(GlobalVariableSet( "TradeIsBusy", 1.0 ) > 0 ) 
65.             return(1);
66.         else
67.         // 如果GlobalVariableSet返回值<= 0, 說明有錯誤
68.         // 在變量創建時生成
69.          {
70.           _GetLastError = GetLastError();
71.           //顯示信息，等待0.1秒，再次嘗試
72.           if(_GetLastError != 0)
73.             {
74.               Print("TradeIsBusy()-GlobalVariableSet("TradeIsBusy",0.0 )-Error #",
75.                     _GetLastError );
76.               Sleep(100);
77.               continue;
78.             }
79.          }
80.       }
81.     //+----------------------------------------------------------------------------------+
82.     //| 如果函數達到執行點，說明整體變量 | 
83.     //| 變量退出.                                                                 |
84.     //| 等待TradeIsBusy 值成為0 並且改變 TradeIsBusy 值為 1 |
85.     //+----------------------------------------------------------------------------------+
86.     while(true)
87.      {
88.      // 如果智能交易被用戶中止，停止業務
89.      if(IsStopped()) 
90.        { 
91.          Print("智能交易被用戶中止!"); 
92.          return(-1); 
93.        }
94.      // 如果等待超過限定時間
95.      // MaxWaiting_sec, 停止業務
96.      if(GetTickCount() - StartWaitingTime > MaxWaiting_sec * 1000)
97.        {
98.          Print("等待時間 (" + MaxWaiting_sec + " sec) 超出!");
99.          return(-2);
100.        }
101.      // 嘗試改變 TradeIsBusy的值從 0 - 1
102.      // 如果成功，離開函數返回1 ("成功編譯")
103.      if(GlobalVariableSetOnCondition( "TradeIsBusy", 1.0, 0.0 )) 
104.          return(1);
105.      else
106.      // 如果失敗，可能導致失敗的2個原因: TradeIsBusy = 1 (隨後等待), 
107.  
108.      // 錯誤生成  (需要我們檢測)
109.       {
110.       _GetLastError = GetLastError();
111.       // 如果仍然存在錯誤，顯示信息並且重新嘗試
112.       if(_GetLastError != 0)
113.       {
114.    Print("TradeIsBusy()-GlobalVariableSetOnCondition("TradeIsBusy",1.0,0.0 )-Error #",
115.          _GetLastError );
116.        continue;
117.       }
118.      }
119.      //如果沒有錯誤，說明TradeIsBusy = 1 (其他智能交易在運行), 
120.      // 隨後顯示信息並且等待...
121.      Comment("等待其他智能交易交易完成...");
122.      Sleep(1000);
123.      Comment("");
124.     }
125.   }
126.  

復制代碼
在這裡可以清楚地看到:
檢測整體變量是否存在，如果沒有，進行創建
試圖改變整體變量的值從 0到 1;如果其值等於0，將開啟。
函數可以運行 MaxWaiting_sec，並且不從圖表中刪除任何商品。
錯誤信息生成你可以在日志中找到。

6. 函數TradeIsNotBusy()
函數TradeIsNotBusy 解決返回的問題:開啟"綠色"。
這項功能沒有限定並且不能由用戶中止。方式非常簡單:如果 "綠色" 關閉，智能交易將不會進行交易。
不會返回任何代碼:結果只能被成功編譯。
參見下面示例:

1. /////////////////////////////////////////////////////////////////////////////////
2. // void TradeIsNotBusy()
3. //
4. // 函數設置整體變量 TradeIsBusy 值等於0.
5. // 如果TradeIsBusy不存在，函數創建。
6. /////////////////////////////////////////////////////////////////////////////////
7. void TradeIsNotBusy()
8.   {
9.     int _GetLastError;
10.     // 測試時，交易作業不被劃分 - 只是終止 
11.     // 此函數
12.     if(IsTesting()) 
13.       { 
14.         return(0); 
15.       }
16.     while(true)
17.       {
18.         // 如果智能交易被用戶中止，停止業務
19.         if(IsStopped()) 
20.           { 
21.             Print("智能交易被用戶中止!"); 
22.             return(-1); 
23.           }
24.         // 嘗試設置整變量值= 0 (創建整體變量)
25.         // 如果 GlobalVariableSet 返回值 > 0, 說明成功
26.         // 離開函數
27.         if(GlobalVariableSet( "TradeIsBusy", 0.0 ) > 0) 
28.             return(1);
29.         else
30.         // 如果GlobalVariableSet 返回值 <= 0, 說明錯誤生成
31.         // 顯示信息，等待並且嘗試重新開始
32.          {
33.          _GetLastError = GetLastError();
34.          if(_GetLastError != 0 )
35.            Print("TradeIsNotBusy()-GlobalVariableSet("TradeIsBusy",0.0)-Error #", 
36.                  _GetLastError );
37.          }
38.         Sleep(100);
39.       }
40.   }

復制代碼
7. 在智能交易中的結合使用
現在我們有 3 個函數可以通向交易作業。使他們簡單地結合到智能交易中，我們可以創建一個 TradeContext.mq4 文件並且使用 #include (獲取文件)。
這是一個使用函數 TradeIsBusy()和函數TradeIsNotBusy()的模板:

1. #include <TradeContext.mq4>
2.  
3. int start()
4.   {
5.     // 現在檢測是否進入市場
6.     ...
7.     // 計算止損水平，贏利水平和標准手數
8.     ...
9.     // 等待交易作業空閒並且進入(如果生成錯誤, 
10.     // 離開)
11.     if(TradeIsBusy() < 0) 
12.         return(-1); 
13.     // 刷新市場信息
14.     RefreshRates();
15.     // 重新計算止損和贏利水平
16.     ...
17.     // 開倉
18.     if(OrderSend(...) < 0) 
19.       { 
20.         Alert("錯誤開倉位置 # ", GetLastError()); 
21.       }
22.  
23.     //設置交易作業空閒
24.     TradeIsNotBusy();
25.  
26.     return(0);
27.   }
28.  

復制代碼
在使用函數 TradeIsBusy()和函數 TradeIsNotBusy()時，只有一個問題能夠產生: 如果在交易作業變成忙後，智能交易從圖表中移除，變量 TradeIsBusy將會等於 1。其他的智能交易將不可能運行。
這個問題可以很輕松地解決: 在智能交易在圖表中交易時，不從圖表中移除;)
在終端停歇時， TradeIsBusy值也有可能不等於0。這種情況，函數 TradeIsNotBusy()從智能交易的函數 init() 被使用。
當然，在任何時間內可以手動改變變量值: 終端內的F3鍵 。不建議進行使用。 外_匯_邦 WaiHuiBang.com