public static StringBuilder GetFormatedDateTimeForFilename(this StringBuilder sb, DateTime value)
{
sb.Clear();
//sb.ConcatFormat("{0}{1: yyyy-MM-dd HH:mm:ss.fff}{2}", before, value, after);
sb.Concat(value.Year, 0, '0', 10, false);
sb.Concat(value.Month, 2);
sb.Concat(value.Day, 2);
sb.Append("_");
sb.Concat(value.Hour, 2);
sb.Concat(value.Minute, 2);
sb.Concat(value.Second, 2);
return(sb);
}
public static StringBuilder GetFormatedDateTimeOffset(this StringBuilder sb, string before, DateTime value, string after = "")
{
sb.Clear();
//sb.ConcatFormat("{0}{1: yyyy-MM-dd HH:mm:ss.fff}{2}", before, value, after);
sb.Append(before);
sb.Concat(value.Year, 4, '0', 10, false);
sb.Append("-");
sb.Concat(value.Month, 2);
sb.Append("-");
sb.Concat(value.Day, 2);
sb.Append(" ");
sb.Concat(value.Hour, 2);
sb.Append(":");
sb.Concat(value.Minute, 2);
sb.Append(":");
sb.Concat(value.Second, 2);
sb.Append(".");
sb.Concat(value.Millisecond, 3);
sb.Append(after);
return(sb);
}
//! Convert a given unsigned integer value to a string and concatenate onto the stringbuilder. Assume base ten.
public static StringBuilder Concat(this StringBuilder string_builder, uint uint_val, uint pad_amount, char pad_char)
{
string_builder.Concat(uint_val, pad_amount, pad_char, 10, true);
return(string_builder);
}
//! Convert a given unsigned integer value to a string and concatenate onto the stringbuilder. Assume no padding and base ten.
public static StringBuilder Concat(this StringBuilder string_builder, uint uint_val)
{
string_builder.Concat(uint_val, 0, ms_default_pad_char, 10, true);
return(string_builder);
}
//! Convert a given float value to a string and concatenate onto the stringbuilder.
public static StringBuilder Concat(this StringBuilder string_builder, double double_val, uint decimal_places, uint pad_amount)
{
string_builder.Concat(double_val, decimal_places, pad_amount, ms_default_pad_char, false);
return(string_builder);
}
//! Convert a given float value to a string and concatenate onto the stringbuilder. Assumes five decimal places, and no padding.
public static StringBuilder Concat(this StringBuilder string_builder, double double_val)
{
string_builder.Concat(double_val, ms_default_decimal_places, 0, ms_default_pad_char, false);
return(string_builder);
}
//! Convert a given float value to a string and concatenate onto the stringbuilder
public static StringBuilder Concat(this StringBuilder string_builder, double double_val, uint decimal_places, uint pad_amount, char pad_char, bool thousandSeparator)
{
Debug.Assert(pad_amount >= 0);
if (decimal_places == 0)
{
// No decimal places, just round up and print it as an int
// Agh, Math.Floor() just works on doubles/decimals. Don't want to cast! Let's do this the old-fashioned way.
long int_val;
if (double_val >= 0.0)
{
// Round up
int_val = (long)(double_val + 0.5);
}
else
{
// Round down for negative numbers
int_val = (long)(double_val - 0.5);
}
string_builder.Concat(int_val, pad_amount, pad_char, 10, thousandSeparator);
}
else
{
double add = 0.5;
for (int i = 0; i < decimal_places; i++)
{
add *= 0.1f;
}
double_val += double_val >= 0 ? add : -add;
int int_part = (int)double_val;
if (int_part == 0 && double_val < 0)
{
string_builder.Append('-');
}
// First part is easy, just cast to an integer
string_builder.Concat(int_part, pad_amount, pad_char, 10, thousandSeparator);
// Decimal point
string_builder.Append('.');
// Work out remainder we need to print after the d.p.
double remainder = Math.Abs(double_val - int_part);
uint tmp = decimal_places;
// Multiply up to become an int that we can print
do
{
remainder *= 10;
tmp--;
}while (tmp > 0);
// Round up. It's guaranteed to be a positive number, so no extra work required here.
//remainder += 0.5f;
// All done, print that as an int!
string_builder.Concat((uint)remainder, decimal_places, '0', 10, thousandSeparator);
}
return(string_builder);
}
//! Convert a given float value to a string and concatenate onto the stringbuilder. Assumes no padding.
public static StringBuilder Concat(this StringBuilder string_builder, float float_val, uint decimal_places)
{
string_builder.Concat(float_val, decimal_places, 0, ms_default_pad_char, false);
return(string_builder);
}
//! Convert a given signed integer value to a string and concatenate onto the stringbuilder. Assume base ten.
public static StringBuilder Concat(this StringBuilder string_builder, int int_val, uint pad_amount)
{
string_builder.Concat(int_val, pad_amount, ms_default_pad_char, 10, true);
return(string_builder);
}
//! The worker method. This does a garbage-free conversion of a generic type, and uses the garbage-free Concat() to add to the stringbuilder
private static void ConcatFormatValue <T>(this StringBuilder string_builder, T arg, uint padding, uint base_value, uint decimal_places, bool thousandSeparation) where T : IConvertible
{
switch (arg.GetTypeCode())
{
case System.TypeCode.Boolean:
{
if (arg.ToBoolean(CultureInfo.InvariantCulture))
{
string_builder.Append("true");
}
else
{
string_builder.Append("false");
}
break;
}
case System.TypeCode.UInt32:
{
string_builder.Concat(arg.ToUInt32(NumberFormatInfo.InvariantInfo), padding, '0', base_value, thousandSeparation);
break;
}
case System.TypeCode.Int32:
{
string_builder.Concat(arg.ToInt32(NumberFormatInfo.InvariantInfo), padding, '0', base_value, thousandSeparation);
break;
}
case System.TypeCode.Int64:
{
string_builder.Concat(arg.ToInt64(NumberFormatInfo.InvariantInfo), padding, '0', base_value, thousandSeparation);
break;
}
case System.TypeCode.UInt64:
{
string_builder.Concat(arg.ToInt32(NumberFormatInfo.InvariantInfo), padding, '0', base_value, thousandSeparation);
break;
}
case System.TypeCode.Single:
{
string_builder.Concat(arg.ToSingle(NumberFormatInfo.InvariantInfo), decimal_places, padding, '0', false);
break;
}
case System.TypeCode.Double:
{
string_builder.Concat(arg.ToDouble(NumberFormatInfo.InvariantInfo), decimal_places, padding, '0', false);
break;
}
case System.TypeCode.Decimal:
{
string_builder.Concat(arg.ToSingle(NumberFormatInfo.InvariantInfo), decimal_places, padding, '0', false);
break;
}
case System.TypeCode.String:
{
string_builder.Append(arg.ToString());
break;
}
default:
{
Debug.Assert(false, "Unknown parameter type");
break;
}
}
}