C# 如何在彭博社获得实时价格快照？

我想从Bloomberg.NETAPI3上用C#获得一个实时价格快照

我可以从样本中看到如何获取历史价格或订阅数据，但我找不到获取订单簿快照的正确请求，即出价/要价/上次交易价格和数量

对于日内的滴答声，我会这样做：

Service refDataService = d_session.GetService("//blp/refdata");
// create intraday tick request
Request request = refDataService.CreateRequest("IntradayTickRequest");
// set request parameters
request.Set("includeConditionCodes", checkBoxIncludeConditionCode.Checked);
request.Set("includeExchangeCodes", checkBoxIncludeExchangeCode.Checked);
Element eventTypes = request.GetElement("eventTypes");
eventTypes.AppendValue("TRADE");
eventTypes.AppendValue("BID");
eventTypes.AppendValue("ASK");
request.Set("security", d_requestSecurity);
request.Set("startDateTime", new BDateTime(startDate.Year, startDate.Month,
             startDate.Day,startDate.Hour, startDate.Minute, startDate.Second, 0));
request.Set("endDateTime", new BDateTime(endDate.Year, endDate.Month, endDate.Day,
             endDate.Hour, endDate.Minute, endDate.Second, 0));

---

是否存在不同的实时快照请求？

根据API附带的示例进行了最低限度的修改：

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Bloomberglp.Blpapi;

namespace BbServerApiTool
{
    public class GetFields : GetBloombergFields
    {
        private static readonly Name EXCEPTIONS = new Name("exceptions");
        private static readonly Name FIELD_ID = new Name("fieldId");
        private static readonly Name REASON = new Name("reason");
        private static readonly Name CATEGORY = new Name("category");
        private static readonly Name DESCRIPTION = new Name("description");
        private static readonly Name ERROR_CODE = new Name("errorCode");
        private static readonly Name SOURCE = new Name("source");
        private static readonly Name SECURITY_ERROR = new Name("securityError");
        private static readonly Name MESSAGE = new Name("message");
        private static readonly Name RESPONSE_ERROR = new Name("responseError");
        private static readonly Name SECURITY_DATA = new Name("securityData");
        private static readonly Name FIELD_EXCEPTIONS = new Name("fieldExceptions");
        private static readonly Name ERROR_INFO = new Name("errorInfo");

        public override List<List<string>> GetBbFields(string[] tickers, string[] fieldsParam)
        {
            string serverHost = System.Configuration.ConfigurationManager.AppSettings["Host"];
            int serverPort = Int32.Parse(System.Configuration.ConfigurationManager.AppSettings["Port"]);

            var sessionOptions = new SessionOptions {ServerHost = serverHost, ServerPort = serverPort};

            var session = new Session(sessionOptions);
            session.Start();
            session.OpenService("//blp/refdata");
            Service refDataService = session.GetService("//blp/refdata");
            Request request = refDataService.CreateRequest("ReferenceDataRequest");
            Element securities = request.GetElement("securities");
            Element fields = request.GetElement("fields");
            request.Set("returnEids", true);

            foreach (var ticker in tickers)
            {
                securities.AppendValue(ticker);
            }

            foreach (var field in fieldsParam)
            {
                fields.AppendValue(field);
            }

            var cID = new CorrelationID(1);
            session.Cancel(cID);
            Results = new List<List<string>>();
            session.SendRequest(request, cID);

            while (true)
            {
                Event eventObj = session.NextEvent();
                processEvent(eventObj, session, fieldsParam);
                if (eventObj.Type == Event.EventType.RESPONSE)
                {
                    return Results;   
                }
            }
        }

        protected override string GetName()
        {
            return "BbServerApiTool";
        }

        private void processEvent(Event eventObj, Session session, string[] fields)
        {
            switch (eventObj.Type)
            {
                case Event.EventType.RESPONSE:
                case Event.EventType.PARTIAL_RESPONSE:
                    processRequestDataEvent(eventObj, session, fields);
                    break;
                default:
                    processMiscEvents(eventObj, session);
                    break;
            }
        }

        private void processMiscEvents(Event eventObj, Session session)
        {
            foreach (Message msg in eventObj.GetMessages())
            {
                switch (msg.MessageType.ToString())
                {
                    case "RequestFailure":
                        Element reason = msg.GetElement(REASON);
                        string message = string.Concat("Error: Source-", reason.GetElementAsString(SOURCE),
                            ", Code-", reason.GetElementAsString(ERROR_CODE), ", category-", reason.GetElementAsString(CATEGORY),
                            ", desc-", reason.GetElementAsString(DESCRIPTION));
                        throw new ArgumentException(message);
                    case "SessionStarted":
                    case "SessionTerminated":
                    case "SessionStopped":
                    case "ServiceOpened":
                    default:
                        break;
                }
            }
        }
        private void processRequestDataEvent(Event eventObj, Session session, string[] fields)
        {
            foreach (Message msg in eventObj.GetMessages())
            {
                if (msg.MessageType.Equals(Name.GetName("ReferenceDataResponse")))
                {
                    Element secDataArray = msg.GetElement(SECURITY_DATA);
                    int numberOfSecurities = secDataArray.NumValues;
                    for (int index = 0; index < numberOfSecurities; index++)
                    {
                        Element secData = secDataArray.GetValueAsElement(index);
                        Element fieldData = secData.GetElement("fieldData");

                        if (secData.HasElement(FIELD_EXCEPTIONS))
                        {
                            // process error
                            Element error = secData.GetElement(FIELD_EXCEPTIONS);
                            if (error.Elements.Count() > 0)
                            {
                                Element errorException = error.GetValueAsElement(0);
                                Element errorInfo = errorException.GetElement(ERROR_INFO);
                                string message = errorInfo.GetElementAsString(MESSAGE);
                                throw new ArgumentException(message);
                            }
                        }

                        var list = new List<string> { secData.GetElement("security").GetValueAsString() };
                        if (secData.HasElement(SECURITY_ERROR))
                        {
                            Element error = secData.GetElement(SECURITY_ERROR);
                            string errorMessage = error.GetElementAsString(MESSAGE);
                            //                            throw new ArgumentException(errorMessage);
                            //TODO Log
                            logger.WriteLine("Couldn't get a value for " + secData.GetElement("security").GetValueAsString());
                            foreach (var field in fields)
                            {
                                list.Add("N/A");
                            }
                        }
                        else
                        {
                            foreach (var field in fields)
                            {
                                Element item = fieldData.GetElement(field);
                                list.Add(item.IsNull ? "N/A" : item.GetValueAsString());
                            }
                        }
                        Results.Add(list);
                    }
                }
            }
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.IO；
使用System.Linq；
使用Bloombergglp.Blpapi；
名称空间BBServerAPI工具
{
公共类GetFields:GetBloombergFields
{
私有静态只读名称异常=新名称（“异常”）；
私有静态只读名称字段_ID=新名称（“字段ID”）；
私有静态只读名称原因=新名称（“原因”）；
私有静态只读名称类别=新名称（“类别”）；
私有静态只读名称描述=新名称（“描述”）；
私有静态只读名称错误\ U代码=新名称（“错误代码”）；
私有静态只读名称源=新名称（“源”）；
私有静态只读名称SECURITY_ERROR=新名称（“securityError”）；
私有静态只读名称消息=新名称（“消息”）；
私有静态只读名称响应_ERROR=新名称（“responseError”）；
私有静态只读名称SECURITY_DATA=新名称（“securityData”）；
私有静态只读名称字段_异常=新名称（“字段异常”）；
私有静态只读名称错误_INFO=新名称（“errorInfo”）；
公共覆盖列表GetBbFields（字符串[]标记器，字符串[]字段SPARAM）
{
字符串serverHost=System.Configuration.ConfigurationManager.AppSettings[“主机”]；
int serverPort=Int32.Parse（System.Configuration.ConfigurationManager.AppSettings[“端口]）；
var sessionOptions=newsessionoptions{ServerHost=ServerHost，ServerPort=ServerPort}；
var会话=新会话（会话选项）；
session.Start（）；
session.OpenService（“//blp/refdata”）；
服务refDataService=session.GetService（“//blp/refdata”）；
Request-Request=refDataService.CreateRequest（“ReferenceDataRequest”）；
元素证券=request.GetElement（“证券”）；
元素字段=request.GetElement（“字段”）；
request.Set（“returnEids”，true）；
foreach（报价器中的var报价器）
{
证券.附加价值（股票代码）；
}
foreach（fieldsParam中的var字段）
{
字段。追加值（字段）；
}
var cID=新的相关ID（1）；
会话取消（cID）；
结果=新列表（）；
session.SendRequest（请求，cID）；
while（true）
{
Event eventObj=session.NextEvent（）；
processEvent（eventObj、session、fieldsParam）；
if（eventObj.Type==Event.EventType.RESPONSE）
{
返回结果；
}
}
}
受保护的重写字符串GetName（）
{
返回“bbserverapitol”；
}
私有void processEvent（Event eventObj、会话会话、字符串[]字段）
{
开关（事件对象类型）
{
case Event.EventType.RESPONSE：
case Event.EventType.PARTIAL_响应：
processRequestDataEvent（eventObj、会话、字段）；
打破
违约：
processMiscEvents（eventObj，会话）；
打破
}
}
私有void processMiscEvents（事件eventObj，会话会话）
{
foreach（eventObj.GetMessages（）中的消息msg）
{
开关（msg.MessageType.ToString（））
{
案例“请求失败”：
元素原因=msg.GetElement（原因）；
string message=string.Concat（“错误：源-”，reason.GetElementAsString（源），
“，代码-”，reason.GetElementAsString（错误代码），“，类别-”，reason.GetElementAsString（类别），
“，desc-”，reason.GetElementAsString（说明））；
抛出新的ArgumentException（消息）；
案例“开庭开始”：
“开庭终止”一案：
案例“SessionStopped”：
案例“ServiceOpened”：
违约：
打破
}
}
}
private void processRequestDataEvent（事件eventObj，会话会话，字符串[]字段）
{
foreach（eventObj.GetMessages（）中的消息msg）
{
if（msg.MessageType.Equals（Name.GetName（“ReferenceDataResponse”））
{
Element secDataArray=msg.GetElement（安全数据）；
int numberOfSecurities=secDataArray.NumValues；
对于（int index=0；index0）
{
Element errorException=错误。GetValueAsElement（0）；
Element errorInfo=errorException.GetElement（错误信息）；