ब्लूमबर्ग में लाइव मूल्य स्नैपशॉट कैसे प्राप्त करें?

Question

मैं ब्लूमबर्ग से लाइव प्राइस स्नैपशॉट प्राप्त करने के लिए देख रहा हूं। नेट एपीआई 3 सी # के साथ।

मैं नमूनों से ऐतिहासिक कीमतों को प्राप्त करने या डेटा की सदस्यता लेने के लिए देख सकता हूं, लेकिन मुझे ऑर्डर बुक स्नैपशॉट, यानी बोली/पूछ/अंतिम व्यापार मूल्य और मात्रा प्राप्त करने का सही अनुरोध नहीं मिल रहा है।

एक इंट्रा डे टिक मैं कुछ इस तरह करना होगा के लिए:

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

वहाँ एक अलग, लाइव स्नैपशॉट अनुरोध है?

Answer 1

न्यूनतम उदाहरण है कि एपीआई के साथ आता है से अनुकूलित:

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

आप पूरी तरह लाइव मूल्य निर्धारण सुनिश्चित करना चाहते हैं, तो आप शायद सदस्यता सेवा एपीआई (// BLP/mktdata) का प्रयोग करेंगे, जो भी होगा इसे टैग किए गए अंतिम व्यापार के सटीक समय के साथ मूल्य वापस करें।

डेवलपर की परिशिष्ट C.2 (सदस्यता प्रतिमान एक) में एक ब्लूमबर्ग टर्मिनल के माध्यम से उपलब्ध मार्गदर्शिका में यह का एक अच्छा उदाहरण है।

Answer 3

ऐसा प्रतीत होता है ऑर्डर बुक के एक 'लाइव स्नैपशॉट' के लिए कोई विशेष ब्लूमबर्ग अनुरोध है। उदाहरणों में अन्य विधियों को स्पष्ट रूप से दस्तावेज किया गया है, लेकिन ऐसा लगता है कि ब्लूमबर्ग इसे अपने .NET API में नहीं देते हैं।

संदर्भ डेटा अनुरोधों जो क्वेरी का एक स्नैपशॉट प्रकार के सबसे करीब होने लगते हैं, लेकिन वहाँ इन चरों को अद्यतन करने में विलंबता पर कोई प्रलेखन है। नाम 'संदर्भ' वास्तविक समय अनुरोध की तरह कुछ ध्वनि में बहुत भरोसा नहीं करता है।

एक सदस्यता अनुरोध का एक स्नैपशॉट प्रकार के वैकल्पिक पद्धति है और कई अनुप्रयोगों में बेहतर हो सकता है। सदस्यता के साथ, ऑर्डर बुक के अपडेट आपके सॉकेट में लाइव स्ट्रीम किए जाते हैं। इस दृष्टिकोण के साथ दोष यह है कि आपको इसका समर्थन करने के लिए आंतरिक वास्तुकला की आवश्यकता है और आपको कुछ बाजारों में किसी भी गतिविधि को देखने के लिए समय की अनिश्चित अवधि की प्रतीक्षा करनी पड़ सकती है।

इसे ध्यान में रखते

, मुझे लगता है कि एक परीक्षण और त्रुटि दृष्टिकोण सबसे अच्छा है, और एक अन्य डेटा प्रदाता के साथ काम करने और अधिक उपयोगी हो सकता है।

Answer 4

आप वास्तविक समय की कीमतों और नहीं स्थिर लोगों को पाने के लिए की जरूरत है, यू यह ReferenceDataRequest के माध्यम से अभी भी कर सकते हैं। एकमात्र अंतर जो फ़ील्ड का उपयोग करना है। PX_LAST आपको अंतिम मूल्य देता है जो आपके संदर्भ डेटा मासिक सीमा की गणना करता है। LAST_PRICE आपको वास्तविक समय की अंतिम कीमत देता है जो आपके वास्तविक समय डेटा मासिक सीमा की गणना करता है।

पुनश्च:। मैं हमारे ब्लूमबर्ग बिक्री प्रतिनिधि से यह जानकारी मिली