public static int?ToNullableInt(object value)
{
int?convertedValue;
if (CheckHelper.IsFilled(value))
{
if (value is int || value.GetType().IsEnum)
{
convertedValue = (int)value;
}
else
{
int temp;
var stringValue = value.ToString();
int.TryParse(stringValue, out temp);
convertedValue = temp;
}
}
else
{
convertedValue = null;
}
return(convertedValue);
}
public static DateTime?ToDateTime(object value, bool invariantCulture = false)
{
DateTime?retVal = null;
if (CheckHelper.IsFilled(value))
{
if (value is DateTime)
{
retVal = (DateTime)value;
}
else
{
DateTime dateValue;
if (invariantCulture)
{
DateTime.TryParse(value.ToString(), DateTimeFormatInfo.InvariantInfo, DateTimeStyles.None, out dateValue);
}
else
{
DateTime.TryParse(value.ToString(), out dateValue);
}
retVal = dateValue;
}
}
return(retVal);
}
public static double?ToNullableDouble(object value)
{
double?convertedValue;
if (CheckHelper.IsFilled(value))
{
if (value is decimal)
{
convertedValue = (double)value;
}
else
{
double temp;
var stringValue = value.ToString();
double.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out temp);
convertedValue = temp;
}
}
else
{
convertedValue = null;
}
return(convertedValue);
}
/// <summary>
/// Method converts object to double
/// </summary>
/// <param name="value">Value to be converted </param>
/// <param name="invariantCulture">True to enable conversion culture-independent (insensitive)</param>
/// <returns>Converted value</returns>
public static double ToDouble(object value, bool invariantCulture = false)
{
double convertedValue = 0.0;
if (CheckHelper.IsFilled(value))
{
if (value is double)
{
convertedValue = (double)value;
}
else
{
string stringValue = value.ToString();
if (invariantCulture)
{
double.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out convertedValue);
}
else
{
double.TryParse(stringValue, out convertedValue);
}
}
}
return(convertedValue);
}
public static bool ToBoolean(string value)
{
if (CheckHelper.IsFilled(value) && string.Equals(value, "true", StringComparison.CurrentCultureIgnoreCase))
{
return(true);
}
return(false);
}
public static object IfNullReturnDBNullValue(object value)
{
if (CheckHelper.IsFilled(value))
{
return(value);
}
return(DBNull.Value);
}
public static object IfNullReturnNull(object value)
{
if (CheckHelper.IsFilled(value))
{
return(value);
}
return(null);
}
/// <summary>
/// Method is used so we don't have to write multiple if statements when checking for nulls
/// </summary>
/// <typeparam name="TInput"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="obj"></param>
/// <param name="evaluator"></param>
/// <returns></returns>
public static TResult With <TInput, TResult>(this TInput obj, Func <TInput, TResult> evaluator)
where TInput : class
{
if (CheckHelper.IsFilled(obj))
{
return(evaluator(obj));
}
return(default(TResult));
}
public static byte[] ToBytes(object value)
{
byte[] convertedValue = null;
if (CheckHelper.IsFilled(value))
{
convertedValue = value as byte[];
}
return(convertedValue);
}
public static int ToInt(string value)
{
int convertedValue = 0;
if (CheckHelper.IsFilled(value))
{
int.TryParse(value, out convertedValue);
}
return(convertedValue);
}
public static T?ToEnum <T>(object value) where T : struct, IConvertible
{
T result;
if (CheckHelper.IsFilled(value) && Enum.TryParse(value.ToString(), true, out result))
{
return(result);
}
return(null);
}
public static string ToString(object value)
{
string stringValue = string.Empty;
if (CheckHelper.IsFilled(value))
{
stringValue = value.ToString();
}
return(stringValue);
}
public static string ByteArrayToHexString(byte[] value)
{
string retVal = string.Empty;
if (CheckHelper.IsFilled(value))
{
retVal = string.Concat(Array.ConvertAll(value, x => x.ToString("x2")));
}
return(retVal);
}
public static string ToString(double value, bool emptyStringForZero = false)
{
string stringValue;
if (emptyStringForZero && !CheckHelper.IsFilled(value))
{
stringValue = string.Empty;
}
else
{
stringValue = ToLongString(value);
}
return(stringValue);
}
public static byte[] HexStringToByteArray(string value)
{
byte[] retVal = null;
if (CheckHelper.IsFilled(value))
{
int numberChars = value.Length;
retVal = new byte[numberChars / 2];
for (int i = 0; i < numberChars; i += 2)
{
retVal[i / 2] = Convert.ToByte(value.Substring(i, 2), 16);
}
}
return(retVal);
}
public static DateTime?ToDateTime(string value, string format, string cultureCode)
{
DateTime?retVal = null;
if (CheckHelper.IsFilled(value))
{
DateTime convertedValue;
if (DateTime.TryParseExact(value, format, CultureInfo.CreateSpecificCulture(cultureCode), DateTimeStyles.None, out convertedValue))
{
retVal = convertedValue;
}
}
return(retVal);
}
public static DateTime ToDBDateTime(DateTime?value)
{
DateTime dateValue;
if (CheckHelper.IsFilled(value))
{
dateValue = value.Value;
}
else
{
dateValue = NullTime;
}
return(dateValue);
}
public static DateTime?ToDateTime(string value, string format)
{
DateTime?retVal = null;
if (CheckHelper.IsFilled(value))
{
DateTime convertedValue;
if (DateTime.TryParseExact(value, format, null, DateTimeStyles.None, out convertedValue))
{
retVal = convertedValue;
}
}
return(retVal);
}
public static int ToInt(object value)
{
int convertedValue = 0;
if (CheckHelper.IsFilled(value))
{
if (value is int || value.GetType().IsEnum)
{
convertedValue = (int)value;
}
else
{
string stringValue = value.ToString();
int.TryParse(stringValue, out convertedValue);
}
}
return(convertedValue);
}
public static decimal ToDecimal(object value)
{
decimal convertedValue = 0.0m;
if (CheckHelper.IsFilled(value))
{
if (value is decimal)
{
convertedValue = (decimal)value;
}
else
{
string stringValue = value.ToString().Replace("'", string.Empty);
decimal.TryParse(stringValue, NumberStyles.Any, CultureInfo.InvariantCulture, out convertedValue);
}
}
return(convertedValue);
}
public static float ToFloat(object value)
{
float convertedValue = 0.0f;
if (CheckHelper.IsFilled(value))
{
if (value is float)
{
convertedValue = (float)value;
}
else
{
string stringValue = value.ToString();
float.TryParse(stringValue, out convertedValue);
}
}
return(convertedValue);
}
public static long ToLong(object value)
{
long convertedValue = 0;
if (CheckHelper.IsFilled(value))
{
if (value is long)
{
convertedValue = (long)value;
}
else
{
string stringValue = value.ToString();
long.TryParse(stringValue, out convertedValue);
}
}
return(convertedValue);
}
public static Tuple <DateTime, DateTime> ToDateTimeRange(string daterange, string format)
{
Tuple <DateTime, DateTime> retVal = null;
var dates = daterange.Split('-');
if (dates.Length > 1)
{
DateTime?dateFrom = ToDateTime(dates[0].Trim(), format);
DateTime?dateTo = ToDateTime(dates[1].Trim(), format);
if (CheckHelper.IsFilled(dateFrom) &&
CheckHelper.IsFilled(dateTo))
{
retVal = new Tuple <DateTime, DateTime>(dateFrom.Value, dateTo.Value);
}
}
return(retVal);
}
public static string ToApiString(string value)
{
return(CheckHelper.IsFilled(value)
? value
: null);
}
