I have modified the code to use in the console application. From my test, the application can run properly. Please the attached code and output file.

output.txt, programcs.txt

The part where it gets hung up is on a subsequent request (as below). The software is called RightEdge (rightedgesystems.com). Let me know if there's something else I can provide, and thank you in advance!

        public void Launch(string symbol)
        {
            request = timeSeries.SetupDataRequest(symbol)
            .WithView("BID")
            .WithAllFields()
            .WithInterval(CommonInterval.Daily)
            .WithNumberOfPoints(10)
            .OnDataReceived(DataReceivedCallback)
            .CreateAndSend();
        }
        public 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)
                {
                    Common.BarData reBar = new Common.BarData();
                    reBar.BarStartTime = bar.Timestamp.Value;
                    reBar.Open = bar.Open.Value;
                    reBar.High = bar.High.Value;
                    reBar.Low = bar.Low.Value;
                    reBar.Close = bar.Close.Value;
                    if (bar.Volume.HasValue)
                    {
                        reBar.Volume = Convert.ToUInt64(bar.Volume.Value);
                    }
                    ReutersRetrieval.bars.Add(reBar);
                }
            }
            if (!chunk.IsLast) return;
            request = null;
            ReutersRetrieval.StopMessagePump();
        }

To completely clarify- here is the entire code that is relevant.

When I first click the button in the app to retrieve data, this is called:

                InitReuters.InitializeDataServices("RightEdge");

Here is the entire InitReuters class:

    public class InitReuters
    {
        public static IDataServices Services { get; set; }

        public static void InitializeDataServices(string appName)
        {
            Services = DataServices.Instance;
            Services.StateChanged += ServicesOnStateChanged;

            Services.Initialize(appName);
            InitializeTimeSeries();
        }

        private static void ServicesOnStateChanged(object sender, DataServicesStateChangedEventArgs dataServicesStateChangedEventArgs)
        {
            //
        }

        public static ITimeSeriesDataService timeSeries;

        private static void InitializeTimeSeries()
        {
            timeSeries = DataServices.Instance.TimeSeries;
            timeSeries.ServiceInformationChanged += timeSeries_ServiceInformationChanged;
        }

        private static void timeSeries_ServiceInformationChanged(object sender, ServiceInformationChangedEventArgs e)
        {
            Debug.Print("{0}: {1}", e.Information.State, e.Information.Message);
        }
    }

Then the code will run through the actual retrieval portion, which is the RetrieveData method below:

        public static DispatcherFrame Frame;

        public static void StopMessagePump()
        {
            Frame.Continue = false;
        }

        public static List<Common.BarData> bars;

        public List<Common.BarData> RetrieveData(Symbol symbol, int frequency, DateTime startDate, DateTime endDate, BarConstructionType barConstruction)
        {
            if (frequency != (int)BarFrequency.Daily)
            {
                return new List<Common.BarData>();
            }

            if (startDate == DateTime.MinValue)
            {
                startDate = new DateTime(1900, 1, 2);
            }

            if (endDate == DateTime.MaxValue)
            {
                endDate = DateTime.Now;
            }

            string RIC = symbol.SymbolInformation.CustomHistoricalData;

            bars = new List<Common.BarData>();

            Frame = new DispatcherFrame();
            (new TSRequest(InitReuters.timeSeries)).Launch(RIC, startDate);
            Dispatcher.PushFrame(Frame);
            Frame = null;
            return bars;
        }

.. and here is the TSRequest class that contains the actual code for requesting the data:

    public class TSRequest
    {
        public ITimeSeriesDataService timeSeries;
        public static ITimeSeriesDataRequest request;

        public TSRequest(ITimeSeriesDataService timeSeries)
        {
            this.timeSeries = timeSeries;
        }

        public void Launch(string RIC, DateTime startDate)
        {
            request = timeSeries.SetupDataRequest(RIC)
            .WithView("BID")
            .WithAllFields()
            .WithInterval(CommonInterval.Daily)
            .From(startDate)
            .OnDataReceived(DataReceivedCallback)
            .CreateAndSend();
        }

        public 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)
                {
                    Common.BarData reBar = new Common.BarData();
                    reBar.BarStartTime = bar.Timestamp.Value;
                    reBar.Open = bar.Open.Value;
                    reBar.High = bar.High.Value;
                    reBar.Low = bar.Low.Value;
                    reBar.Close = bar.Close.Value;
                    if (bar.Volume.HasValue)
                    {
                        reBar.Volume = Convert.ToUInt64(bar.Volume.Value);
                    }
                    ReutersRetrieval.bars.Add(reBar);
                }
            }
            if (!chunk.IsLast) return;

            request = null;
            ReutersRetrieval.StopMessagePump();
        }
    }