Async ExchangeAPI init

examples/ExchangeSharpWinForms/MainForm.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Text;
 using System.Windows.Forms;
 using ExchangeSharp;
@@ -28,7 +28,7 @@ private async void FetchTickers()
             this.UseWaitCursor = true;
             try
             {
-                var api = ExchangeAPI.GetExchangeAPI(cmbExchange.SelectedItem as string);
+                var api = await ExchangeAPI.GetExchangeAPIAsync(cmbExchange.SelectedItem as string);
                 var tickers = await api.GetTickersAsync();
                 StringBuilder b = new StringBuilder();
                 foreach (var ticker in tickers)
@@ -52,10 +52,10 @@ public MainForm()
             InitializeComponent();
         }
 
-        protected override void OnShown(EventArgs e)
+        protected override async void OnShown(EventArgs e)
         {
             base.OnShown(e);
-            foreach (var exchange in ExchangeAPI.GetExchangeAPIs())
+			foreach (var exchange in await ExchangeAPI.GetExchangeAPIsAsync())
             {
                 cmbExchange.Items.Add(exchange.Name);
             }

src/ExchangeSharp/API/Exchanges/_Base/ExchangeAPI.cs

@@ -45,12 +45,13 @@ public abstract partial class ExchangeAPI : BaseAPI, IExchangeAPI
 		#region Private methods
 
 		private static readonly IReadOnlyCollection<Type> exchangeTypes = typeof(ExchangeAPI).Assembly.GetTypes().Where(type => type.IsSubclassOf(typeof(ExchangeAPI)) && !type.IsAbstract).ToArray();
-		private static readonly ConcurrentDictionary<Type, IExchangeAPI> apis = new ConcurrentDictionary<Type, IExchangeAPI>();
+		private static readonly ConcurrentDictionary<Type, Task<IExchangeAPI>> apis = new ConcurrentDictionary<Type, Task<IExchangeAPI>>();
+		private static readonly SemaphoreSlim semaphore = new SemaphoreSlim(1);
 
 		private bool initialized;
 		private bool disposed;
 
-		private static IExchangeAPI InitializeAPI(Type? type, Type? knownType = null)
+		private static async Task<IExchangeAPI> InitializeAPIAsync(Type? type, Type? knownType = null)
 		{
 			if (type is null)
 			{
@@ -64,30 +65,23 @@ private static IExchangeAPI InitializeAPI(Type? type, Type? knownType = null)
 			}
 
 			const int retryCount = 3;
-			Exception? ex = null;
-
+
 			// try up to 3 times to init
-			for (int i = 1; i <= 3; i++)
+			for (int i = 1; i <= retryCount; i++)
 			{
 				try
 				{
-					api.InitializeAsync().Sync();
-					ex = null;
-					break;
+					await api.InitializeAsync();
 				}
-				catch (Exception _ex)
+				catch (Exception)
 				{
-					ex = _ex;
-					if (i != retryCount)
+					if (i == retryCount)
 					{
-						Thread.Sleep(5000);
+						throw;
 					}
-				}
-			}
 
-			if (ex != null)
-			{
-				throw ex;
+					Thread.Sleep(5000);
+				}
 			}
 
 			return api;
@@ -365,7 +359,7 @@ public void Dispose()
 				Cache?.Dispose();
 
 				// take out of global api dictionary if disposed and we are the current exchange in the dictionary
-				if (apis.TryGetValue(GetType(), out IExchangeAPI existing) && this == existing)
+				if (apis.TryGetValue(GetType(), out Task<IExchangeAPI> existing) && this == existing.Result)
 				{
 					apis.TryRemove(GetType(), out _);
 				}
@@ -386,9 +380,17 @@ private async Task InitializeAsync()
 			initialized = true;
 		}
 
-		private static IExchangeAPI CreateExchangeAPI(Type? type)
+		/// <summary>
+		/// Create an exchange api, by-passing any cache. Use this method for cases
+		/// where you need multiple instances of the same exchange, for example
+		/// multiple credentials.
+		/// </summary>
+		/// <typeparam name="T">Type of exchange api to create</typeparam>
+		/// <returns>Created exchange api</returns>
+		[Obsolete("Use the async version")]
+		public static T CreateExchangeAPI<T>() where T : ExchangeAPI
 		{
-			return InitializeAPI(type);
+			return CreateExchangeAPIAsync<T>().Result;
 		}
 
 		/// <summary>
@@ -398,75 +400,117 @@ private static IExchangeAPI CreateExchangeAPI(Type? type)
 		/// </summary>
 		/// <typeparam name="T">Type of exchange api to create</typeparam>
 		/// <returns>Created exchange api</returns>
-		public static T CreateExchangeAPI<T>() where T : ExchangeAPI
+		public static async Task<T> CreateExchangeAPIAsync<T>() where T : ExchangeAPI
 		{
-			return (T)CreateExchangeAPI(typeof(T));
+			return (T)await InitializeAPIAsync(typeof(T));
 		}
 
 		/// <summary>
 		/// Get a cached exchange API given an exchange name (see ExchangeName class)
 		/// </summary>
 		/// <param name="exchangeName">Exchange name. Must match the casing of the ExchangeName class name exactly.</param>
 		/// <returns>Exchange API or null if not found</returns>
+		[Obsolete("Use the async version")]
 		public static IExchangeAPI GetExchangeAPI(string exchangeName)
+		{
+			return GetExchangeAPIAsync(exchangeName).Result;
+		}
+
+		/// <summary>
+		/// Get a cached exchange API given an exchange name (see ExchangeName class)
+		/// </summary>
+		/// <param name="exchangeName">Exchange name. Must match the casing of the ExchangeName class name exactly.</param>
+		/// <returns>Exchange API or null if not found</returns>
+		public static Task<IExchangeAPI> GetExchangeAPIAsync(string exchangeName)
 		{
 			Type type = ExchangeName.GetExchangeType(exchangeName);
-			return GetExchangeAPI(type);
+			return GetExchangeAPIAsync(type);
 		}
 
 		/// <summary>
 		/// Get a cached exchange API given a type
 		/// </summary>
 		/// <typeparam name="T">Type of exchange to get</typeparam>
 		/// <returns>Exchange API or null if not found</returns>
+		[Obsolete("Use the async version")]
 		public static IExchangeAPI GetExchangeAPI<T>() where T : ExchangeAPI
+		{
+			return GetExchangeAPIAsync<T>().Result;
+		}
+
+		public static Task<IExchangeAPI> GetExchangeAPIAsync<T>() where T : ExchangeAPI
 		{
 			// note: this method will be slightly slow (milliseconds) the first time it is called due to cache miss and initialization
 			// subsequent calls with cache hits will be nanoseconds
 			Type type = typeof(T)!;
-			return GetExchangeAPI(type);
+			return GetExchangeAPIAsync(type);
 		}
 
 		/// <summary>
 		/// Get a cached exchange API given a type
 		/// </summary>
 		/// <param name="type">Type of exchange</param>
 		/// <returns>Exchange API or null if not found</returns>
+		[Obsolete("Use the async version")]
 		public static IExchangeAPI GetExchangeAPI(Type type)
 		{
-			// note: this method will be slightly slow (milliseconds) the first time it is called due to cache miss and initialization
-			// subsequent calls with cache hits will be nanoseconds
-			return apis.GetOrAdd(type, _exchangeName =>
+			return GetExchangeAPIAsync(type).Result;
+		}
+
+		/// <summary>
+		/// Get a cached exchange API given a type
+		/// </summary>
+		/// <param name="type">Type of exchange</param>
+		/// <returns>Exchange API or null if not found</returns>
+		public static async Task<IExchangeAPI> GetExchangeAPIAsync(Type type)
+		{
+			if (apis.TryGetValue(type, out var result)) return await result;
+
+			await semaphore.WaitAsync();
+			try
 			{
-				// find the api type
-				Type? foundType = exchangeTypes.FirstOrDefault(t => t == type);
-				return InitializeAPI(foundType, type);
-			});
+				// try again inside semaphore
+				if (apis.TryGetValue(type, out result)) return await result;
+
+				// still not found, initialize it
+				var foundType = exchangeTypes.FirstOrDefault(t => t == type);
+			    return await (apis[type] = InitializeAPIAsync(foundType, type));
+			}
+			finally
+			{
+				semaphore.Release();
+			}
 		}
 
 		/// <summary>
 		/// Get all cached versions of exchange APIs
 		/// </summary>
 		/// <returns>All APIs</returns>
+		[Obsolete("Use the async version")]
 		public static IExchangeAPI[] GetExchangeAPIs()
 		{
-			foreach (Type type in exchangeTypes)
+			return GetExchangeAPIsAsync().Result;
+		}
+
+		/// <summary>
+		/// Get all cached versions of exchange APIs
+		/// </summary>
+		/// <returns>All APIs</returns>
+		public static async Task<IExchangeAPI[]> GetExchangeAPIsAsync()
+		{
+			var apiList = new List<IExchangeAPI>();
+			foreach (var kv in apis.ToArray())
 			{
-				List<IExchangeAPI> apiList = new List<IExchangeAPI>();
-				foreach (var kv in apis.ToArray())
+				if (kv.Value == null)
 				{
-					if (kv.Value == null)
-					{
-						apiList.Add(GetExchangeAPI(kv.Key));
-					}
-					else
-					{
-						apiList.Add(kv.Value);
-					}
+					apiList.Add(await GetExchangeAPIAsync(kv.Key));
+				}
+				else
+				{
+					apiList.Add(await kv.Value);
 				}
-				return apiList.ToArray();
 			}
-			return apis.Values.ToArray();
+			return apiList.ToArray();
 		}
 
 		/// <summary>

src/ExchangeSharp/API/Exchanges/_Base/ExchangeLogger.cs

@@ -195,15 +195,29 @@ public static BinaryReader OpenLogReader(string basePath)
             return new BinaryReader(new System.IO.Compression.GZipStream(File.OpenRead(basePath + ".gz"), System.IO.Compression.CompressionMode.Decompress, false));
         }
 
+		/// <summary>
+		/// Begins logging exchanges - writes errors to console. You should block the app using Console.ReadLine.
+		/// </summary>
+		/// <param name="path">Path to write files to</param>
+		/// <param name="intervalSeconds">Interval in seconds in between each log calls for each exchange</param>
+		/// <param name="terminateAction">Call this when the process is about to exit, like a WM_CLOSE message on Windows.</param>
+		/// <param name="compress">Whether to compress the log files</param>
+		/// <param name="exchangeNamesAndSymbols">Exchange names and symbols to log</param>
+		[Obsolete("Use the async version")]
+        public static void LogExchanges(string path, float intervalSeconds, out Action terminateAction, bool compress, params string[] exchangeNamesAndSymbols)
+		{
+			terminateAction = LogExchangesAsync(path, intervalSeconds, compress, exchangeNamesAndSymbols).Result;
+		}
+
         /// <summary>
         /// Begins logging exchanges - writes errors to console. You should block the app using Console.ReadLine.
         /// </summary>
         /// <param name="path">Path to write files to</param>
         /// <param name="intervalSeconds">Interval in seconds in between each log calls for each exchange</param>
-        /// <param name="terminateAction">Call this when the process is about to exit, like a WM_CLOSE message on Windows.</param>
         /// <param name="compress">Whether to compress the log files</param>
         /// <param name="exchangeNamesAndSymbols">Exchange names and symbols to log</param>
-        public static void LogExchanges(string path, float intervalSeconds, out Action terminateAction, bool compress, params string[] exchangeNamesAndSymbols)
+        /// <returns">Call this when the process is about to exit, like a WM_CLOSE message on Windows.</returns>
+        public static async Task<Action> LogExchangesAsync(string path, float intervalSeconds, bool compress, params string[] exchangeNamesAndSymbols)
         {
             bool terminating = false;
             Action terminator = null;
@@ -212,7 +226,7 @@ public static void LogExchanges(string path, float intervalSeconds, out Action t
             List<ExchangeLogger> loggers = new List<ExchangeLogger>();
             for (int i = 0; i < exchangeNamesAndSymbols.Length;)
             {
-                loggers.Add(new ExchangeLogger(ExchangeAPI.GetExchangeAPI(exchangeNamesAndSymbols[i++]), exchangeNamesAndSymbols[i++], intervalSeconds, path, compress));
+                loggers.Add(new ExchangeLogger(await ExchangeAPI.GetExchangeAPIAsync(exchangeNamesAndSymbols[i++]), exchangeNamesAndSymbols[i++], intervalSeconds, path, compress));
             };
             foreach (ExchangeLogger logger in loggers)
             {
@@ -244,7 +258,6 @@ public static void LogExchanges(string path, float intervalSeconds, out Action t
                     loggers.Clear();
                 }
             };
-            terminateAction = terminator;
 
             // make sure to close properly
             Console.CancelKeyPress += delegate (object sender, ConsoleCancelEventArgs e)
@@ -256,6 +269,8 @@ public static void LogExchanges(string path, float intervalSeconds, out Action t
                 terminator();
             };
             Logger.Info("Loggers \"{0}\" started, press ENTER or CTRL-C to terminate.", string.Join(", ", loggers.Select(l => l.API.Name)));
+
+            return terminator;
         }
 
         /// <summary>

src/ExchangeSharpConsole/ExchangeSharpConsole.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>

src/ExchangeSharpConsole/Options/BaseOption.cs

@@ -117,14 +117,14 @@ protected void WaitInteractively()
 			Console.CursorLeft = 0;
 		}
 
-		protected IExchangeAPI GetExchangeInstance(string exchangeName)
+		protected Task<IExchangeAPI> GetExchangeInstanceAsync(string exchangeName)
 		{
-			return ExchangeAPI.GetExchangeAPI(exchangeName);
+			return ExchangeAPI.GetExchangeAPIAsync(exchangeName);
 		}
 
 		protected async Task RunWebSocket(string exchangeName, Func<IExchangeAPI, Task<IWebSocket>> getWebSocket)
 		{
-			using var api = ExchangeAPI.GetExchangeAPI(exchangeName);
+			using var api = await ExchangeAPI.GetExchangeAPIAsync(exchangeName);
 
 			Console.WriteLine("Connecting web socket to {0}...", api.Name);
 

src/ExchangeSharpConsole/Options/BuyOption.cs

@@ -20,7 +20,7 @@ public override async Task RunCommand()
 
 		protected async Task AddOrder(bool isBuyOrder)
 		{
-			using var api = GetExchangeInstance(ExchangeName);
+			using var api = await GetExchangeInstanceAsync(ExchangeName);
 
 			var exchangeOrderRequest = GetExchangeOrderRequest(isBuyOrder, api);
 

src/ExchangeSharpConsole/Options/CancelOrderOption.cs

@@ -11,7 +11,7 @@ public class CancelOrderOption : BaseOption,
 	{
 		public override async Task RunCommand()
 		{
-			using var api = GetExchangeInstance(ExchangeName);
+			using var api = await GetExchangeInstanceAsync(ExchangeName);
 
 			api.LoadAPIKeys(KeyPath);
 

src/ExchangeSharpConsole/Options/CandlesOption.cs

@@ -11,7 +11,7 @@ public class CandlesOption : BaseOption, IOptionPerExchange, IOptionPerMarketSym
 	{
 		public override async Task RunCommand()
 		{
-			using var api = GetExchangeInstance(ExchangeName);
+			using var api = await GetExchangeInstanceAsync(ExchangeName);
 
 			var candles = await api.GetCandlesAsync(
 				MarketSymbol,

src/ExchangeSharpConsole/Options/CurrenciesOption.cs

@@ -13,7 +13,7 @@ public class CurrenciesOption : BaseOption, IOptionPerExchange
 
 		public override async Task RunCommand()
 		{
-			using var api = GetExchangeInstance(ExchangeName);
+			using var api = await GetExchangeInstanceAsync(ExchangeName);
 
 			Authenticate(api);
 

src/ExchangeSharpConsole/Options/DepositAddressOption.cs

@@ -14,7 +14,7 @@ public class DepositAddressOption : BaseOption, IOptionPerExchange, IOptionWithC
 
 		public override async Task RunCommand()
 		{
-			using var api = GetExchangeInstance(ExchangeName);
+			using var api = await GetExchangeInstanceAsync(ExchangeName);
 
 			Authenticate(api);
 

src/ExchangeSharpConsole/Options/ExampleOption.cs

@@ -12,7 +12,7 @@ public class ExampleOption : BaseOption, IOptionWithKey
 	{
 		public override async Task RunCommand()
 		{
-			using var api = ExchangeAPI.GetExchangeAPI(ExchangeName.Kraken);
+			using var api = await ExchangeAPI.GetExchangeAPIAsync(ExchangeName.Kraken);
 			var ticker = await api.GetTickerAsync("XXBTZUSD");
 
 			Console.WriteLine("On the Kraken exchange, 1 bitcoin is worth {0} USD.", ticker.Bid);