public static NameValueCollection SetList <T>(this NameValueCollection q, string name, T[] values, bool throwExceptions, params int[] allowedSizes) where T : struct, IConvertible
{
if (values == null)
{
q.Remove(name);
return(q);
}
bool flag = allowedSizes.Length == 0;
foreach (int allowedSize in allowedSizes)
{
if (allowedSize == values.Length)
{
flag = true;
}
}
if (!flag)
{
if (throwExceptions)
{
throw new ArgumentOutOfRangeException(nameof(values), "The specified array is not a valid length. Valid lengths are " + NameValueCollectionExtensions.JoinPrimitives <int>(allowedSizes, ','));
}
return(q);
}
q[name] = NameValueCollectionExtensions.JoinPrimitives <T>(values, ',');
return(q);
}
/// <summary>
/// Provides culture-invariant serialization of value types, in lower case for querystring readability. Setting a key to null removes it.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="q"></param>
/// <param name="name"></param>
/// <param name="val"></param>
/// <returns></returns>
public static NameValueCollection Set <T>(this NameValueCollection q, string name, T?val) where T : struct, IConvertible
{
if (!val.HasValue)
{
q.Remove(name);
}
else
{
q[name] = NameValueCollectionExtensions.SerializePrimitive <T>(val);
}
return(q);
}
private static string JoinPrimitives <T>(T[] array, char delimiter) where T : struct, IConvertible
{
StringBuilder stringBuilder = new StringBuilder();
for (int index = 0; index < array.Length; ++index)
{
stringBuilder.Append(NameValueCollectionExtensions.SerializePrimitive <T>(new T?(array[index])));
if (index < array.Length - 1)
{
stringBuilder.Append(delimiter);
}
}
return(stringBuilder.ToString());
}
/// <summary>
/// Parses a comma-delimited list of primitive values. If there are unparsable items in the list, they will be replaced with 'fallbackValue'. If fallbackValue is null, the function will return null
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="text"></param>
/// <param name="fallbackValue"></param>
/// <param name="allowedSizes"></param>
/// <returns></returns>
public static T[] ParseList <T>(string text, T?fallbackValue, params int[] allowedSizes) where T : struct, IConvertible
{
if (text == null)
{
return((T[])null);
}
text = text.Trim(' ', '(', ')', ',');
if (text.Length == 0)
{
return((T[])null);
}
string[] strArray = text.Split(new char[1] {
','
}, StringSplitOptions.None);
bool flag = allowedSizes.Length == 0;
foreach (int allowedSize in allowedSizes)
{
if (allowedSize == strArray.Length)
{
flag = true;
}
}
if (!flag)
{
return((T[])null);
}
T[] objArray = new T[strArray.Length];
for (int index = 0; index < strArray.Length; ++index)
{
T?primitive = NameValueCollectionExtensions.ParsePrimitive <T>(strArray[index], fallbackValue);
if (!primitive.HasValue)
{
return((T[])null);
}
objArray[index] = primitive.Value;
}
return(objArray);
}
/// <summary>
/// Provides culture-invariant parsing of int, double, float, bool, and enum values.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="q"></param>
/// <param name="name"></param>
/// <param name="defaultValue"></param>
/// <returns></returns>
public static T Get <T>(this NameValueCollection q, string name, T defaultValue) where T : struct, IConvertible
{
return(NameValueCollectionExtensions.ParsePrimitive <T>(q[name], new T?(defaultValue)).Value);
}
public static T[] GetList <T>(this NameValueCollection q, string name, T?fallbackValue, params int[] allowedSizes) where T : struct, IConvertible
{
return(NameValueCollectionExtensions.ParseList <T>(q[name], fallbackValue, allowedSizes));
}
/// <summary>
/// Provides culture-invariant serialization of value types, in lower case for querystring readability. Setting a key to null removes it.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="name"></param>
/// <param name="val"></param>
/// <returns></returns>
public TK Set <T>(string name, T?val) where T : struct, IConvertible
{
return((TK)NameValueCollectionExtensions.Set <T>(this, name, val));
}
/// <summary>
/// Serializes the given value by calling .ToString(). If the value is null, the key is removed.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="name"></param>
/// <param name="val"></param>
/// <returns></returns>
public TK SetAsString <T>(string name, T val) where T : class
{
return((TK)NameValueCollectionExtensions.SetAsString <T>(this, name, val));
}
/// <summary>
/// Provides culture-invariant parsing of byte, int, double, float, bool, and enum values.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="name"></param>
/// <param name="defaultValue"></param>
/// <returns></returns>
public T?Get <T>(string name, T?defaultValue) where T : struct, IConvertible
{
return(NameValueCollectionExtensions.ParsePrimitive <T>(this[name], defaultValue));
}