public void GetNewsDetailAsync(int storyId, Action<NewsDetailDTO> onSuccess, Action<Exception> onError)
        {
            var client = new Client(RPC_URI);
            client.BeginLogIn(USERNAME, PASSWORD,
                ar =>
                {
                    try
                    {
                        client.EndLogIn(ar);

                        client.BeginGetNewsDetail(storyId.ToString(),
                            ar2 =>
                            {
                                try
                                {
                                    var resp = client.EndGetNewsDetail(ar2);

                                    _client.BeginLogOut(ar3 => _client.EndLogOut(ar3), null);

                                    onSuccess(resp.NewsDetail);
                                }
                                catch (Exception exc)
                                {
                                    onError(exc);
                                }
                            }, null);
                    }
                    catch (Exception exc)
                    {
                        onError(exc);
                    }
                }, null);
        }

 public void SetupFixture()
 {
     _rpcClient = BuildRpcClient();
     _streamingClient = _rpcClient.CreateStreamingClient();
     _CFDmarketId = GetAvailableCFDMarkets(_rpcClient)[0].MarketId;
     _accounts = _rpcClient.AccountInformation.GetClientAndTradingAccount();
 }

        private static void DoPolling()
        {
            var client = new Client(Const.RPC_URI, Const.STREAMING_URI, "Test.{B4E415A7-C453-4867-BDD1-C77ED345777B}");
            try
            {
                client.AppKey = "Test";
                client.StartMetrics();

                client.LogIn(Const.USERNAME, Const.PASSWORD);

                for (int i = 0; i < 10; i++)
                {
                    var accountInfo = client.AccountInformation.GetClientAndTradingAccount();
                    client.TradesAndOrders.ListOpenPositions(accountInfo.CFDAccount.TradingAccountId);
                    Thread.Sleep(1000);
                }

                client.LogOut();
            }
            catch (Exception exc)
            {
                Trace.WriteLine(exc);
            }
            finally
            {
                client.Dispose();
            }
        }

        static void Main(string[] args)
        {
            try
            {
                var curProcess = Process.GetCurrentProcess();
                var secondsOnStart = curProcess.TotalProcessorTime.TotalSeconds;
                var totalWatch = Stopwatch.StartNew();

                for (int i = 0; i < 20; i++)
                {
                    var client = new Client(Const.RPC_URI, Const.STREAMING_URI, "");
                    var recorder = new Recorder(client);
                    recorder.Start();

                    var loginWatch = Stopwatch.StartNew();
                    client.LogIn(Const.USERNAME, Const.PASSWORD);
                    loginWatch.Stop();

                    var accountInfoWatch = Stopwatch.StartNew();
                    var accountInfo = client.AccountInformation.GetClientAndTradingAccount();
                    accountInfoWatch.Stop();

                    var listSpreadMarketsWatch = Stopwatch.StartNew();
                    var resp = client.SpreadMarkets.ListSpreadMarkets("", "",
                        accountInfo.ClientAccountId, 100, false);
                    listSpreadMarketsWatch.Stop();

                    var logoutWatch = Stopwatch.StartNew();
                    client.LogOut();
                    logoutWatch.Stop();

                    var purgeHandle = client.ShutDown();
                    if (!purgeHandle.WaitOne(60000))
                        throw new ApplicationException();

                    var requests = recorder.GetRequests();
                    if (requests.Count != 4)
                        throw new ApplicationException();

                    AddResult(loginWatch, requests[0], "Login");
                    AddResult(accountInfoWatch, requests[1], "GetClientAndTradingAccount");
                    AddResult(listSpreadMarketsWatch, requests[2], "ListSpreadMarkets");
                    AddResult(logoutWatch, requests[3], "Logout");

                    recorder.Stop();
                    recorder.Dispose();
                    client.Dispose();
                }

                totalWatch.Stop();
                var secondsOnEnd = curProcess.TotalProcessorTime.TotalSeconds;
                Console.WriteLine("CPU time used, seconds: {0} total time: {1}", secondsOnEnd - secondsOnStart, totalWatch.Elapsed.TotalSeconds);
            }
            catch (Exception exc)
            {
                Console.WriteLine(exc);
            }

            Debugger.Break();
        }

        public void CanChangePassword()
        {
            const string NEWPASSWORD = "bingo72652";
            var rpcClient = new Client(Settings.RpcUri,Settings.StreamingUri, AppKey);
            
            //Login with existing credentials
            rpcClient.LogIn(Settings.RpcUserName, Settings.RpcPassword);

            //And change password
            var changePasswordResponse = rpcClient.Authentication.ChangePassword(new ApiChangePasswordRequestDTO()
                                                                                         {
                                                                                             UserName = Settings.RpcUserName,
                                                                                             Password = Settings.RpcPassword,
                                                                                             NewPassword = NEWPASSWORD
                                                                                         });

            Assert.IsTrue(changePasswordResponse.IsPasswordChanged);
            rpcClient.LogOut();

            //Make sure that login existing password fails 
            Assert.Throws<ReliableHttpException>(() => rpcClient.LogIn(Settings.RpcUserName, Settings.RpcUserName));

            //Login with changed password and change back
            rpcClient.LogIn(Settings.RpcUserName, NEWPASSWORD);
            changePasswordResponse = rpcClient.Authentication.ChangePassword(new ApiChangePasswordRequestDTO()
                                                                                         {
                                                                                             UserName = Settings.RpcUserName,
                                                                                             Password = NEWPASSWORD,
                                                                                             NewPassword = Settings.RpcPassword
                                                                                         });

            Assert.IsTrue(changePasswordResponse.IsPasswordChanged);
            rpcClient.LogOut();
            rpcClient.Dispose();
        }

        public void CanMockCiapiServerConversation()
        {
            Uri uri = new Uri(NormalizeUrl("/"));
            var rpcClient = new Client(uri, uri, "foobardotnet");

            rpcClient.LogIn("Foo", "Bar");

            Assert.AreEqual("5f28983b-0e0a-4a57-92af-0d07c6fdbc38", rpcClient.Session);

            // get some headlines
            var headlines = rpcClient.News.ListNewsHeadlinesWithSource("dj", "UK", 100);
            Assert.AreEqual(100, headlines.Headlines.Length);

            // get a story id from one of the headlines
            var storyId = headlines.Headlines[0].StoryId;
            Assert.AreEqual(1416482, storyId);

            var storyDetail = rpcClient.News.GetNewsDetail("dj", storyId.ToString());

            Assert.IsTrue(storyDetail.NewsDetail.Story.Contains("By Anita Greil "));

            rpcClient.LogOut();

            rpcClient.Dispose();
        }

        public void RecordNewDataForCIAPI()
        {
            var rpcClient = new Client(new Uri("https://ciapi.cityindex.com/tradingapi"), new Uri("https://push.cityindex.com"), "foobardotnet");

            // start recording requests
            var stream = new MemoryStream();
            var streamRecorder = new StreamRecorder(rpcClient, stream);
            streamRecorder.Start();

            rpcClient.LogIn("secret", "secret");

            var accountInfo = rpcClient.AccountInformation.GetClientAndTradingAccount();
            rpcClient.SpreadMarkets.ListSpreadMarkets("", "", accountInfo.ClientAccountId, 100, false);
            rpcClient.News.ListNewsHeadlinesWithSource("dj", "UK", 10);
            rpcClient.Market.GetMarketInformation(MarketId.ToString());
            rpcClient.PriceHistory.GetPriceBars(MarketId.ToString(), "MINUTE", 1, "20");
            rpcClient.TradesAndOrders.ListOpenPositions(accountInfo.SpreadBettingAccount.TradingAccountId);

            rpcClient.LogOut();

            streamRecorder.Stop();
            stream.Position = 0;

            using (var fileStream = File.Create("recorded_requests.txt"))
            {
                stream.WriteTo(fileStream);
            }
        }

        public Client(Uri rpcUri, Uri streamingUri, string appKey,IJsonSerializer serializer, IRequestFactory factory)
            : base(serializer, factory)
        {
	#if SILVERLIGHT
	#if WINDOWS_PHONE
	        UserAgent = "CIAPI.PHONE7."+ GetVersionNumber();
	#else
	        UserAgent = "CIAPI.SILVERLIGHT."+ GetVersionNumber();
	#endif
	#else
	        UserAgent = "CIAPI.CS." + GetVersionNumber();
	#endif
        AppKey=appKey;
        _client=this;
        _rootUri = rpcUri;
        _streamingUri = streamingUri;

            this. Authentication = new _Authentication(this);
            this. PriceHistory = new _PriceHistory(this);
            this. News = new _News(this);
            this. CFDMarkets = new _CFDMarkets(this);
            this. SpreadMarkets = new _SpreadMarkets(this);
            this. Market = new _Market(this);
            this. Preference = new _Preference(this);
            this. TradesAndOrders = new _TradesAndOrders(this);
            this. AccountInformation = new _AccountInformation(this);
            this. Messaging = new _Messaging(this);
            this. Watchlist = new _Watchlist(this);
            this. ClientApplication = new _ClientApplication(this);
            this. ExceptionHandling = new _ExceptionHandling(this);
        Log.Debug("Rpc.Client created for " + _rootUri.AbsoluteUri);
        }

        public void CanSendMetrics()
        {

            // set up a listener
            var log = new StringBuilder();
            var writer = new StringWriter(log);
            var listener = new TextWriterTraceListener(writer);
            Trace.Listeners.Add(listener);

            var rpcClient = new Client(Settings.RpcUri, Settings.StreamingUri, "my-test-appkey");
            var metricsRecorder = new MetricsRecorder(rpcClient, new Uri("http://metrics.labs.cityindex.com/LogEvent.ashx"));
            metricsRecorder.Start();

            rpcClient.LogIn(Settings.RpcUserName, Settings.RpcPassword);

            var headlines = rpcClient.News.ListNewsHeadlinesWithSource("dj", "UK", 100);

            foreach (var item in headlines.Headlines)
            {
                rpcClient.News.GetNewsDetail("dj", item.StoryId.ToString());
            }

            new AutoResetEvent(false).WaitOne(10000);

            rpcClient.LogOut();

            metricsRecorder.Stop();
            rpcClient.Dispose();

            Trace.Listeners.Remove(listener);

            var logText = log.ToString();

            Assert.IsTrue(logText.Contains("Latency message complete"), "did not find evidence of metrics being posted");
        }

        public Client(Uri rpcUri, Uri streamingUri, string appKey, int backgroundInterval)
            : base(new Serializer(),backgroundInterval)
        {
	#if SILVERLIGHT
	#if WINDOWS_PHONE
	        UserAgent = "CIAPI.PHONE7."+ GetVersionNumber();
	#else
	        UserAgent = "CIAPI.SILVERLIGHT."+ GetVersionNumber();
	#endif
	#else
	        UserAgent = "CIAPI.CS." + GetVersionNumber();
	#endif
        _streamingFactory=new LightStreamerStreamingClientFactory();
        AppKey=appKey;
        _client=this;
        _rootUri = rpcUri;
        _streamingUri = streamingUri;

            this. Authentication = new _Authentication(this);
            this. PriceHistory = new _PriceHistory(this);
            this. News = new _News(this);
            this. CFDMarkets = new _CFDMarkets(this);
            this. SpreadMarkets = new _SpreadMarkets(this);
            this. Market = new _Market(this);
            this. Preference = new _Preference(this);
            this. TradesAndOrders = new _TradesAndOrders(this);
            this. AccountInformation = new _AccountInformation(this);
            this. Messaging = new _Messaging(this);
            this. Watchlist = new _Watchlist(this);
            this. ClientApplication = new _ClientApplication(this);
        Log.Debug("Rpc.Client created for " + _rootUri.AbsoluteUri);
        }

 public Client BuildRpcClient()
 {
     //Thread.Sleep(2000); // to let throttle settle down
     var rpcClient = new Client(Settings.RpcUri, Settings.StreamingUri, AppKey);
     rpcClient.LogIn(Settings.RpcUserName, Settings.RpcPassword);
     return rpcClient;
 }

        public void Issue42()
        {

            var rpcClient = new Client(Settings.RpcUri);
            rpcClient.LogIn(Settings.RpcUserName, Settings.RpcPassword);
            var param = new NewStopLimitOrderRequestDTO
                            {
                                OrderId = 0,
                                MarketId = 99498,
                                Currency = null,
                                AutoRollover = false,
                                Direction = "buy",
                                Quantity = 10m,
                                BidPrice = 12094m,
                                OfferPrice = 12098m,
                                AuditId = "20110629-G2PREPROD3-0102794",
                                TradingAccountId = 400002249,
                                IfDone = null,
                                OcoOrder = null,
                                Applicability = null,
                                ExpiryDateTimeUTC = null,
                                Guaranteed = false,
                                TriggerPrice = 0m
                            };
            var response = rpcClient.TradesAndOrders.Order(param);


            rpcClient.LogOut();
        }

        protected Client BuildUnauthenticatedRpcClient()
        {
            // WARNING: do not nest or otherwise refactor this method
            // buildUri is looking back 2 stack frames to get the method that called this

            var rpcClient = new Client(BuildUri(), new Uri(_streamingUrl), _apiKey);
            return rpcClient;
        }

 private void AutoLogin()
 {
     if (_ctx == null)
     {
         _ctx = new CIAPI.Rpc.Client(RPC_URI);
         _ctx.LogIn(USERNAME, PASSWORD);
     }
 }

 private static int GetTradingAccountId(Client client, int marketId, AccountInformationResponseDTO accountInfo)
 {
     GetMarketInformationResponseDTO marketInfo = client.Market.GetMarketInformation(marketId.ToString());
     bool isCfd = marketInfo.MarketInformation.Name.EndsWith("CFD");
     ApiTradingAccountDTO tradingAccount = isCfd
                                               ? accountInfo.TradingAccounts[0]
                                               : accountInfo.TradingAccounts[1];
     return tradingAccount.TradingAccountId;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="client"></param>
 /// <param name="appmetricsUri"></param>
 /// <param name="metricsSession"></param>
 /// <param name="metricsAccessKey"></param>
 public MetricsRecorder(Client client, Uri appmetricsUri, string metricsSession, string metricsAccessKey = null)
     : base(client)
 {
     _metricsSession = metricsSession;
     _metricsAccessKey = metricsAccessKey;
     AppmetricsUri = appmetricsUri;
     
     _metricsTimer = new Timer(ignored => PostMetrics(), null, 1000, 10000);
 }

 public override void FixtureSetup()
 {
     base.FixtureSetup();
     // hmmmm... only one fixture setup allowed. 
     _rpcClient = BuildRpcClient();
     _streamingClient = _rpcClient.CreateStreamingClient();
     _CFDmarketId = MarketFixture.GetAvailableCFDMarkets(_rpcClient)[0].MarketId;
     _accounts = _rpcClient.AccountInformation.GetClientAndTradingAccount();
 }

        public MainPage()
        {
            InitializeComponent();

            Dispatcher.BeginInvoke(() =>
            {
                StartButton.IsEnabled = false;
                StopButton.IsEnabled = false;
            });


            // build an rpc client and log it in.
            rpcClient = new Client(new Uri(RpcServerHost));

            // get a session from the rpc client
            rpcClient.BeginLogIn(UserName, Password, ar =>
                {
                    rpcClient.EndLogIn(ar);

                    Debug.WriteLine("creating client");

                    // build a streaming client.
                    _streamingClient = StreamingClientFactory.CreateStreamingClient(new Uri(PushServerHost), UserName, rpcClient.Session);

                    Debug.WriteLine("connecting client");

                    // note: due to internal changes the 'connect' method
                    // name is a misnomer: no actual network activity is occuring,
                    // only the building of the necessary client connections for 
                    // each of the published data adapters. Actual connection is 
                    // performed on demand for each adapter. This minimizes startup time.

                    // the upside to this is that there is no need to run .Connect in a separate thread.



                    Debug.WriteLine("client connected");


                    // from this point there should be no need to stop, disconnect or dispose of the 
                    // client instance. But if you choose to disconnect a StreamingClient, it should
                    // be disposed and reinstantiated. it is a one use object at this point as this is 
                    // the only usage pattern presented in the sample code.

                    Dispatcher.BeginInvoke(() =>
                        {
                            listBox1.Items.Add("logged in");


                            StartButton.IsEnabled = true;
                            StopButton.IsEnabled = false;
                        });

                }, null);

        }

        public void AppKeyIsAppendedToLogonRequest()
        {
            // look at the log to verify - need to expose interals and provide a means to examine the cache to verify programmatically

            var rpcClient = new Client(Settings.RpcUri, Settings.StreamingUri, "my-test-appkey");
            rpcClient.LogIn(Settings.RpcUserName, Settings.RpcPassword);

            rpcClient.LogOut();
            rpcClient.Dispose();
        }

		public static void Connect() 
		{
			Console.WriteLine ("Connecting to CIAPI");
			_rpcClient = new Client(
				new Uri(ConfigurationManager.AppSettings["Server"]), 
				new Uri(ConfigurationManager.AppSettings["StreamingServer"]), 
				ConfigurationManager.AppSettings["ApiKey"] );
			_rpcClient.LogIn(ConfigurationManager.AppSettings["UserName"], ConfigurationManager.AppSettings["Password"]);
			_streamingClient = _rpcClient.CreateStreamingClient();
		}