Exemplo n.º 1
0
        public static void AddParameters(this SqlCommand command, ExecutableParameters parameters)
        {
            Guard.IsNotNull(command, nameof(command));

            foreach (var parameter in parameters)
            {
                command.Parameters.Add(new SqlParameter(parameter.Key, parameter.Value));
            }
        }
Exemplo n.º 2
0
        public void Get_ReturnsParsedBoolValue_WhenKeyIsFound()
        {
            var parameters = new ExecutableParameters(new Dictionary <string, string>()
            {
                { "mykey", "true" }
            });
            var value = parameters.Get <bool>("mykey");

            Assert.True(value);
        }
Exemplo n.º 3
0
        public void Get_ReturnsParsedIntValue_WhenKeyIsFound()
        {
            var parameters = new ExecutableParameters(new Dictionary <string, string>()
            {
                { "mykey", "156" }
            });
            var value = parameters.Get <int>("mykey");

            Assert.Equal(156, value);
        }
Exemplo n.º 4
0
        public void Get_ReturnsValue_WhenKeyIsFound()
        {
            var parameters = new ExecutableParameters(new Dictionary <string, string>()
            {
                { "mykey", "my_value" }
            });
            var value = parameters.Get("mykey");

            Assert.Equal("my_value", value);
        }
Exemplo n.º 5
0
        public void Get_ThrowsException_WhenValueNotCorrectFormat()
        {
            var parameters = new ExecutableParameters(new Dictionary <string, string>()
            {
                { "mykey", "not_an_integer" }
            });
            var exception = Record.Exception(() => parameters.Get <int>("mykey"));

            Assert.NotNull(exception);
            Assert.IsType <FormatException>(exception);
        }
Exemplo n.º 6
0
        private void SetValuesFromArguments(string[] arguments)
        {
            if (arguments == null || arguments.Length == 0)
            {
                throw new ArgumentNullException(nameof(arguments));
            }

            if (arguments.Length < _requiredArgumentCount)
            {
                throw new InvalidOperationException($"Not all required arguments ({_requiredArgumentCount}) were supplied. Argument count: {arguments.Length}.");
            }

            IDictionary <string, string> parameters = new Dictionary <string, string>();

            foreach (var arg in arguments)
            {
                var keyValue = arg.Split('=');
                if (keyValue.Length != 2)
                {
                    throw new InvalidOperationException($"Argument '{arg}' not in correct format of 'key=value'.");
                }

                string key   = keyValue[0]?.Trim();
                string value = keyValue[1]?.Trim();

                if (string.IsNullOrWhiteSpace(key))
                {
                    throw new ArgumentNullException("Argument key empty or null.");
                }

                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException("Argument value empty or null.");
                }

                if (key == ParameterKeys.IntegrationDirectory && string.IsNullOrWhiteSpace(IntegrationDirectory))
                {
                    IntegrationDirectory = value;
                }
                else if (key == ParameterKeys.ExecutablesDirectory && string.IsNullOrWhiteSpace(ExecutablesDirectory))
                {
                    ExecutablesDirectory = value;
                }
                else if (key == ParameterKeys.Library && string.IsNullOrWhiteSpace(LibraryPath))
                {
                    LibraryPath = value.EndsWith(".dll") ? value : $"{value}.dll";
                }
                else if (key == ParameterKeys.Type && string.IsNullOrWhiteSpace(TypeName))
                {
                    TypeName = value;
                }
                else if (key == ParameterKeys.Assembly && string.IsNullOrWhiteSpace(AssemblyName))
                {
                    AssemblyName = value;
                }
                else
                {
                    parameters.Add(key, value);
                }
            }

            Parameters = new ExecutableParameters(parameters);
        }