/// <summary>
/// Confirms that the string parameter value is not null or empty, otherwise throws an exception.
/// </summary>
/// <param name="parameter">The string parameter.</param>
/// <param name="exceptionMessage">The exception message.</param>
/// <returns>
/// The input string parameter.
/// </returns>
/// <exception cref="System.ArgumentException">Thrown if the string parameter is empty.</exception>
/// <exception cref="System.ArgumentNullException">Thrown if the string parameter is null.</exception>
public static Parameter <string> IsNotNullOrEmpty(this Parameter <string> parameter, string exceptionMessage)
{
parameter = parameter.IsNotNull(exceptionMessage);
if (!object.Equals(parameter.Value, string.Empty))
{
return(parameter);
}
if (string.IsNullOrWhiteSpace(exceptionMessage))
{
exceptionMessage = "String is empty.";
}
throw new ArgumentException(exceptionMessage, parameter.ParameterName);
}
/// <summary>
/// Confirms that the string parameter value is not null, empty or white space, otherwise throws an exception.
/// </summary>
/// <param name="parameter">The string parameter.</param>
/// <param name="exceptionMessage">The exception message.</param>
/// <returns>
/// The input string parameter.
/// </returns>
/// <exception cref="System.ArgumentException">Thrown if the string parameter is empty or white space.</exception>
/// <exception cref="System.ArgumentNullException">Thrown if the string parameter is null.</exception>
public static Parameter <string> IsNotNullOrWhiteSpace(this Parameter <string> parameter, string exceptionMessage)
{
parameter = parameter.IsNotNull(exceptionMessage);
if (!string.IsNullOrWhiteSpace(parameter.Value))
{
return(parameter);
}
if (string.IsNullOrWhiteSpace(exceptionMessage))
{
exceptionMessage = string.Format("String is empty or whitespace. Value:<{0}>.", parameter.Value);
}
throw new ArgumentException(exceptionMessage, parameter.ParameterName);
}
/// <summary>
/// Confirms that the collection parameter value is not null or empty, otherwise throws an exception.
/// </summary>
/// <typeparam name="T">The type of the items in the collection parameter.</typeparam>
/// <param name="parameter">The collection parameter.</param>
/// <param name="exceptionMessage">The exception message.</param>
/// <returns>
/// The input collection parameter.
/// </returns>
/// <exception cref="System.ArgumentException">Thrown if the collection parameter is empty.</exception>
/// <exception cref="System.ArgumentNullException">Thrown if the collection parameter is null.</exception>
public static Parameter <IEnumerable <T> > IsNotNullOrEmpty <T>(this Parameter <IEnumerable <T> > parameter, string exceptionMessage)
{
parameter = parameter.IsNotNull(exceptionMessage);
if (parameter.Value.Count() > 0)
{
return(parameter);
}
if (string.IsNullOrWhiteSpace(exceptionMessage))
{
exceptionMessage = "Collection is empty.";
}
throw new ArgumentException(exceptionMessage, parameter.ParameterName);
}
/// <summary>
/// Confirms that the parameter value is not an instance of the specified type, otherwise throws an exception.
/// </summary>
/// <typeparam name="T">The type of the parameter.</typeparam>
/// <param name="parameter">The parameter.</param>
/// <param name="type">The type.</param>
/// <param name="exceptionMessage">The exception message.</param>
/// <returns>
/// The input parameter.
/// </returns>
/// <exception cref="System.ArgumentException">Thrown if the parameter is an instance of the specified type.</exception>
public static Parameter <T> IsNotInstanceOfType <T>(this Parameter <T> parameter, Type type, string exceptionMessage)
{
parameter = parameter.IsNotNull(exceptionMessage);
if (!type.IsInstanceOfType(parameter.Value))
{
return(parameter);
}
if (string.IsNullOrWhiteSpace(exceptionMessage))
{
exceptionMessage = string.Format(
"Value is of an unexpected type. Type:<{0}>.",
type.FullName);
}
throw new ArgumentException(exceptionMessage, parameter.ParameterName);
}
/// <summary>
/// Confirms that the collection parameter value does not contain the unexpected value, otherwise throws an exception.
/// </summary>
/// <typeparam name="T">The type of the items in the parameter collection.</typeparam>
/// <param name="parameter">The collection parameter.</param>
/// <param name="unexpectedValue">The unexpected value.</param>
/// <param name="exceptionMessage">The exception message.</param>
/// <returns>
/// The input collection parameter.
/// </returns>
/// <exception cref="System.ArgumentException">Thrown if the collection parameter value contains the unexpected value.</exception>
public static Parameter <IEnumerable <T> > DoesNotContain <T>(this Parameter <IEnumerable <T> > parameter, T unexpectedValue, string exceptionMessage)
{
parameter = parameter.IsNotNull(exceptionMessage);
if (!parameter.Value.Contains(unexpectedValue))
{
return(parameter);
}
if (string.IsNullOrWhiteSpace(exceptionMessage))
{
exceptionMessage = string.Format(
"Collection contains an unexpected value. Value:<{0}>.",
unexpectedValue);
}
throw new ArgumentException(exceptionMessage, parameter.ParameterName);
}
/// <summary>
/// Confirms that the collection parameter value contains the expected value, otherwise throws an exception.
/// </summary>
/// <typeparam name="T">The type of the items in the parameter collection.</typeparam>
/// <param name="parameter">The collection parameter.</param>
/// <param name="expectedValue">The expected value.</param>
/// <param name="exceptionMessage">The exception message.</param>
/// <returns>
/// The input collection parameter.
/// </returns>
/// <exception cref="System.ArgumentException">Thrown if the collection parameter value does not contain the expected value.</exception>
public static Parameter <IEnumerable <T> > Contains <T>(this Parameter <IEnumerable <T> > parameter, T expectedValue, string exceptionMessage)
{
parameter = parameter.IsNotNull(exceptionMessage);
if (parameter.Value.Contains(expectedValue))
{
return(parameter);
}
if (string.IsNullOrWhiteSpace(exceptionMessage))
{
exceptionMessage = string.Format(
"Collection does not contain the expected value. Expected:<{0}>.",
expectedValue);
}
throw new ArgumentException(exceptionMessage, parameter.ParameterName);
}
/// <summary>
/// Confirms that the string parameter value starts with the expected value, otherwise throws an exception.
/// </summary>
/// <param name="parameter">The string parameter.</param>
/// <param name="expectedValue">The expected value.</param>
/// <param name="exceptionMessage">The exception message.</param>
/// <returns>
/// The input string parameter.
/// </returns>
/// <exception cref="System.ArgumentException">Thrown if the string parameter value does not start with the expected value.</exception>
public static Parameter <string> StartsWith(this Parameter <string> parameter, string expectedValue, string exceptionMessage)
{
parameter = parameter.IsNotNull(exceptionMessage);
if (parameter.Value.StartsWith(expectedValue))
{
return(parameter);
}
if (string.IsNullOrWhiteSpace(exceptionMessage))
{
exceptionMessage = string.Format(
"String does not start with the expected value. Expected:<{0}> Actual:<{1}>.",
expectedValue,
parameter.Value);
}
throw new ArgumentException(exceptionMessage, parameter.ParameterName);
}
/// <summary>
/// Confirms that the string parameter value matches the specified regular expression pattern, otherwise throws an exception.
/// </summary>
/// <param name="parameter">The parameter.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="regexOptions">The regex options.</param>
/// <param name="exceptionMessage">The exception message.</param>
/// <returns>
/// The input parameter.
/// </returns>
/// <exception cref="System.ArgumentException">Thrown if the string parameter value does not match the regular expression pattern.</exception>
public static Parameter <string> IsMatch(this Parameter <string> parameter, string pattern, RegexOptions regexOptions, string exceptionMessage)
{
parameter = parameter.IsNotNull(exceptionMessage);
if (Regex.IsMatch(parameter.Value, pattern, regexOptions))
{
return(parameter);
}
if (string.IsNullOrWhiteSpace(exceptionMessage))
{
exceptionMessage = string.Format(
"String does not match the expected pattern. Pattern:<{0}> Actual:<{1}>.",
pattern,
parameter.Value);
}
throw new ArgumentException(exceptionMessage, parameter.ParameterName);
}