MQL5 交易工具包（第 5 部分）：使用仓位函数扩展历史管理 EX5 库

概述

在上一篇文章中，我们开始开发 HistoryManager EX5 库 的主要函数，该库构成了核心引擎，负责检索、排序和将历史数据分类为各种类型，包括订单、交易、挂单和仓位。大多数这些函数都是设计在后台运行的，库用户不会注意到，并且无法直接访问。唯一可导出的功能是打印函数，它允许用户将订单、交易、挂单或仓位的简单描述列表输出到 MetaTrader 5 日志。

在本文中，我们将通过引入其他用户可访问的函数来扩展 HistoryManager.mq5 源代码，这些函数基于我们在上一篇文章中创建的基础函数。这些新函数将允许库用户轻松查询交易历史数据。用户将能够检索关键详细信息，例如交易持续时间（以秒为单位）、上次平仓的开仓和平仓交易单号、该仓位是通过挂单还是直接入场发起、基于点值的指标（如利润、止损和止盈）以及扣除佣金和库存费等费用后的净利润。所有这些都将允许您在 MQL5 项目中导入 EX5 库，并能够通过简单的函数调用以最小的努力查询各种仓位的历史记录。

首先，我们将打开上一篇文章中的 HistoryManager.mq5 文件，并开始创建 GetTotalDataInfoSize() 函数。初始的 HistoryManager.mq5 源文件附加在上一篇文章的末尾，也可以在本文的末尾找到（ HistoryManager_Part1.mq5） 。我们将继续在 PrintPendingOrdersHistory() 函数下方添加新代码，这是我们之前停下来的地方。

获取总数据信息大小函数

GetTotalDataInfoSize() 函数用于检索并返回指定历史数据数组的大小。该函数与 FetchHistoryByCriteria() 函数协同工作，确保我们可以动态确定特定数据结构中可用的数据量。它的主要作用是识别我们感兴趣的数据集（交易、订单、仓位或挂单），并返回该数据集中的元素总数。

GetTotalDataInfoSize() 函数将有助于简化需要动态访问各种历史数据集的操作。通过传递适当的条件作为参数，我们将有效地查询相关数据结构的大小。

我们将从定义函数签名开始。由于此函数返回一个表示指定数据数组大小的整数，因此它使用 int 返回类型。输入参数或参数是一个无符号整数（ uint ），它允许我们传递预定义的常量来指定我们正在查询的数据类型。

int GetTotalDataInfoSize(uint dataToGet)
  {
//-- Our function's code will go here
  }

接下来，我们将声明一个局部变量 totalDataInfo ，它将存储所请求数据集的大小。

int totalDataInfo = 0;

我们将使用 switch 语句来检查 dataToGet 参数的值。根据其值，我们将识别相应的数据集并使用 ArraySize() 函数确定其大小。

• 交易历史数据：如果 dataToGet 等于 GET_DEALS_HISTORY_DATA ，我们将计算 dealInfo 数组的大小并将其保存到 totalDataInfo 。
• 订单历史数据：如果 dataToGet 等于 GET_ORDERS_HISTORY_DATA ，我们将计算 orderInfo 数组的大小并将其保存到 totalDataInfo 。
• 仓位历史数据：对于 GET_POSITIONS_HISTORY_DATA ，我们将计算 positionInfo 数组的大小并将其保存到 totalDataInfo 。
• 挂单数据：当 dataToGet 与 GET_PENDING_ORDERS_HISTORY_DATA 匹配时，我们将确定 pendingOrderInfo 数组的大小并将其保存到 totalDataInfo中。
• 默认情况：如果没有预定义的常量匹配，我们将把 totalDataInfo 设置为 0 作为后备。

最后，退出 switch 后我们将返回存储在 totalDataInfo 中的值。这将确保函数输出指定数据类型的正确大小，如果没有提供有效的数据类型，则输出 0 。

switch(dataToGet)
  {
   case GET_DEALS_HISTORY_DATA:
      totalDataInfo = ArraySize(dealInfo);
      break;

   case GET_ORDERS_HISTORY_DATA:
      totalDataInfo = ArraySize(orderInfo);
      break;

   case GET_POSITIONS_HISTORY_DATA:
      totalDataInfo = ArraySize(positionInfo);
      break;

   case GET_PENDING_ORDERS_HISTORY_DATA:
      totalDataInfo = ArraySize(pendingOrderInfo);
      break;

   default:
      totalDataInfo = 0;
      break;
  }
return(totalDataInfo);

下面是 GetTotalDataInfoSize() 函数的完整实现，其中所有代码段均按正确的顺序排列。

int GetTotalDataInfoSize(uint dataToGet)
  {
   int totalDataInfo = 0; //- Saves the total elements of the specified history found
   switch(dataToGet)
     {
      case GET_DEALS_HISTORY_DATA: //- Check if we have any available deals history data
         totalDataInfo = ArraySize(dealInfo); //- Save the total deals found
         break;

      case GET_ORDERS_HISTORY_DATA: //- Check if we have any available orders history data
         totalDataInfo = ArraySize(orderInfo); //- Save the total orders found
         break;

      case GET_POSITIONS_HISTORY_DATA: //- Check if we have any available positions history data
         totalDataInfo = ArraySize(positionInfo); //- Save the total positions found
         break;

      case GET_PENDING_ORDERS_HISTORY_DATA: //- Check if we have any available pending orders history data
         totalDataInfo = ArraySize(pendingOrderInfo); //- Save the total pending orders found
         break;

      default: //-- Unknown entry
         totalDataInfo = 0;
         break;
     }
   return(totalDataInfo);
  }

按条件获取历史记录函数

当使用 MQL5 查询最近的历史数据时，例如检索特定交易品种的最后 5 个已平仓买入头寸，不需要从服务器请求整个账户历史，因为这会浪费宝贵的资源。相反，您应该采用最佳方法，首先查询最近的交易历史，例如当天的交易历史。如果您要查找的特定数据在此期间不可用，则可以逐步延长时间范围，直到找到目标数据。此方法可确保效率并最大限度地减少资源使用，在检索必要的历史数据时提供最佳性能。

FetchHistoryByCriteria() 函数根据特定标准系统地检索历史数据，从过去 24 小时开始，并在必要时扩大检索期。它首先检查最新的数据，如果没有找到相关的历史记录，它会逐步扫描旧数据 —— 首先是每周，最长可达一年。如果在扫描全年后没有找到数据，它将尝试检索所有可用的帐户历史记录。

FetchHistoryByCriteria() 函数将作为从不同时期获取交易数据的关键实用过程，并允许 EX5 库扫描和检索历史记录，直到找到所需的数据。如果没有找到相关数据，它将确保库仍然可以尝试检索旧的或完整的帐户历史记录。

让我们首先定义函数签名。由于此函数将由库核心模块在内部使用，因此不可导出。

bool FetchHistoryByCriteria(uint dataToGet)
  {
//-- Our function's code will go here
  }

我们将定义区间变量，用于调节历史检索时间段。最初，它将被设置为 1，以 24 小时时间范围开始。

int interval = 1;

我们将计算从 24 小时前到当前时间的时间范围。

datetime fromDateTime = TimeCurrent() - 1 * (PeriodSeconds(PERIOD_D1) * interval);
datetime toDateTime = TimeCurrent();

接下来，我们将使用 GetHistoryData() 函数来获取定义时间范围内的数据。

GetHistoryData(fromDateTime, toDateTime, dataToGet);

如果在过去 24 小时内没有找到数据，我们将进入一个循环，每次将间隔增加一周。我们将继续这个过程，直到扫描整整一年（ 53 周）。在每次迭代过程中，时间范围都会更新以反映额外的一周。

while(GetTotalDataInfoSize(dataToGet) <= 0)
  {
   interval++;
   fromDateTime = TimeCurrent() - 1 * (PeriodSeconds(PERIOD_W1) * interval);
   toDateTime = TimeCurrent();
   GetHistoryData(fromDateTime, toDateTime, dataToGet);

   if(interval > 53)
     {
      break;
     }
  }

如果扫描一年后仍未找到数据，我们将重置时间范围以覆盖整个帐户历史记录（从最早的历史到当前时间）。这可确保检查所有可用的历史记录。

fromDateTime = 0;
toDateTime = TimeCurrent();
GetHistoryData(fromDateTime, toDateTime, dataToGet);

最后，我们将检查是否已成功检索到任何历史记录。如果扫描整个帐户历史记录后仍未找到任何数据，我们将记录失败并返回 false 。如果找到数据，我们将返回 true 以表示成功。

if(GetTotalDataInfoSize(dataToGet) <= 0)
  {
   return(false);
  }
else
  {
   return(true);
  }

这是 FetchHistoryByCriteria() 函数的完整实现，其中包含所有代码段。

bool FetchHistoryByCriteria(uint dataToGet)
  {
   int interval = 1; //- Modulates the history period

//- Save the history period for the last 24 hours
   datetime fromDateTime = TimeCurrent() - 1 * (PeriodSeconds(PERIOD_D1) * interval);
   datetime toDateTime = TimeCurrent();

//- Get the specified history
   GetHistoryData(fromDateTime, toDateTime, dataToGet);

//- If we have no history in the last 24 hours we need to keep increasing the retrieval
//- period by one week untill we scan a full year (53 weeks)
   while(GetTotalDataInfoSize(dataToGet) <= 0)
     {
      interval++;
      fromDateTime = TimeCurrent() - 1 * (PeriodSeconds(PERIOD_W1) * interval);
      toDateTime = TimeCurrent();
      GetHistoryData(fromDateTime, toDateTime, dataToGet);

      //- If no history is found after a one year scanning period, we exit the while loop
      if(interval > 53)
        {
         break;
        }
     }

//- If we have not found any trade history in the last year, we scan and cache the intire account history
   fromDateTime = 0; //-- 1970 (Epoch)
   toDateTime = TimeCurrent(); //-- Time now
   GetHistoryData(fromDateTime, toDateTime, dataToGet);

//- If we still havent retrieved any history in the account, we log this info by
//- printing it and exit the function by returning false
   if(GetTotalDataInfoSize(dataToGet) <= 0)
     {
      return(false); //- Specified history not found, exit and return false
     }
   else
     {
      return(true); //- Specified history found, exit and return true
     }
  }

获取最近平仓数据函数

GetLastClosedPositionData() 函数负责检索最近平仓的属性并将该数据存储在提供的 lastClosedPositionInfo 引用中。该函数将依赖 FetchHistoryByCriteria() 函数来获取相关的交易历史数据，确保其能够访问必要的仓位信息。如果没有发现平仓，该函数将记录一条错误消息并返回 false 。如果成功，它将检索数据并返回 true 。

让我们首先定义函数签名。由于此函数旨在供外部使用，因此它被导出并可由其他 MQL5 源文件导入。

bool GetLastClosedPositionData(PositionData &lastClosedPositionInfo) export
  {
//-- Our function's code will go here
  }

我们将首先尝试通过使用 GET_POSITIONS_HISTORY_DATA 参数调用 FetchHistoryByCriteria() 函数来获取可用的仓位历史数据。此函数调用将搜索可用的交易历史记录以检索与仓位相关的数据。

if(!FetchHistoryByCriteria(GET_POSITIONS_HISTORY_DATA))
  {
   Print(__FUNCTION__, ": No trading history available. Last closed position can't be retrieved.");
   return(false);
  }

如果没有可用的仓位历史数据（即 FetchHistoryByCriteria() 函数返回 false ），我们将使用 Print() 函数记录错误消息，该函数通过提供有关失败的有用信息来帮助调试。然后该函数返回 false ，表示无法检索最后平仓的仓位。

如果成功检索到仓位历史数据，我们将在 lastClosedPositionInfo 变量中保存最后平仓的信息。这是通过将 positionInfo 数组中的第一个元素分配给 lastClosedPositionInfo 来完成的，因为该数组包含所有仓位的历史记录，其中最近平仓的仓位位于数组的开头。为了完成该函数，我们将返回 true 以表明最后平仓的数据已成功检索并存储在提供的引用变量中。

lastClosedPositionInfo = positionInfo[0];
return(true);

这是 GetLastClosedPositionData() 函数的完整实现，其中包括所有代码段。

bool GetLastClosedPositionData(PositionData &lastClosedPositionInfo) export
  {
   if(!FetchHistoryByCriteria(GET_POSITIONS_HISTORY_DATA))
     {
      Print(__FUNCTION__, ": No trading history available. Last closed position can't be retrieved.");
      return(false);
     }

//-- Save the last closed position data in the referenced lastClosedPositionInfo variable
   lastClosedPositionInfo = positionInfo[0];
   return(true);
  }

最后平仓仓位类型函数

LastClosedPositionType() 函数将负责确定交易账户中最近关闭的仓位的类型，并将其存储在引用变量 lastClosedPositionType 中。此函数是GetLastClosedPositionData()函数的逻辑扩展，利用其检索最后关闭的仓位并提取其特定类型的功能。

在需要分析最近交易的类型时，需要使用 LastClosedPositionType() 函数，例如区分买入和卖出仓位，或根据仓位类型识别更复杂的策略。

让我们首先定义函数签名。由于此函数旨在供导入 EX5 库的 MQL5 文件使用，因此我们将其标记为可导出。这将确保该函数可从外部访问，从而增强模块化和可用性。

bool LastClosedPositionType(ENUM_POSITION_TYPE &lastClosedPositionType) export
  {
//-- Our function's code will go here
  }

我们首先声明一个 PositionData 类型的局部变量 lastClosedPositionInfo 。此变量将临时存储最后平仓的详细信息，我们将使用 GetLastClosedPositionData() 函数提取这些信息。

PositionData lastClosedPositionInfo;

我们调用 GetLastClosedPositionData() 函数，并将 lastClosedPositionInfo 作为参数传递。如果函数返回 true ，则表示已成功检索最后平仓的数据。

if(GetLastClosedPositionData(lastClosedPositionInfo))
{
   //- Process the retrieved data
}

如果 GetLastClosedPositionData() 失败（返回 false ），则此函数立即退出，返回 false 以表明操作无法完成。

在 if 块中，我们从 lastClosedPositionInfo 中提取 type 属性并将其分配给引用变量 lastClosedPositionType 。这确保调用代码可以访问最后关闭的仓位的类型。成功保存类型后，我们返回 true 表示操作成功并退出函数。

lastClosedPositionType = lastClosedPositionInfo.type;
return(true);

如果检索最后平仓失败，函数将跳过 if 块并直接返回 false 。这表明无法确定仓位类型。

return(false);

以下是 LastClosedPositionType() 函数的完整实现，其中所有代码段均按正确顺序排列。

bool LastClosedPositionType(ENUM_POSITION_TYPE &lastClosedPositionType) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionType = lastClosedPositionInfo.type;
      return(true);
     }
   return(false);
  }

最近平仓交易量函数

LastClosedPositionVolume() 函数负责检索交易历史记录中最近平仓的交易量。它将该交易量保存到引用变量 lastClosedPositionVolume 中。如果 LastClosedPositionVolume() 函数成功检索到最后平仓的数据，它会使用交易量值更新 lastClosedPositionVolume 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionVolume 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionVolume(double &lastClosedPositionVolume) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionVolume = lastClosedPositionInfo.volume;
      return(true);
     }
   return(false);
  }

最近平仓交易品种函数

LastClosedPositionSymbol() 函数负责检索交易历史记录中最近平仓的仓位交易品种。它将该交易品种保存到引用变量 lastClosedPositionSymbol 中。如果 LastClosedPositionSymbol() 函数成功检索到最后平仓的数据，它会使用交易品种值更新 lastClosedPositionSymbol 变量，并通过返回 true 来确认操作成功。如果检索数据失败，则 lastClosedPositionSymbol 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionSymbol(string &lastClosedPositionSymbol) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionSymbol = lastClosedPositionInfo.symbol;
      return(true);
     }
   return(false);
  }

最近平仓单号函数

LastClosedPositionTicket() 函数负责检索交易历史记录中最近平仓的编号。它将此编号保存到引用变量 lastClosedPositionTicket 中。如果 LastClosedPositionTicket() 函数成功检索到最后平仓的数据，它会使用编号更新 lastClosedPositionTicket 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionTicket 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionTicket(ulong &lastClosedPositionTicket) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionTicket = lastClosedPositionInfo.ticket;
      return(true);
     }
   return(false);
  }

最近平仓利润函数

LastClosedPositionProfit() 函数负责检索交易历史记录中最近平仓的利润。它将这个利润保存到引用变量 lastClosedPositionProfit 中。如果 LastClosedPositionProfit() 函数成功检索到最后平仓的数据，它会使用利润值更新 lastClosedPositionProfit 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionProfit 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionProfit(double &lastClosedPositionProfit) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionProfit = lastClosedPositionInfo.profit;
      return(true);
     }
   return(false);
  }

最近平仓净利润函数

LastClosedPositionNetProfit() 函数负责检索交易历史记录中最近平仓的净利润。持仓净利润是从持仓利润中扣除佣金和库存费等所有费用后的最终价值。它将净利润保存到引用变量 lastClosedPositionNetProfit 中。如果 LastClosedPositionNetProfit() 函数成功检索到最后平仓的数据，它会使用净利润值更新 lastClosedPositionNetProfit 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionNetProfit 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionNetProfit(double &lastClosedPositionNetProfit) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionNetProfit = lastClosedPositionInfo.netProfit;
      return(true);
     }
   return(false);
  }

最近平仓点数（点）利润函数

LastClosedPositionPipProfit() 函数负责检索交易历史记录中最近平仓的点利润。它将这个点利润保存到引用变量 lastClosedPositionPipProfit 中。如果 LastClosedPositionPipProfit() 函数成功检索到最后平仓的数据，它会使用点利润值更新 lastClosedPositionPipProfit 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionPipProfit 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionPipProfit(int &lastClosedPositionPipProfit) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionPipProfit = lastClosedPositionInfo.pipProfit;
      return(true);
     }
   return(false);
  }

最近平仓价格函数

LastClosedPositionClosePrice() 函数负责检索交易历史记录中最近平仓的平仓价格。它将平仓价格保存到引用变量 lastClosedPositionClosePrice 中。如果 LastClosedPositionClosePrice() 函数成功检索到最后平仓的数据，它会使用平仓价更新 lastClosedPositionClosePrice 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionClosePrice 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionClosePrice(double &lastClosedPositionClosePrice) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionClosePrice = lastClosedPositionInfo.closePrice;
      return(true);
     }
   return(false);
  }

最近平仓开仓价格函数

LastClosedPositionOpenPrice() 函数负责检索交易历史记录中最近平仓的开仓价格。它将这个开盘价保存到引用变量 lastClosedPositionOpenPrice 中。如果 LastClosedPositionOpenPrice() 函数成功检索到最后平仓的数据，它会使用开仓价更新 lastClosedPositionOpenPrice 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionOpenPrice 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionOpenPrice(double &lastClosedPositionOpenPrice) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionOpenPrice = lastClosedPositionInfo.openPrice;
      return(true);
     }
   return(false);
  }

最近平仓止损价格函数

LastClosedPositionSlPrice() 函数负责检索交易历史记录中最近平仓的止损价格。它将止损价格保存到引用变量 lastClosedPositionSlPrice 中。如果 LastClosedPositionSlPrice() 函数成功检索到最后平仓的数据，它会使用止损价格值更新 lastClosedPositionSlPrice 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionSlPrice 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionSlPrice(double &lastClosedPositionSlPrice) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionSlPrice = lastClosedPositionInfo.slPrice;
      return(true);
     }
   return(false);
  }

最近平仓止盈价函数

LastClosedPositionTpPrice() 函数负责检索交易历史记录中最近平仓的止盈价格。它将这个止盈价格保存到引用变量 lastClosedPositionTpPrice 中。如果 LastClosedPositionTpPrice() 函数成功检索到最后平仓的数据，它会使用止盈价格值更新 lastClosedPositionTpPrice 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionTpPrice 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionTpPrice(double &lastClosedPositionTpPrice) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionTpPrice = lastClosedPositionInfo.tpPrice;
      return(true);
     }
   return(false);
  }

最近平仓止损点数（Pips）函数

LastClosedPositionSlPips() 函数负责检索最近平仓的止损值（以点数 ( pips ) 为单位）。它将止损值保存到引用变量 lastClosedPositionSlPips 中。如果 LastClosedPositionSlPips() 函数成功检索到最后平仓的数据，它会使用止损点值更新 lastClosedPositionSlPips 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionSlPips 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionSlPips(int &lastClosedPositionSlPips) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionSlPips = lastClosedPositionInfo.slPips;
      return(true);
     }
   return(false);
  }

最近平仓止盈点数（Pips）函数

LastClosedPositionTpPips() 函数负责检索最近平仓的止盈值（以点数 ( pips ) 为单位）。它将这个止盈值保存到引用变量 lastClosedPositionTpPips中。如果 LastClosedPositionTpPips() 函数成功检索到最后平仓的数据，它会使用止盈点值更新 lastClosedPositionTpPips 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionTpPips 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionTpPips(int &lastClosedPositionTpPips) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionTpPips = lastClosedPositionInfo.tpPips;
      return(true);
     }
   return(false);
  }

最近平仓开仓时间函数

LastClosedPositionOpenTime() 函数负责检索最近平仓的开仓时间。它将这个开仓时间保存到引用变量 lastClosedPositionOpenTime 中。如果 LastClosedPositionOpenTime() 函数成功检索到最后平仓的数据，它会使用开仓时间值更新 lastClosedPositionOpenTime 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionOpenTime 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionOpenTime(datetime &lastClosedPositionOpenTime) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionOpenTime = lastClosedPositionInfo.openTime;
      return(true);
     }
   return(false);
  }

最近平仓平仓时间函数

LastClosedPositionCloseTime() 函数负责检索最近平仓的平仓时间。它将这个平仓时间保存到引用变量 lastClosedPositionCloseTime 中。如果 LastClosedPositionCloseTime() 函数成功检索到最后平仓的数据，它会使用平仓时间值更新 lastClosedPositionCloseTime 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionCloseTime 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionCloseTime(datetime &lastClosedPositionCloseTime) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionCloseTime = lastClosedPositionInfo.closeTime;
      return(true);
     }
   return(false);
  }

最近平仓的仓位库存费函数

LastClosedPositionSwap() 函数负责检索最近平仓的库存费值。它将这个库存费值保存到引用变量 lastClosedPositionSwap 中。如果 LastClosedPositionSwap() 函数成功检索到最后平仓的数据，它会使用库存费值更新 lastClosedPositionSwap 变量，并通过返回 true 来确认操作成功。如果检索数据失败，则 lastClosedPositionSwap 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionSwap(double &lastClosedPositionSwap) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionSwap = lastClosedPositionInfo.swap;
      return(true);
     }
   return(false);
  }

最近平仓佣金函数

LastClosedPositionCommission() 函数负责检索最近平仓的佣金值。它将这个佣金值保存到引用变量 lastClosedPositionCommission 中。如果 LastClosedPositionCommission() 函数成功检索到最后平仓的数据，它会使用佣金值更新 lastClosedPositionCommission 变量，并通过返回 true 来确认操作成功。如果检索数据失败，则 lastClosedPositionCommission 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionCommission(double &lastClosedPositionCommission) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionCommission = lastClosedPositionInfo.commission;
      return(true);
     }
   return(false);
  }

最近平仓订单类型函数

LastClosedPositionInitiatingOrderType() 函数负责检索最近平仓的初始订单类型。这使我们能够知道该仓位是由挂单（买入止损、买入限价、卖出止损、卖出限价、买入止损限价或卖出止损限价）还是直接入场订单发起的。它将这个初始订单类型保存到引用变量 lastClosedPositionInitiatingOrderType 中。如果 LastClosedPositionInitiatingOrderType() 函数成功检索最后平仓的数据，它将使用初始订单类型值更新 lastClosedPositionInitiatingOrderType 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionInitiatingOrderType 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionInitiatingOrderType(ENUM_ORDER_TYPE &lastClosedPositionInitiatingOrderType) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionInitiatingOrderType = lastClosedPositionInfo.initiatingOrderType;
      return(true);
     }
   return(false);
  }

最近平仓仓位 ID 函数

LastClosedPositionId() 函数负责检索最近平仓的 ID 。它将此仓位 ID 保存到引用变量 lastClosedPositionId 中。如果 LastClosedPositionId() 函数成功检索到最后平仓的数据，它会使用仓位 ID 值更新 lastClosedPositionId 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionId 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionId(ulong &lastClosedPositionId) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionId = lastClosedPositionInfo.positionId;
      return(true);
     }
   return(false);
  }

最近平仓仓位的发起挂单函数

LastClosedPositionInitiatedByPendingOrder() 函数负责检查最近平仓的仓位是否由挂单发起。它将此信息保存到引用变量 lastClosedPositionInitiatedByPendingOrder 中。如果 LastClosedPositionInitiatedByPendingOrder() 函数成功检索最后平仓的数据，它将使用结果更 新lastClosedPositionInitiatedByPendingOrder 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionInitiatedByPendingOrder 变量保持不变，并且该函数通过返回 false 来指示失败。

bool LastClosedPositionInitiatedByPendingOrder(bool &lastClosedPositionInitiatedByPendingOrder) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionInitiatedByPendingOrder = lastClosedPositionInfo.initiatedByPendingOrder;
      return(true);
     }
   return(false);
  }

最近平仓开仓订单编号函数

LastClosedPositionOpeningOrderTicket() 函数负责检索最近平仓的开仓订单的编号。它将此编号保存到引用变量 lastClosedPositionOpeningOrderTicket 中。如果 LastClosedPositionOpeningOrderTicket() 函数成功检索到最后平仓的数据，它会使用编号更新 lastClosedPositionOpeningOrderTicket 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionOpeningOrderTicket 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionOpeningOrderTicket(ulong &lastClosedPositionOpeningOrderTicket) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionOpeningOrderTicket = lastClosedPositionInfo.openingOrderTicket;
      return(true);
     }
   return(false);
  }

最近平仓开仓交易编号函数

LastClosedPositionOpeningDealTicket() 函数负责检索最近平仓的开仓交易的编号。它将这个交易编号保存到引用变量 lastClosedPositionOpeningDealTicket 中。如果 LastClosedPositionOpeningDealTicket()函数成功检索到最后平仓的数据，它会使用 交易编号更新 lastClosedPositionOpeningDealTicket 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionOpeningDealTicket 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionOpeningDealTicket(ulong &lastClosedPositionOpeningDealTicket) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionOpeningDealTicket = lastClosedPositionInfo.openingDealTicket;
      return(true);
     }
   return(false);
  }

最近平仓平仓交易编号函数

LastClosedPositionClosingDealTicket() 函数负责检索最近平仓的平仓交易的编号。它将这个交易编号保存到引用变量 lastClosedPositionClosingDealTicket 中。如果 LastClosedPositionClosingDealTicket() 函数成功检索到最后平仓的数据，它会使用交易编号更新 lastClosedPositionClosingDealTicket 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionClosingDealTicket 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionClosingDealTicket(ulong &lastClosedPositionClosingDealTicket) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionClosingDealTicket = lastClosedPositionInfo.closingDealTicket;
      return(true);
     }
   return(false);
  }

最近平仓幻数函数

LastClosedPositionMagic() 函数负责检索最近关闭的仓位的幻数。它将这个幻数保存到引用变量 lastClosedPositionMagic 中。如果 LastClosedPositionMagic() 函数成功检索到最后平仓的数据，它会使用幻数更新 lastClosedPositionMagic 变量，并通过返回 true 来确认操作成功。如果检索数据失败，则 lastClosedPositionMagic 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionMagic(ulong &lastClosedPositionMagic) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionMagic = lastClosedPositionInfo.magic;
      return(true);
     }
   return(false);
  }

最近平仓注释函数

LastClosedPositionComment() 函数负责检索与最近关闭的仓位相关的注释。它将此注释保存到引用变量 lastClosedPositionComment 中。如果 LastClosedPositionComment() 函数成功检索到最后平仓的数据，它会使用注释更新 lastClosedPositionComment 变量，并通过返回 true 确认操作成功。如果检索数据失败，则 lastClosedPositionComment 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionComment(string &lastClosedPositionComment) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionComment = lastClosedPositionInfo.comment;
      return(true);
     }
   return(false);
  }

最近平仓持仓持续时间函数

LastClosedPositionDuration() 函数负责检索最近平仓的持仓时间（以秒为单位）。它将这个持仓时间保存到引用变量 lastClosedPositionDuration 中。如果 LastClosedPositionDuration() 函数成功检索到最近平仓的数据，它会使用持仓时间更新 lastClosedPositionDuration 变量，并通过返回true 确认操作成功。如果检索数据失败，则 lastClosedPositionDuration 变量保持不变，并且函数通过返回 false 来指示失败。

bool LastClosedPositionDuration(long &lastClosedPositionDuration) export
  {
   PositionData lastClosedPositionInfo;
   if(GetLastClosedPositionData(lastClosedPositionInfo))
     {
      lastClosedPositionDuration = lastClosedPositionInfo.duration;
      return(true);
     }
   return(false);
  }

结论

在本文中，您了解了如何将更小、更集中的实用函数（例如我们设计的用于检索最近平仓仓位的特定属性的函数）协同工作以完成目标任务，同时保持 EX5 库代码库的清晰度和模块化。通过隔离提取各种仓位属性的逻辑，这些功能简化了收集特定数据的过程，使其更加清晰、有效。

为了使本文简洁且重点突出，我们将把检索最后完成和取消的挂单的各种属性的库函数的创建推迟到下一篇文章中。在那篇文章中，我们将详细探讨这些函数，确保它们与现有框架很好地集成。接下来，我们将继续开发一套分析报告函数，使用户能够根据历史交易数据生成深刻的摘要和详细的报告。这种循序渐进的方法将确保清晰性，并使我们能够全面地涵盖每个主题，而不会一下子给你带来太多信息。

在本文的结尾，您将找到 HistoryManager.mq5 库源代码的最新版本，其中包括本文中创建的所有函数以及上一篇文章中介绍的函数。 感谢您的关注，我期待着在下一篇文章中再次与您联系。