¿Cómo obtener una instantánea del precio en vivo en Bloomberg?

Question

Estoy buscando obtener una instantánea del precio real de Bloomberg .Net API 3 con C#.

Puedo ver en las muestras cómo obtener precios históricos o suscribir datos, pero no puedo encontrar la solicitud correcta para obtener una instantánea del libro de pedidos, es decir, Bid/Ask/Last trade Price and Quantities.

Para una garrapata intradía me gustaría hacer algo como esto:

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)); 

¿Hay una solicitud instantánea diferente, en directo?

Answer 1

mínimamente adaptado del ejemplo que viene con la 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); 
        } 
       } 
      } 
     } 
    } 
} 

Answer 2

Si desea asegurarse de precios absolutamente vivo, es probable que utilice el servicio de suscripción API (// BLP/mktdata), que también devuelva el precio con la hora exacta de la última operación etiquetada.

Hay un buen ejemplo de esto en la Guía del desarrollador disponible a través de un Terminal de Bloomberg en el apéndice C.2 (El paradigma de suscripción uno).

Answer 3

Parece que no hay una solicitud específica de Bloomberg para una "instantánea en vivo" de la cartera de pedidos. Los otros métodos están obviamente documentados en los ejemplos, pero parece que Bloomberg no da esto en su API .Net.

Existen solicitudes de datos de referencia que parecen ser las más cercanas a una consulta de tipo de instantánea, pero no hay documentación sobre la latencia en la actualización de estas variables. El nombre 'referencia' no inspira gran confianza en algo que suena como una solicitud en tiempo real.

Una suscripción es el método alternativo a una solicitud de tipo de instantánea y puede ser superior en muchas aplicaciones. Con una suscripción, las actualizaciones de la cartera de pedidos se transmiten en vivo a su socket. El inconveniente de este enfoque es que necesita la arquitectura interna para soportarlo y también puede tener que esperar durante un tiempo indeterminado para ver cualquier actividad en algunos mercados.

Con esto en mente, creo que un enfoque de prueba y error es el mejor, y trabajar con otro proveedor de datos podría ser más fructífero.

Answer 4

Si necesita obtener precios en tiempo real y no los estáticos, puede hacerlo a través de ReferenceDataRequest. La única diferencia es qué campo usar. PX_LAST le ofrece el último precio que cuenta para su límite mensual de datos de referencia. LAST_PRICE le brinda el último precio en tiempo real que cuenta para su límite mensual de datos en tiempo real.

PS:. Tengo esta información de nuestra Bloomberg representante de ventas