/// <summary>
        /// Resolves a single component connection. If connections are configured to be
        /// retrieved from Discovery service it finds a IDiscovery and resolves the connection there.
        /// </summary>
        /// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param>
        /// <returns>resolved connection parameters or null if nothing was found.</returns>
        public async Task <ConnectionParams> ResolveAsync(string correlationId)
        {
            if (_connections.Count == 0)
            {
                return(null);
            }

            // Return connection that doesn't require discovery
            foreach (var connection in _connections)
            {
                if (!connection.UseDiscovery)
                {
                    return(connection);
                }
            }

            // Return connection that require discovery
            foreach (var connection in _connections)
            {
                if (connection.UseDiscovery)
                {
                    var resolvedConnection = await ResolveInDiscoveryAsync(correlationId, connection);

                    if (resolvedConnection != null)
                    {
                        // Merge configured and new parameters
                        resolvedConnection = new ConnectionParams(ConfigParams.MergeConfigs(connection, resolvedConnection));
                        return(resolvedConnection);
                    }
                }
            }

            return(null);
        }
        /// <summary>
        /// Resolves all component connection. If connections are configured to be
        /// retrieved from Discovery service it finds a IDiscovery and resolves the connection there.
        /// </summary>
        /// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param>
        /// <returns>a list of resolved connections.</returns>
        public async Task <List <ConnectionParams> > ResolveAllAsync(string correlationId)
        {
            var resolved  = new List <ConnectionParams>();
            var toResolve = new List <ConnectionParams>();

            // Sort connections
            foreach (var connection in _connections)
            {
                if (connection.UseDiscovery)
                {
                    toResolve.Add(connection);
                }
                else
                {
                    resolved.Add(connection);
                }
            }

            // Resolve addresses that require that
            if (toResolve.Count <= 0)
            {
                return(resolved);
            }

            foreach (var connection in toResolve)
            {
                var resolvedConnections = await ResolveAllInDiscoveryAsync(correlationId, connection);

                foreach (var resolvedConnection in resolvedConnections)
                {
                    // Merge configured and new parameters
                    var localResolvedConnection = new ConnectionParams(ConfigParams.MergeConfigs(connection, resolvedConnection));
                    resolved.Add(localResolvedConnection);
                }
            }

            return(resolved);
        }
        private string ComposeUri(List <ConnectionParams> connections, CredentialParams credential)
        {
            // If there is a uri then return it immediately
            foreach (var connection in connections)
            {
                var fullUri = connection.GetAsNullableString("uri");//connection.Uri;
                if (fullUri != null)
                {
                    return(fullUri);
                }
            }

            // Define hosts
            var hosts = "";

            foreach (var connection in connections)
            {
                var host = connection.Host;
                var port = connection.Port;

                if (hosts.Length > 0)
                {
                    hosts += ",";
                }
                hosts += host + (port == 0 ? "" : ":" + port);
            }

            // Define database
            var database = "";

            foreach (var connection in connections)
            {
                database = connection.GetAsNullableString("database") ?? database;
            }
            if (database.Length > 0)
            {
                database = "/" + database;
            }

            // Define authentication part
            var auth = "";

            if (credential != null)
            {
                var username = credential.Username;
                if (username != null)
                {
                    var password = credential.Password;
                    if (password != null)
                    {
                        auth = username + ":" + password + "@";
                    }
                    else
                    {
                        auth = username + "@";
                    }
                }
            }

            // Define additional parameters parameters
            var options = ConfigParams.MergeConfigs(connections.ToArray()).Override(credential);

            options.Remove("uri");
            options.Remove("host");
            options.Remove("port");
            options.Remove("database");
            options.Remove("username");
            options.Remove("password");
            var parameters = "";
            var keys       = options.Keys;

            foreach (var key in keys)
            {
                if (parameters.Length > 0)
                {
                    parameters += "&";
                }

                parameters += key;

                var value = options.GetAsString(key);
                if (value != null)
                {
                    parameters += "=" + value;
                }
            }
            if (parameters.Length > 0)
            {
                parameters = "?" + parameters;
            }

            // Compose uri
            var uri = "mongodb://" + auth + hosts + database + parameters;

            return(uri);
        }
        public static AzureStorageConnectionParams MergeConfigs(params ConfigParams[] configs)
        {
            var config = ConfigParams.MergeConfigs(configs);

            return(new AzureStorageConnectionParams(config));
        }