CryptoExchange V12 (#281)

* Result types:
  * (Web)CallResult types are replaced by HttpResult, WebSocketResult and QueryResult with the same logic
  * Updated result types to record type
  * Result creation can be done with (Http/WebSocket/Query)Result.Ok(..) and .Fail(..)
  * Removed implicit result type conversion to bool, `if (result)` no longer works, instead use `if (result.Success)`
  * Replaced CallResult.SuccessResult with CallResult.Ok()
  * Fixed result object nullability hinting, for example Data might be null if Success isn't checked for true

* Parameters & serialization:
  * Added support for `enabled` and `disabled` strings to bool converter
  * Removed ParameterCollection type, has been replaced by Parameters type
  * Removed ArraySerialization, OrderParameters and ParameterOrderComparer properties from RestApiClient, moved to ParameterSerializationsSettings
  * Updated RestRequestConfiguration in AuthenticationProvider.ProcessRequest to contain the full RequestDefinition instead of copied fields	

* Clients:
  * Updated Api client constructor logging parameter from ILogger to ILoggerFactory? 
  * Added Api client constructor exchange name parameter
  * Added ToString overrides on base API types
  * Added Exchange property on BaseApiClient
  * Added ApiCredentials property on IRestApiClient and ISocketApiClient interfaces
  * Updated ILogger source from client name to topic specific client name
  * Removed logging from client creation
  * Fixed BaseRestClient SetApiCredentials not marked as virtual

* Rest:
  * Added BaseAddress to RequestDefinition object
  * Updated RestApiClient AuthenticationProvider logic from private to protected and virtual
  * Removed RestApiClient.SendAsync baseAddress parameter removed
  * Removed RestApiClient.SendAsync without type parameter

* WebSocket:
  * Updated MessageRouting definition into CreateForEvent for subscriptions and CreateForQuery for queries
  * Improved Query type safety with CeateForQuery which allows second parameter for specifying the result type
  * Renamed MessageRouter.CreateWithoutHandler to CreateVoid
  * Updated SocketApiClient.GetSocketConnection to check connection uri instead of Tag for finding compatible connections
  * Removed unused UnhandledMessageExpected property SocketApiClient
  * Fixed issue in SocketApiClient.GetSocketConnection causing requests to always wait the full max 10 seconds when there was a reconnecting socket
	
* Shared APIs:
  * Updated Option definitions to always require the exchange name as first parameter
  * Added missing dedicated option types
  * Added Discover method on ISharedClient interface, returning info on supported capabilities and operations
  * Added SharedRequest GetParamValue helper method accepting multiple parameter names
  * Added ResetStaticExchangeParameters method on ExchangeParameters
  * Added Status property to SharedWithdrawal model
  * Added TradingModes property to SharedBalance model
  * Updated ExchangeSymbolCache to support multiple environments and additional key separation
  * Updated Shared ExchangeParameters parameter names to be case insensitive
  * Updated code comments
  * Replaced ExchangeResult with ExchangeCallResult type
  * Removed AsExchangeResult/ExchangeWebResult
  * Removed TradingMode from the response model, only maintained on models where it makes sense
  * Removed IListenKey support, listen keys now rely on internal management with TokenManager

* Rate limiting:
  * Fixed websocket connection attempts counting towards rate limit even when server could not be reached
  * Removed host from rate limit methods, now part of the already provided RequestDefinition
  * Added amount parameter to RateLimit Reset method to allow partially resetting the limit

* Added TokenManager implementation for automatic listenkey/token management
* Added UserClientProvider base class
* Added async streaming on UserDataTracker items with StreamUpdatesAsync
* Added cancellation token support to UserDataTracker starting
* Added Unit type for non-result types
* Added ServerError constructor taking ErrorType and message to make it easier to create
* Added SupportedEnvironments property to PlatformInfo
* Updated SymbolOrderBook DoResyncAsync to return CallResult instead of CallResult<bool> which was redundant
* Various small performance improvements

CryptoExchange.Net.UnitTests/Implementations/TestQuery.cs

@@ -11,15 +11,15 @@ namespace CryptoExchange.Net.UnitTests.Implementations
     {
         public TestQuery(TestSocketMessage request, bool authenticated) : base(request, authenticated, 1)
         {
-            MessageRouter = MessageRouter.CreateWithoutTopicFilter<TestSocketMessage>(request.Id.ToString(), HandleMessage);
+            MessageRouter = MessageRouter.CreateForQuery<TestSocketMessage>(request.Id.ToString(), HandleMessage);
         }
 
-        private CallResult? HandleMessage(SocketConnection connection, DateTime time, string? arg3, TestSocketMessage message)
+        private CallResult<TestSocketMessage>? HandleMessage(SocketConnection connection, DateTime time, string? arg3, TestSocketMessage message)
         {
             if (message.Data != "OK")
-                return new CallResult(new ServerError(ErrorInfo.Unknown with { Message = message.Data }));
+                return CallResult.Fail<TestSocketMessage>(new ServerError(ErrorInfo.Unknown with { Message = message.Data }));
 
-            return CallResult.SuccessResult;
+            return CallResult.Ok(message);
         }
     }
 }

CryptoExchange.Net.UnitTests/Implementations/TestRestApiClient.cs

@@ -20,8 +20,8 @@ namespace CryptoExchange.Net.UnitTests.Implementations
     {
         protected override IRestMessageHandler MessageHandler { get; } = new TestRestMessageHandler();
 
-        public TestRestApiClient(ILogger logger, HttpClient? httpClient, TestRestOptions options) 
-            : base(logger, httpClient, options.Environment.RestClientAddress, options, options.ExchangeOptions)
+        public TestRestApiClient(ILoggerFactory? loggerFactory, HttpClient? httpClient, TestRestOptions options) 
+            : base(loggerFactory, "Test", httpClient, options.Environment.RestClientAddress, options, options.ExchangeOptions)
         {
         }
 
@@ -48,14 +48,14 @@ namespace CryptoExchange.Net.UnitTests.Implementations
             RequestFactory = factory;
         }
 
-        internal async Task<WebCallResult<T>> GetResponseAsync<T>(HttpMethod? httpMethod = null, ParameterCollection? collection = null, RateLimitGate? rateLimitGate = null)
+        internal async Task<HttpResult<T>> GetResponseAsync<T>(HttpMethod? httpMethod = null, Parameters? collection = null, RateLimitGate? rateLimitGate = null)
         {
-            var definition = new RequestDefinition("/path", httpMethod ?? HttpMethod.Get)
+            var definition = new RequestDefinition(BaseAddress, "/path", httpMethod ?? HttpMethod.Get)
             {
                 Weight = rateLimitGate == null ? 0 : 1,
                 RateLimitGate = rateLimitGate
             };
-            return await SendAsync<T>(BaseAddress, definition, collection ?? new ParameterCollection(), default);
+            return await SendAsync<T>(definition, collection ?? new Parameters(new ParameterSerializationSettings()), default);
         }
 
         internal void SetParameterPosition(HttpMethod httpMethod, HttpMethodParameterPosition pos)

CryptoExchange.Net.UnitTests/Implementations/TestRestClient.cs

@@ -20,8 +20,8 @@ namespace CryptoExchange.Net.UnitTests.Implementations
         {
             Initialize(options.Value);
 
-            ApiClient1 = AddApiClient(new TestRestApiClient(_logger, httpClient, options.Value));
-            ApiClient2 = AddApiClient(new TestRestApiClient(_logger, httpClient, options.Value));
+            ApiClient1 = AddApiClient(new TestRestApiClient(loggerFactory, httpClient, options.Value));
+            ApiClient2 = AddApiClient(new TestRestApiClient(loggerFactory, httpClient, options.Value));
         }
     }
 }

CryptoExchange.Net.UnitTests/Implementations/TestSerializerContext.cs

@@ -1,4 +1,5 @@
-using CryptoExchange.Net.UnitTests.ConverterTests;
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.UnitTests.ConverterTests;
 using CryptoExchange.Net.UnitTests.Implementations;
 using System.Collections.Generic;
 using System.Text.Json.Serialization;
@@ -11,6 +12,7 @@ namespace CryptoExchange.Net.UnitTests
     [JsonSerializable(typeof(IDictionary<string, string>))]
     [JsonSerializable(typeof(Dictionary<string, object>))]
     [JsonSerializable(typeof(IDictionary<string, object>))]
+    [JsonSerializable(typeof(Parameters))]
     [JsonSerializable(typeof(TestObject))]
 
     [JsonSerializable(typeof(TestSocketMessage))]

CryptoExchange.Net.UnitTests/Implementations/TestSocketApiClient.cs

@@ -17,13 +17,13 @@ namespace CryptoExchange.Net.UnitTests.Implementations
 {
     internal class TestSocketApiClient : SocketApiClient<TestEnvironment, TestAuthenticationProvider, TestCredentials>
     {
-        public TestSocketApiClient(ILogger logger, TestSocketOptions options)
-            : base(logger, options.Environment.SocketClientAddress, options, options.ExchangeOptions)
+        public TestSocketApiClient(ILoggerFactory? loggerFactory, TestSocketOptions options)
+            : base(loggerFactory, "Test", options.Environment.SocketClientAddress, options, options.ExchangeOptions)
         {
         }
 
-        public TestSocketApiClient(ILogger logger, HttpClient httpClient, string baseAddress, TestSocketOptions options, SocketApiOptions apiOptions)
-            : base(logger, baseAddress, options, apiOptions)
+        public TestSocketApiClient(ILoggerFactory? loggerFactory, HttpClient httpClient, string baseAddress, TestSocketOptions options, SocketApiOptions apiOptions)
+            : base(loggerFactory, "Test", baseAddress, options, apiOptions)
         {
         }
 
@@ -36,7 +36,7 @@ namespace CryptoExchange.Net.UnitTests.Implementations
         protected override TestAuthenticationProvider CreateAuthenticationProvider(TestCredentials credentials) =>
             new TestAuthenticationProvider(credentials);
 
-        public async Task<CallResult<UpdateSubscription>> SubscribeToUpdatesAsync<T>(Action<DataEvent<T>> handler, bool subQuery, CancellationToken ct)
+        public async Task<WebSocketResult<UpdateSubscription>> SubscribeToUpdatesAsync<T>(Action<DataEvent<T>> handler, bool subQuery, CancellationToken ct)
         {
             return await base.SubscribeAsync(new TestSubscription<T>(_logger, handler, subQuery, false), ct);
         }

CryptoExchange.Net.UnitTests/Implementations/TestSocketClient.cs

@@ -19,8 +19,8 @@ namespace CryptoExchange.Net.UnitTests.Implementations
         {
             Initialize(options.Value);
 
-            ApiClient1 = AddApiClient(new TestSocketApiClient(_logger, options.Value));
-            ApiClient2 = AddApiClient(new TestSocketApiClient(_logger, options.Value));
+            ApiClient1 = AddApiClient(new TestSocketApiClient(loggerFactory, options.Value));
+            ApiClient2 = AddApiClient(new TestSocketApiClient(loggerFactory, options.Value));
         }
     }
 }

CryptoExchange.Net.UnitTests/Implementations/TestSubscription.cs

@@ -21,7 +21,7 @@ namespace CryptoExchange.Net.UnitTests.Implementations
             _handler = handler;
             _subQuery = subQuery;
 
-            MessageRouter = MessageRouter.CreateWithoutTopicFilter<T>("test", HandleUpdate);
+            MessageRouter = MessageRouter.CreateForEvent<T>("test", HandleUpdate);
         }
 
         protected override Query? GetSubQuery(SocketConnection connection)
@@ -44,7 +44,7 @@ namespace CryptoExchange.Net.UnitTests.Implementations
         private CallResult? HandleUpdate(SocketConnection connection, DateTime time, string? originalData, T data)
         {
             _handler(new DataEvent<T>("Test", data, time, originalData));
-            return CallResult.SuccessResult;
+            return CallResult.Ok();
         }
     }
 }