Jak uzyskać migawkę ceny na żywo w bloomberg?

Question

Szukam uzyskać migawkę ceny na żywo z Bloomberg .Net API 3 z C#.

Widzę z próbek, jak uzyskać historyczne ceny lub subskrybować dane, ale nie mogę znaleźć prawidłowego żądania, aby uzyskać migawkę książki zamówień, tj. Bid/Ask/Last trade Price and Quantities.

Dla kleszcza intraday chciałbym zrobić coś takiego:

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

Czy istnieje inny, żywo prośba migawka?

Answer 1

Minimalnie zaadaptowany z przykładu, który pochodzi z 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

Jeśli chcesz się upewnić cennik absolutnie na żywo, prawdopodobnie użyć API usługi subskrypcji (// BLP/mktdata), które również Zwróć cenę z dokładnym czasem ostatniego oznaczonego tagiem handlu.

Jest to dobry przykład w Przewodniku programisty dostępnym za pośrednictwem terminalu Bloomberg w dodatku C.2 (Paradygmat subskrypcji).

Answer 3

Wygląda na to, że nie ma konkretnego żądania Bloomberg dotyczącego "Live Snapshot" portfela zamówień. Inne metody są oczywiście udokumentowane w przykładach, ale wydaje się, że Bloomberg nie daje tego w swoim API .Net.

Istnieją żądania danych referencyjnych, które wydają się być najbliższe zapytaniu typu migawka, ale nie ma dokumentacji opóźnienia w aktualizacji tych zmiennych. Nazwa "referencja" nie wzbudza wielkiego zaufania do czegoś brzmiącego jak żądanie w czasie rzeczywistym.

Subskrypcja jest alternatywną metodą dla zapytania typu migawka i może być lepsza w wielu aplikacjach. Dzięki subskrypcji aktualizacje książki zamówień są przesyłane strumieniowo na żywo do gniazda. Wadą tego podejścia jest to, że potrzebna jest wewnętrzna architektura do jego obsługi, a także może być konieczne oczekiwanie na czas nieokreślony, aby zobaczyć jakąkolwiek aktywność na niektórych rynkach.

Mając to na uwadze, uważam, że najlepsze jest podejście próbne i błędne, a współpraca z innym dostawcą danych może być bardziej owocna.

Answer 4

Jeśli chcesz uzyskać ceny w czasie rzeczywistym, a nie statyczne, możesz to zrobić za pomocą ReferenceDataRequest. Jedyna różnica, jakiego pola użyć. PX_LAST podaje ostatnią cenę, która wlicza się do miesięcznego limitu danych referencyjnych. LAST_PRICE daje ci ostatnią cenę w czasie rzeczywistym, która wlicza się do miesięcznego limitu danych w czasie rzeczywistym.

. PS: Mam te informacje z naszego Bloomberg Sales Rep