/// <summary>
/// Copies all values from <paramref name="sourceParameters"/> to <paramref name="targetParameters"/>
/// </summary>
/// <param name="targetParameters">Target to copy parameters into</param>
/// <param name="sourceParameters">Source parameters</param>
public static void CopyFrom(this IModifiableBobConnectionParameters targetParameters, IModifiableBobConnectionParameters sourceParameters)
{
if (targetParameters == null)
{
throw new ArgumentNullException(nameof(targetParameters));
}
if (sourceParameters == null)
{
throw new ArgumentNullException(nameof(sourceParameters));
}
targetParameters.Host = sourceParameters.Host;
targetParameters.Port = sourceParameters.Port;
targetParameters.User = sourceParameters.User;
targetParameters.Password = sourceParameters.Password;
targetParameters.MaxReceiveMessageSize = sourceParameters.MaxReceiveMessageSize;
targetParameters.MaxSendMessageSize = sourceParameters.MaxSendMessageSize;
targetParameters.OperationTimeout = sourceParameters.OperationTimeout;
targetParameters.ConnectionTimeout = sourceParameters.ConnectionTimeout;
targetParameters.CustomParameters.Clear();
foreach (var customParam in sourceParameters.CustomParameters)
{
targetParameters.CustomParameters.Add(customParam.Key, customParam.Value);
}
}
/// <summary>
/// Converts parameters to its string representation
/// </summary>
/// <param name="parameters">Parameters instance</param>
/// <param name="includePassword">When True password is included into string representation, otherwise it is not</param>
/// <returns>String representation</returns>
public static string ToString(this IModifiableBobConnectionParameters parameters, bool includePassword)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
const string pairEnding = "; ";
StringBuilder result = new StringBuilder();
if (!string.IsNullOrWhiteSpace(parameters.Host))
{
if (parameters.Port.HasValue)
{
result.Append("Address = ").Append(parameters.Host).Append(":").Append(parameters.Port.Value).Append(pairEnding);
}
else
{
result.Append("Address = ").Append(parameters.Host).Append(pairEnding);
}
}
else
{
if (parameters.Host != null)
{
result.AppendConnectionStringValue("Host", EscapeConnectionStringToken(parameters.Host), pairEnding);
}
if (parameters.Port.HasValue)
{
result.AppendConnectionStringValue("Port", parameters.Port.Value.ToString(), pairEnding);
}
}
result.AppendConnectionStringValue("User", EscapeConnectionStringToken(parameters.User), pairEnding);
if (includePassword)
{
result.AppendConnectionStringValue("Password", EscapeConnectionStringToken(parameters.Password), pairEnding);
}
result.AppendConnectionStringValue("MaxReceiveMessageSize", parameters.MaxReceiveMessageSize?.ToString(), pairEnding);
result.AppendConnectionStringValue("MaxSendMessageSize", parameters.MaxSendMessageSize?.ToString(), pairEnding);
result.AppendConnectionStringValue("OperationTimeout", parameters.OperationTimeout?.ToString(), pairEnding);
result.AppendConnectionStringValue("ConnectionTimeout", parameters.ConnectionTimeout?.ToString(), pairEnding);
foreach (var customParam in parameters.CustomParameters)
{
result.AppendConnectionStringValue(EscapeConnectionStringToken(customParam.Key), EscapeConnectionStringToken(customParam.Value), pairEnding);
}
if (result.Length == 0)
{
return("");
}
return(result.ToString(0, result.Length - pairEnding.Length));
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="sourceParameters">Source parameters</param>
internal BobConnectionParametersBuilder(IModifiableBobConnectionParameters sourceParameters)
{
if (sourceParameters == null)
{
throw new ArgumentNullException(nameof(sourceParameters));
}
_customParameters = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
Host = string.Empty;
IModifiableBobConnectionParametersExtensions.CopyFrom(targetParameters: this, sourceParameters: sourceParameters);
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="sourceParameters">Source parameters</param>
internal BobConnectionParameters(IModifiableBobConnectionParameters sourceParameters)
{
if (sourceParameters == null)
{
throw new ArgumentNullException(nameof(sourceParameters));
}
_customParameters = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
_nodeAddress = null;
Host = string.Empty;
IModifiableBobConnectionParametersExtensions.CopyFrom(targetParameters: this, sourceParameters: sourceParameters);
IModifiableBobConnectionParametersExtensions.Validate(this, ValidationExceptionBehaviour.InvalidConnectionParametersException);
}
/// <summary>
/// Validates connection parameters
/// </summary>
/// <param name="parameters">Parameters</param>
/// <param name="exceptionBehaviour">Controls exception behaviour</param>
/// <returns>True if valid, otherwise False or exception</returns>
public static bool Validate(this IModifiableBobConnectionParameters parameters, ValidationExceptionBehaviour exceptionBehaviour)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (string.IsNullOrWhiteSpace(parameters.Host))
{
return(ReturnOrThrowValidationError(exceptionBehaviour, "Value cannot be an empty string for 'Host' parameter", (object)null));
}
if (parameters.Port.HasValue && (parameters.Port.Value < 0 || parameters.Port.Value > ushort.MaxValue))
{
return(ReturnOrThrowValidationError(exceptionBehaviour, "'Port' is not in a valid range", parameters.Port.Value));
}
if (parameters.MaxReceiveMessageSize.HasValue && parameters.MaxReceiveMessageSize.Value < 0)
{
return(ReturnOrThrowValidationError(exceptionBehaviour, "'MaxReceiveMessageSize' cannot be negative", parameters.MaxReceiveMessageSize.Value));
}
if (parameters.MaxSendMessageSize.HasValue && parameters.MaxSendMessageSize.Value < 0)
{
return(ReturnOrThrowValidationError(exceptionBehaviour, "'MaxSendMessageSize' cannot be negative", parameters.MaxSendMessageSize.Value));
}
if (parameters.OperationTimeout.HasValue && parameters.OperationTimeout.Value < TimeSpan.Zero && parameters.OperationTimeout.Value != Timeout.InfiniteTimeSpan)
{
return(ReturnOrThrowValidationError(exceptionBehaviour, "'OperationTimeout' cannot be negative", parameters.OperationTimeout.Value));
}
if (parameters.ConnectionTimeout.HasValue && parameters.ConnectionTimeout.Value < TimeSpan.Zero && parameters.ConnectionTimeout.Value != Timeout.InfiniteTimeSpan)
{
return(ReturnOrThrowValidationError(exceptionBehaviour, "'ConnectionTimeout' cannot be negative", parameters.ConnectionTimeout.Value));
}
return(true);
}
/// <summary>
/// Parses connection string or node address into <paramref name="parameters"/>
/// </summary>
/// <param name="connectionString">Connection string or node address</param>
/// <param name="parameters">Target parameters</param>
/// <exception cref="ArgumentNullException">Null arguments</exception>
/// <exception cref="FormatException">Incorrect format</exception>
public static void ParseConnectionStringInto(string connectionString, IModifiableBobConnectionParameters parameters)
{
if (connectionString == null)
{
throw new ArgumentNullException(nameof(connectionString));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new FormatException("Connection string cannot be empty. At least 'address' should be specified");
}
if (connectionString.IndexOfAny(_connectionStringMarkers) < 0)
{
BobNodeAddress.TryParseCore(connectionString, true, out string host, out int?port);
parameters.Host = host;
if (port != null)
{
parameters.Port = port;
}
}
else
{
var keyValues = ParseConnectionStringIntoKeyValues(connectionString);
foreach (var keyValue in keyValues)
{
parameters.SetValue(keyValue.Key, keyValue.Value, allowCustomParameters: true);
}
}
parameters.Validate(ValidationExceptionBehaviour.FormatException);
}
/// <summary>
/// Sets value for specified key
/// </summary>
/// <param name="parameters">Parameters that will be changed in this operation</param>
/// <param name="key">Key</param>
/// <param name="value">Value</param>
/// <param name="allowCustomParameters">If false, an exception will be thrown if the parameter does not match any known. Otherwise, the value will be written into CustomParameters</param>
public static void SetValue(this IModifiableBobConnectionParameters parameters, string key, string value, bool allowCustomParameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentException("Key cannot be an empty string", nameof(key));
}
switch (key.ToLower())
{
case "host":
parameters.Host = value;
break;
case "port":
if (string.IsNullOrWhiteSpace(value))
{
parameters.Port = null;
}
else if (!int.TryParse(value, out int portVal))
{
throw new FormatException($"Unable to parse 'port' value: {value}");
}
else
{
parameters.Port = portVal;
}
break;
case "address":
case "server":
if (value == null)
{
parameters.Host = null;
parameters.Port = null;
}
else if (string.IsNullOrWhiteSpace(value))
{
parameters.Host = value;
}
else
{
BobNodeAddress.TryParseCore(value, true, out string addrHostVal, out int?addrPortVal);
parameters.Host = addrHostVal;
if (addrPortVal != null)
{
parameters.Port = addrPortVal;
}
}
break;
case "user":
case "user id":
parameters.User = value;
break;
case "password":
parameters.Password = value;
break;
case "maxreceivemessagesize":
case "maxreceivemessagelength":
if (string.IsNullOrWhiteSpace(value))
{
parameters.MaxReceiveMessageSize = null;
}
else if (!int.TryParse(value, out int maxReceiveMessageSizeVal))
{
throw new FormatException($"Unable to parse '{key}' value: {value}");
}
else
{
parameters.MaxReceiveMessageSize = maxReceiveMessageSizeVal;
}
break;
case "maxsendmessagesize":
case "maxsendmessagelength":
if (string.IsNullOrWhiteSpace(value))
{
parameters.MaxSendMessageSize = null;
}
else if (!int.TryParse(value, out int maxSendMessageSizeVal))
{
throw new FormatException($"Unable to parse '{key}' value: {value}");
}
else
{
parameters.MaxSendMessageSize = maxSendMessageSizeVal;
}
break;
case "operationtimeout":
if (string.IsNullOrWhiteSpace(value))
{
parameters.OperationTimeout = null;
}
else
{
parameters.OperationTimeout = ParseTimeInterval(key, value);
}
break;
case "connectiontimeout":
case "connect timeout":
if (string.IsNullOrWhiteSpace(value))
{
parameters.ConnectionTimeout = null;
}
else
{
parameters.ConnectionTimeout = ParseTimeInterval(key, value);
}
break;
case "timeout":
if (string.IsNullOrWhiteSpace(value))
{
parameters.ConnectionTimeout = null;
parameters.OperationTimeout = null;
}
else
{
parameters.ConnectionTimeout = ParseTimeInterval(key, value);
parameters.OperationTimeout = parameters.ConnectionTimeout;
}
break;
default:
if (!allowCustomParameters)
{
throw new ArgumentException($"Unknown key: {key}", nameof(key));
}
parameters.CustomParameters[key] = value;
break;
}
}
/// <summary>
/// Validates connection parameters
/// </summary>
/// <param name="parameters">Parameters</param>
/// <returns>True if valid, otherwise False</returns>
public static bool IsValid(this IModifiableBobConnectionParameters parameters)
{
return(Validate(parameters, ValidationExceptionBehaviour.NoException));
}
/// <summary>
/// Gets value from parameters by specified key
/// </summary>
/// <param name="parameters">Parameters instance</param>
/// <param name="key">Key</param>
/// <param name="allowCustomParameters">If true, the CustomParameters dictionary is also used to retrieve the value</param>
/// <returns>Extracted value</returns>
public static string GetValue(this IModifiableBobConnectionParameters parameters, string key, bool allowCustomParameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentException("Key cannot be an empty string", nameof(key));
}
switch (key.ToLower())
{
case "host":
return(parameters.Host);
case "port":
return(parameters.Port?.ToString());
case "address":
case "server":
if (string.IsNullOrWhiteSpace(parameters.Host))
{
return(null);
}
if (parameters.Port.HasValue)
{
return((parameters.Host ?? "") + ":" + parameters.Port.Value.ToString());
}
return(parameters.Host ?? "");
case "user":
case "user id":
return(parameters.User);
case "password":
return(parameters.Password);
case "maxreceivemessagesize":
case "maxreceivemessagelength":
return(parameters.MaxReceiveMessageSize?.ToString());
case "maxsendmessagesize":
case "maxsendmessagelength":
return(parameters.MaxSendMessageSize?.ToString());
case "operationtimeout":
return(parameters.OperationTimeout?.ToString());
case "connectiontimeout":
case "connect timeout":
return(parameters.ConnectionTimeout?.ToString());
default:
if (!allowCustomParameters)
{
throw new ArgumentException($"Unknown key: {key}", nameof(key));
}
if (!parameters.CustomParameters.ContainsKey(key))
{
throw new ArgumentException($"Key is unknown and not presented in CustomParameters dictionary: {key}", nameof(key));
}
return(parameters.CustomParameters[key]);
}
}
internal bool Equals(IModifiableBobConnectionParameters other)
{
return(ModifiableBobConnectionParametersEqualityComparer.Instance.Equals(this, other));
}
