Hi @HFTVOL,

We strongly recommend single threaded architecture for the data retrieval part of the code using Eikon .NET SDK. The reason is the .NET assemblies in the SDK for historical reasons have a dependency on a single threaded COM library. This COM library is used by multiple components in Eikon, the .NET SDK is just one of them. The dependency on the COM library is precisely the reason why Windows message pump is required, as I explained to you previously on a different thread.

@HFTVOL

Could you please share the cut-down version of your program with the source code? Therefore, I can use it to replicate and investigate the issue in my environment.

From the snippet code, the application calls PushDispatcherFrame to create create a IDataServices and structure the request. It means that it uses the same _dispatcher thread to call the code.

private void PushDispatcherFrame(Action action)
        {
            _dispatcher.Invoke(() =>
            {
                //execute action
                action();
                //push frame
                _frame = new DispatcherFrame();
                Dispatcher.PushFrame(_frame);
            });
        }

Therefore, it should be thread safe because the code will be called in order by the dispatcher thread (_dispatcher).

Hello @HFTVOL,

If you are a customer, please submit your query to My Account, https://my.thomsonreuters.comand click "RAISE A CASE". Then, an appropriate consultant will contact you and assist you on this issue.

If you are exploring the Eikon.NET API, we are glad to help, as Jirapongse has suggested, please provide a cut-down version of your code which we can use to reproduce the issue on our testbed, and any pertaining information that we would need to reproduce.

With respect,

-AHS

@jirapongse.phuriphanvichai

@zoya.farberov

I launched a query in my Account section. And I am not just "exploring" the API, I am a paying customer and would appreciate if support was a little more forthcoming.

Here is the reproducible code. Please note that the code works fine when running all requests from the same task/thread. As soon as multiple tasks are involved something internally in your API hangs. Goal is to connect/initialize ONCE only, but request many times from potentially different threads.

using System;
using System.Threading.Tasks;
using System.Windows.Threading;
using ThomsonReuters.Desktop.SDK.DataAccess;
using ThomsonReuters.Desktop.SDK.DataAccess.TimeSeries;


namespace ReutersTestCase
{
    class Program
    {
        static void Main(string[] args)
        {
            var testCode = new TestCode();


            //initialize
            testCode.Initialize();


            var task1 = Task.Run(() =>
            {
                testCode.SubmitRequest();
            }).ContinueWith(a =>
            {
                var task2 = Task.Run(() =>
                {
                    testCode.SubmitRequest();
                }).ContinueWith(b =>
                {
                    var task3 = Task.Run(() =>
                    {
                        testCode.SubmitRequest();
                    });
                });


            });


               
            Console.WriteLine("Press enter to exit");
            Console.ReadLine();
        }
    }


    public class TestCode
    {
        private int _iterationId;
        private IDataServices _currentDataService;
        private ITimeSeriesDataService _timeSeriesServices;
        private ITimeSeriesDataRequest _currentRequest;
        private DispatcherFrame _currentFrame;
        private Dispatcher _currentDispatcher;
        private bool _isInitCompleted;
        private bool _isRequestCompleted;
                
        public TestCode()
        {
            _isInitCompleted = false;
            _currentDispatcher = Dispatcher.CurrentDispatcher;
        }            


        public void Initialize()
        {
            _currentFrame = new DispatcherFrame();


            _currentDataService = DataServices.Instance;
            _currentDataService.StateChanged += CurrentDataServiceOnStateChanged;
            _currentDataService.Initialize("TestApp");
            _timeSeriesServices = DataServices.Instance.TimeSeries;
            _timeSeriesServices.ServiceInformationChanged += TimeSeriesServicesOnServiceInformationChanged;


            Dispatcher.PushFrame(_currentFrame);


            //wait hack
            while (_isInitCompleted == false)
            {
                Task.Delay(200).Wait();
            }


            Console.WriteLine("Init completed");
        }


        public void SubmitRequest()
        {
            PushDispatcherFrame(new Action(() =>
            {
                _isRequestCompleted = false;


                _currentFrame = new DispatcherFrame();


                _currentRequest = _timeSeriesServices.SetupDataRequest("EUR=")
                    .WithView("BID")
                    .WithAllFields()
                    .WithInterval(CommonInterval.Daily)
                    .WithNumberOfPoints(10)
                    .OnDataReceived(DataReceivedCallback)
                    .CreateAndSend();


                Dispatcher.PushFrame(_currentFrame);








                //wait hack
                while (_isRequestCompleted == false)
                {
                    Task.Delay(200).Wait();
                }
            }));
        }


        private void CurrentDataServiceOnStateChanged(object sender, DataServicesStateChangedEventArgs dataServicesStateChangedEventArgs)
        {
            ReleaseFrame(false);
            _isInitCompleted = true;
        }


        private void TimeSeriesServicesOnServiceInformationChanged(object sender, ServiceInformationChangedEventArgs serviceInformationChangedEventArgs)
        {
            //do nothing here
        }


        private void DataReceivedCallback(DataChunk chunk)
        {
            foreach (IBarData bar in chunk.Records.ToBarRecords())
            {
                if (bar.Open.HasValue && bar.High.HasValue && bar.Low.HasValue && bar.Close.HasValue && bar.Timestamp.HasValue)
                {
                    Console.WriteLine(
                        "{0}: EUR= OHLC {1} {2} {3} {4}",
                        bar.Timestamp.Value.ToShortDateString(),
                        bar.Open.Value.ToString("##.0000"),
                        bar.High.Value.ToString("##.0000"),
                        bar.Low.Value.ToString("##.0000"),
                        bar.Close.Value.ToString("##.0000")
                    );


                    
                };
            }


            if (!chunk.IsLast)
                return;
            
            ReleaseFrame(false);


            Console.WriteLine();


            _currentRequest = null;
            _isRequestCompleted = true;
        }


        private void PushDispatcherFrame(Action action)
        {
            _currentDispatcher.Invoke(() =>
            {
                //create new frame
                _currentFrame = new DispatcherFrame();


                //execute action
                action();


                //push frame
                Dispatcher.PushFrame(_currentFrame);
            });
        }


        private void ReleaseFrame(bool isContinue)
        {
            _currentDispatcher.Invoke(() =>
            {
                _currentFrame.Continue = isContinue;
            });
        }
    }
}