Allow creating new instance of exchange (#613)

* Allow creating new instance of exchange

* Remove test code

* Remove redundant try/catch

* Discard operator

* Cleanup

* Remove redundant check

* Pattern matching

Author: jjxtra

Diff for: CONTRIBUTING.md

@@ -20,7 +20,7 @@ Please follow these coding guidelines...
 
 When creating a new Exchange API, please do the following:
 - For reference comparisons, https://github.com/ccxt/ccxt is a good project to compare against when creating a new exchange. Use node.js in Visual Studio to debug through the code.
-- See ```ExchangeAPIDefinitions.cs``` for all possible methods that can be overriden to make an exchange, along with adding the name to the ExchangeName class. Great starting point to copy/paste as your new Exchange...API.cs file.
+- See ```ExchangeAPIDefinitions.cs``` for all possible methods that can be overriden to make an exchange, along with adding the name to the ExchangeName class. Great starting point to copy/paste as your new Exchange...API.cs file. The constant in ExchangeName should match the casing of the exchange name in the Exchange[Name]API class.
 - Put the exchange API class is in it's own folder (/API/Exchanges). If you are creating model objects or helper classes for an exchange, make internal classes inside a namespace for your exchange and put them in the sub-folder for the exchange. Binance and Bittrex are good examples.
 - Please use ```CryptoUtility, BaseAPIExtensions and ExchangeAPIExtensions``` for common code / parsing before rolling your own parsing code.
 - Ensure that the unit tests and integrations tests (```ExchangeSharpConsole.exe test exchangeName=[name]```) pass before submitting a pull request.

Diff for: src/ExchangeSharp/API/Exchanges/KuCoin/ExchangeKuCoinAPI.cs

@@ -728,5 +728,5 @@ private string GetWebsocketBulletToken()
         #endregion Private Functions
     }
 
-    public partial class ExchangeName { public const string Kucoin = "Kucoin"; }
+    public partial class ExchangeName { public const string Kucoin = "KuCoin"; }
 }

Diff for: src/ExchangeSharp/API/Exchanges/_Base/ExchangeAPI.cs

@@ -343,40 +343,81 @@ private async Task InitializeAsync()
 			initialized = true;
 		}
 
-		/// <summary>
-		/// Get an exchange API given an exchange name (see ExchangeName class)
-		/// </summary>
-		/// <param name="exchangeName">Exchange name</param>
-		/// <returns>Exchange API or null if not found</returns>
-		public static IExchangeAPI GetExchangeAPI(string exchangeName)
+		private static IExchangeAPI CreateExchangeAPI(Type? type)
 		{
-			// find the exchange with the name and creat it
-			foreach (Type type in exchangeTypes)
+			if (type is null)
+			{
+				throw new ArgumentNullException("No type found for exchange");
+			}
+
+			if (!(Activator.CreateInstance(type, true) is ExchangeAPI api))
+			{
+				throw new ArgumentException($"Invalid type {type.FullName}, not a {nameof(ExchangeAPI)} type");
+			}
+
+			Exception? ex = null;
+
+			// try up to 3 times to init
+			for (int i = 0; i < 3; i++)
 			{
-				ExchangeAPI api = (Activator.CreateInstance(type, true)as ExchangeAPI) !;
-				if (api.Name.Equals(exchangeName, StringComparison.OrdinalIgnoreCase))
+				try
+				{
+					api.InitializeAsync().Sync();
+					break;
+				}
+				catch (Exception _ex)
 				{
-					return GetExchangeAPI(type);
+					ex = _ex;
+					Thread.Sleep(5000);
 				}
 			}
-			throw new ApplicationException("No exchange found with name " + exchangeName);
+
+			if (ex != null)
+			{
+				throw ex;
+			}
+
+			return api;
+		}
+
+		/// <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>
+		public static T CreateExchangeAPI<T>() where T : ExchangeAPI
+		{
+			return (T)CreateExchangeAPI(typeof(T));
 		}
 
 		/// <summary>
-		/// Get an exchange API given a type
+		/// 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 IExchangeAPI GetExchangeAPI(string exchangeName)
+		{
+			Type type = ExchangeName.GetExchangeType(exchangeName);
+			return GetExchangeAPI(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>
-		public static IExchangeAPI GetExchangeAPI<T>()where T : ExchangeAPI
+		public static IExchangeAPI GetExchangeAPI<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) !;
+			Type type = typeof(T)!;
 			return GetExchangeAPI(type);
 		}
 
 		/// <summary>
-		/// Get an exchange API given a type
+		/// 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>
@@ -386,51 +427,52 @@ public static IExchangeAPI GetExchangeAPI(Type type)
 			// subsequent calls with cache hits will be nanoseconds
 			return apis.GetOrAdd(type, _exchangeName =>
 			{
-				// find an API with the right name
-				ExchangeAPI? api = null;
+				// find the api type
 				Type? foundType = exchangeTypes.FirstOrDefault(t => t == type);
-				if (foundType != null)
+				if (foundType is null)
+				{
+					throw new ArgumentException($"Unable to find exchange of type {type?.FullName}");
+				}
+
+				// create the api
+				if (!(Activator.CreateInstance(foundType, true) is ExchangeAPI api))
 				{
-					api = (Activator.CreateInstance(foundType, true)as ExchangeAPI) !;
-					Exception? ex = null;
-					const int retryCount = 3;
+					throw new ApplicationException($"Failed to create exchange of type {foundType.FullName}");
+				}
+
+				Exception? ex = null;
+				const int retryCount = 3;
 
-					// try up to n times to init
-					for (int i = 1; i <= retryCount; i++)
+				// try up to n times to init
+				for (int i = 1; i <= retryCount; i++)
+				{
+					try
 					{
-						try
-						{
-							api.InitializeAsync().Sync();
-							ex = null;
-							break;
-						}
-						catch (Exception _ex)
-						{
-							ex = _ex;
-							if (i != retryCount)
-							{
-								Thread.Sleep(5000);
-							}
-						}
+						api.InitializeAsync().Sync();
+						ex = null;
+						break;
 					}
-
-					if (ex != null)
+					catch (Exception _ex)
 					{
-						throw ex;
+						ex = _ex;
+						if (i != retryCount)
+						{
+							Thread.Sleep(5000);
+						}
 					}
 				}
 
-				if (api == null)
+				if (ex != null)
 				{
-					throw new ApplicationException("No exchange found with type " + type.FullName);
+					throw ex;
 				}
 
 				return api;
 			});
 		}
 
 		/// <summary>
-		/// Get all exchange APIs
+		/// Get all cached versions of exchange APIs
 		/// </summary>
 		/// <returns>All APIs</returns>
 		public static IExchangeAPI[] GetExchangeAPIs()

Diff for: src/ExchangeSharp/API/Exchanges/_Base/ExchangeName.cs

@@ -1,4 +1,4 @@
-/*
+/*
 MIT LICENSE
 
 Copyright 2017 Digital Ruby, LLC - http://www.digitalruby.com
@@ -24,16 +24,45 @@ namespace ExchangeSharp
     /// </summary>
     public static partial class ExchangeName
     {
-        private static readonly HashSet<string> exchangeNames = new HashSet<string>();
+		private static readonly Type exchangeApiType = typeof(ExchangeAPI);
+		private static readonly HashSet<string> exchangeNames = new HashSet<string>();
 
         static ExchangeName()
         {
-            foreach (FieldInfo field in typeof(ExchangeName).GetFields(BindingFlags.Public | BindingFlags.Static))
-            {
-                exchangeNames.Add(field.GetValue(null).ToString());
-            }
+			foreach (FieldInfo field in typeof(ExchangeName).GetFields(BindingFlags.Public | BindingFlags.Static))
+			{
+				// pull value of name field
+				string name = field.GetValue(null)!.ToString();
+
+				// make sure we have a valid type for the name
+				_ = GetExchangeType(name);
+
+				// add to unique list of names
+				exchangeNames.Add(name);
+			}
         }
 
+		internal static Type GetExchangeType(string exchangeName)
+		{
+			try
+			{
+				// make sure we have a valid type for the name
+				Type type = Type.GetType($"ExchangeSharp.Exchange{exchangeName}API");
+
+				// we had better have a type sub-classing from ExchangeAPI
+				if (type is null || !type.IsSubclassOf(exchangeApiType))
+				{
+					throw new ApplicationException($"Name of {exchangeName} is not an {nameof(ExchangeAPI)} class");
+				}
+				return type;
+			}
+			catch (Exception ex)
+			{
+				// fatal
+				throw new ApplicationException($"Failed to get type from exchange name {exchangeName}", ex);
+			}
+		}
+
         /// <summary>
         /// Check if an exchange name exists
         /// </summary>

Diff for: tests/ExchangeSharpTests/ExchangeTests.cs

@@ -62,6 +62,26 @@ private async Task<string> GetAllSymbolsJsonAsync()
             return JsonConvert.SerializeObject(allSymbols);
         }
 
+		[TestMethod]
+		public void ExchangeGetCreateTest()
+		{
+			// make sure get exchange api calls serve up the same instance
+			var ex1 = ExchangeAPI.GetExchangeAPI<ExchangeGeminiAPI>();
+			var ex2 = ExchangeAPI.GetExchangeAPI(ExchangeName.Gemini);
+			Assert.AreSame(ex1, ex2);
+			Assert.IsInstanceOfType(ex2, typeof(ExchangeGeminiAPI));
+
+			// make sure create exchange serves up new instances
+			var ex3 = ExchangeAPI.CreateExchangeAPI<ExchangeGeminiAPI>();
+			Assert.AreNotSame(ex3, ex2);
+
+			// make sure a bad exchange name throws correct exception
+			Assert.ThrowsException<ApplicationException>(() =>
+			{
+				ExchangeAPI.GetExchangeAPI("SirExchangeNotAppearingInThisFilm");
+			});
+		}
+
         [TestMethod]
         public async Task GlobalSymbolTest()
         {