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/Converters/SystemTextJson/BoolConverter.cs

@@ -56,14 +56,26 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             if (reader.TokenType == JsonTokenType.False)
                 return false;
 
-            var value = reader.TokenType switch
+            if (reader.TokenType == JsonTokenType.Number)
             {
-                JsonTokenType.String => reader.GetString(),
-                JsonTokenType.Number => reader.GetInt16().ToString(),
-                _ => null
-            };
+                var number = reader.GetInt16();
+                if (number > 1)
+                    return true;
 
-            value = value?.ToLowerInvariant().Trim();
+                return false;
+            }
+
+            if (reader.TokenType == JsonTokenType.Null)
+            {
+                if (typeToConvert == typeof(bool))
+                    LibraryHelpers.StaticLogger?.LogWarning("Received null bool value, but property type is not a nullable bool. Resolver: {Resolver}", options.TypeInfoResolver?.GetType()?.Name);
+                return default;
+            }
+
+            if (reader.TokenType != JsonTokenType.String)
+                throw new SerializationException($"Can't convert bool value for token type {reader.TokenType}");
+            
+            var value = reader.GetString()?.ToLowerInvariant().Trim();
             if (string.IsNullOrEmpty(value))
             {
                 if (typeToConvert == typeof(bool))
@@ -73,12 +85,14 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
 
             switch (value)
             {
+                case "enabled":
                 case "true":
                 case "yes":
                 case "y":
                 case "1":
                 case "on":
                     return true;
+                case "disabled":
                 case "false":
                 case "no":
                 case "n":
@@ -88,7 +102,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                     return false;
             }
 
-            throw new SerializationException($"Can't convert bool value {value}");
+            throw new SerializationException($"Can't convert bool value, unknown string value: {value}");
         }
 
     }

CryptoExchange.Net/Converters/SystemTextJson/DateTimeConverter.cs

@@ -16,17 +16,19 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         private const long _ticksPerSecond = TimeSpan.TicksPerMillisecond * 1000;
         private const decimal _ticksPerMicrosecond = TimeSpan.TicksPerMillisecond / 1000m;
         private const decimal _ticksPerNanosecond = TimeSpan.TicksPerMillisecond / 1000m / 1000;
+        private static Type _dateTimeType = typeof(DateTime);
+        private static Type _nullableDateTimeType = typeof(DateTime?);
 
         /// <inheritdoc />
         public override bool CanConvert(Type typeToConvert)
         {
-            return typeToConvert == typeof(DateTime) || typeToConvert == typeof(DateTime?);
+            return typeToConvert == _dateTimeType || typeToConvert == _nullableDateTimeType;
         }
 
         /// <inheritdoc />
         public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
         {
-            return typeToConvert == typeof(DateTime) ? new DateTimeConverterInner() : new NullableDateTimeConverterInner();
+            return typeToConvert == _dateTimeType ? new DateTimeConverterInner() : new NullableDateTimeConverterInner();
         }
 
         private class NullableDateTimeConverterInner : JsonConverter<DateTime?>
@@ -68,7 +70,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         {
             if (reader.TokenType == JsonTokenType.Null)
             {
-                if (typeToConvert == typeof(DateTime))
+                if (typeToConvert == _dateTimeType)
                     LibraryHelpers.StaticLogger?.LogWarning("DateTime value of null, but property is not nullable. Resolver: {Resolver}", options.TypeInfoResolver?.GetType()?.Name);
                 return default;
             }
@@ -76,7 +78,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
             if (reader.TokenType is JsonTokenType.Number)
             {
                 var decValue = reader.GetDecimal();
-                if (decValue == 0 || decValue < 0)
+                if (decValue <= 0)
                     return default;
 
                 return ParseFromDecimal(decValue);
@@ -86,8 +88,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
                 var stringValue = reader.GetString();
                 if (string.IsNullOrWhiteSpace(stringValue)
                     || stringValue!.Equals("-1", StringComparison.Ordinal)
-                    || stringValue!.Equals("0001-01-01T00:00:00Z", StringComparison.OrdinalIgnoreCase)
-                    || decimal.TryParse(stringValue, out var decVal) && decVal == 0)
+                    || stringValue!.Equals("0001-01-01T00:00:00Z", StringComparison.OrdinalIgnoreCase))
                 {
                     return default;
                 }
@@ -124,7 +125,7 @@ namespace CryptoExchange.Net.Converters.SystemTextJson
         /// <summary>
         /// Parse a string value to datetime
         /// </summary>
-        public static DateTime ParseFromString(string stringValue, string? resolverName)
+        public static DateTime? ParseFromString(string stringValue, string? resolverName)
         {
             if (stringValue!.Length == 12 && stringValue.StartsWith("202", StringComparison.OrdinalIgnoreCase))
             {