public static int DatePart(string Interval, object DateValue, FirstDayOfWeek DayOfWeek = 1, FirstWeekOfYear WeekOfYear = 1)
{
DateTime time;
try
{
time = Conversions.ToDate(DateValue);
}
catch (StackOverflowException exception)
{
throw exception;
}
catch (OutOfMemoryException exception2)
{
throw exception2;
}
catch (ThreadAbortException exception3)
{
throw exception3;
}
catch (Exception)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[] { "DateValue" }));
}
return DatePart(DateIntervalFromString(Interval), time, DayOfWeek, WeekOfYear);
}
public static int DatePart(string Interval, object DateValue,
[Optional, DefaultParameterValue(FirstDayOfWeek.Sunday)] FirstDayOfWeek DayOfWeek,
[Optional, DefaultParameterValue(FirstWeekOfYear.Jan1)] FirstWeekOfYear WeekOfYear)
{
DateTime time;
try
{
time = Conversions.ToDate(DateValue);
}
catch (StackOverflowException exception)
{
throw exception;
}
catch (OutOfMemoryException exception2)
{
throw exception2;
}
catch (ThreadAbortException exception3)
{
throw exception3;
}
catch (Exception)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[] { "DateValue" }));
}
return(DatePart(DateIntervalFromString(Interval), time, DayOfWeek, WeekOfYear));
}
// Get the difference between two dates.
public static long DateDiff
(DateInterval Interval, DateTime Date1, DateTime Date2,
[Optional][DefaultValue(FirstDayOfWeek.Sunday)]
FirstDayOfWeek DayOfWeek,
[Optional][DefaultValue(FirstWeekOfYear.Jan1)]
FirstWeekOfYear WeekOfYear)
{
Calendar calendar = CultureInfo.CurrentCulture.Calendar;
switch (Interval)
{
case DateInterval.Year:
return(calendar.GetYear(Date2) -
calendar.GetYear(Date1));
case DateInterval.Quarter:
return((calendar.GetYear(Date2) -
calendar.GetYear(Date1)) * 4 +
((calendar.GetMonth(Date2) - 1) / 3) -
((calendar.GetMonth(Date1) - 1) / 3));
case DateInterval.Month:
return((calendar.GetYear(Date2) -
calendar.GetYear(Date1)) * 12 +
calendar.GetMonth(Date2) -
calendar.GetMonth(Date1));
case DateInterval.DayOfYear:
case DateInterval.Day:
return(AdjustDiff(Date2.Ticks - Date1.Ticks,
TimeSpan.TicksPerDay));
case DateInterval.WeekOfYear:
{
Date1.AddDays(-Weekday(Date1, DayOfWeek));
Date2.AddDays(-Weekday(Date2, DayOfWeek));
return(AdjustDiff(Date2.Ticks - Date1.Ticks,
TimeSpan.TicksPerDay * 7));
}
// Not reached.
case DateInterval.Weekday:
return(AdjustDiff(Date2.Ticks - Date1.Ticks,
TimeSpan.TicksPerDay * 7));
case DateInterval.Hour:
return(AdjustDiff(Date2.Ticks - Date1.Ticks,
TimeSpan.TicksPerHour));
case DateInterval.Minute:
return(AdjustDiff(Date2.Ticks - Date1.Ticks,
TimeSpan.TicksPerMinute));
case DateInterval.Second:
return(AdjustDiff(Date2.Ticks - Date1.Ticks,
TimeSpan.TicksPerSecond));
}
throw new ArgumentException
(S._("VB_InvalidInterval"), "Interval");
}
public static int GetWeekNumber(DateTime date, DayOfWeek firstDayOfWeek, FirstWeekOfYear firstWeekOfYear)
{
// First four-day week of the year - minumum days count
int fourDayWeek = 4;
return(firstWeekOfYear switch
{
FirstWeekOfYear.FirstFullWeek => GetWeekOfYearFullDays(date, firstDayOfWeek, 7),
FirstWeekOfYear.FirstFourDayWeek => GetWeekOfYearFullDays(date, firstDayOfWeek, fourDayWeek),
_ => GetFirstDayWeekOfYear(date, firstDayOfWeek),
});
public static int DatePart
(String Interval, Object DateValue,
[Optional][DefaultValue(FirstDayOfWeek.Sunday)]
FirstDayOfWeek FirstDayOfWeekValue,
[Optional][DefaultValue(FirstWeekOfYear.Jan1)]
FirstWeekOfYear FirstWeekOfYearValue)
{
return(DatePart(StringToInterval(Interval),
DateType.FromObject(DateValue),
FirstDayOfWeekValue, FirstWeekOfYearValue));
}
public static long DateDiff
(String Interval, Object Date1, Object Date2,
[Optional][DefaultValue(FirstDayOfWeek.Sunday)]
FirstDayOfWeek DayOfWeek,
[Optional][DefaultValue(FirstWeekOfYear.Jan1)]
FirstWeekOfYear WeekOfYear)
{
return(DateDiff(StringToInterval(Interval),
DateType.FromObject(Date1),
DateType.FromObject(Date2),
DayOfWeek, WeekOfYear));
}
/// <summary>
/// Implementation of DatePart where DateValue is an object, in some cases this function is
/// expected to return null which is not done by Microsoft.VisualBasic.DateAndTime.DatePart.
/// </summary>
/// <param name="Interval">DateInterval enumeration value or String expression representing
/// the part of the date/time value you want to return.
/// </param>
/// <param name="DateValue">Date value that you want to evaluate.</param>
/// <param name="DayOfWeek">A value chosen from the FirstDayOfWeek enumeration that specifies
/// the first day of the week. If not specified, FirstDayOfWeek.Sunday is used.</param>
/// <param name="WeekOfYear">A value chosen from the FirstWeekOfYear enumeration that specifies
/// the first week of the year. If not specified, FirstWeekOfYear.Jan1 is used.</param>
/// <returns>Returns an Integer value containing the specified component of a given Date value
/// or null if DateValue is null.</returns>
public static object DatePart(string Interval, object DateValue, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear)
{
if (DateValue == null)
return null;
if (Convert.IsDBNull(DateValue))
return null;
if ((DateValue is string) && (string.IsNullOrEmpty((string)DateValue)))
return null;
return Microsoft.VisualBasic.DateAndTime.DatePart(Interval, Convert.ToDateTime(DateValue), DayOfWeek, WeekOfYear);
}
public static long DateDiff(
DateInterval Interval, DateTime Date1, DateTime Date2,
[Optional, DefaultParameterValue(FirstDayOfWeek.Sunday)]
FirstDayOfWeek DayOfWeek,
[Optional, DefaultParameterValue(FirstWeekOfYear.Jan1)]
FirstWeekOfYear WeekOfYear)
{
Calendar currentCalendar;
TimeSpan span = Date2.Subtract(Date1);
switch (Interval)
{
case DateInterval.Year:
currentCalendar = CurrentCalendar;
return((long)(currentCalendar.GetYear(Date2) - currentCalendar.GetYear(Date1)));
case DateInterval.Quarter:
currentCalendar = CurrentCalendar;
return((long)((((currentCalendar.GetYear(Date2) - currentCalendar.GetYear(Date1)) * 4) + ((currentCalendar.GetMonth(Date2) - 1) / 3)) - ((currentCalendar.GetMonth(Date1) - 1) / 3)));
case DateInterval.Month:
currentCalendar = CurrentCalendar;
return((long)((((currentCalendar.GetYear(Date2) - currentCalendar.GetYear(Date1)) * 12) + currentCalendar.GetMonth(Date2)) - currentCalendar.GetMonth(Date1)));
case DateInterval.DayOfYear:
case DateInterval.Day:
return((long)Math.Round(Conversion.Fix(span.TotalDays)));
case DateInterval.WeekOfYear:
Date1 = Date1.AddDays((double)(0 - GetDayOfWeek(Date1, DayOfWeek)));
Date2 = Date2.AddDays((double)(0 - GetDayOfWeek(Date2, DayOfWeek)));
return(((long)Math.Round(Conversion.Fix(Date2.Subtract(Date1).TotalDays))) / 7L);
case DateInterval.Weekday:
return(((long)Math.Round(Conversion.Fix(span.TotalDays))) / 7L);
case DateInterval.Hour:
return((long)Math.Round(Conversion.Fix(span.TotalHours)));
case DateInterval.Minute:
return((long)Math.Round(Conversion.Fix(span.TotalMinutes)));
case DateInterval.Second:
return((long)Math.Round(Conversion.Fix(span.TotalSeconds)));
}
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Interval" }));
}
public static int GetWeekNumber(DateTime date, DayOfWeek firstDayOfWeek, FirstWeekOfYear firstWeekOfYear)
{
// First four-day week of the year - minumum days count
int fourDayWeek = 4;
switch (firstWeekOfYear)
{
case FirstWeekOfYear.FirstFullWeek:
return(GetWeekOfYearFullDays(date, firstDayOfWeek, 7));
case FirstWeekOfYear.FirstFourDayWeek:
return(GetWeekOfYearFullDays(date, firstDayOfWeek, fourDayWeek));
default:
return(GetFirstDayWeekOfYear(date, firstDayOfWeek));
}
}
public static long DateDiff(DateInterval Interval, DateTime Date1, DateTime Date2, FirstDayOfWeek DayOfWeek = 1, FirstWeekOfYear WeekOfYear = 1)
{
Calendar currentCalendar;
TimeSpan span = Date2.Subtract(Date1);
switch (Interval)
{
case DateInterval.Year:
currentCalendar = CurrentCalendar;
return (long) (currentCalendar.GetYear(Date2) - currentCalendar.GetYear(Date1));
case DateInterval.Quarter:
currentCalendar = CurrentCalendar;
return (long) ((((currentCalendar.GetYear(Date2) - currentCalendar.GetYear(Date1)) * 4) + ((currentCalendar.GetMonth(Date2) - 1) / 3)) - ((currentCalendar.GetMonth(Date1) - 1) / 3));
case DateInterval.Month:
currentCalendar = CurrentCalendar;
return (long) ((((currentCalendar.GetYear(Date2) - currentCalendar.GetYear(Date1)) * 12) + currentCalendar.GetMonth(Date2)) - currentCalendar.GetMonth(Date1));
case DateInterval.DayOfYear:
case DateInterval.Day:
return (long) Math.Round(Conversion.Fix(span.TotalDays));
case DateInterval.WeekOfYear:
Date1 = Date1.AddDays((double) (0 - GetDayOfWeek(Date1, DayOfWeek)));
Date2 = Date2.AddDays((double) (0 - GetDayOfWeek(Date2, DayOfWeek)));
return (((long) Math.Round(Conversion.Fix(Date2.Subtract(Date1).TotalDays))) / 7L);
case DateInterval.Weekday:
return (((long) Math.Round(Conversion.Fix(span.TotalDays))) / 7L);
case DateInterval.Hour:
return (long) Math.Round(Conversion.Fix(span.TotalHours));
case DateInterval.Minute:
return (long) Math.Round(Conversion.Fix(span.TotalMinutes));
case DateInterval.Second:
return (long) Math.Round(Conversion.Fix(span.TotalSeconds));
}
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Interval" }));
}
public static int DatePart(string Interval, object DateValue, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear)
{
}
public static List <int> GetWeekNumbersInMonth(int weeksInMonth, DayOfWeek firstDayOfWeek, FirstWeekOfYear firstWeekOfYear, DateTime navigatedDate)
{
int selectedYear = navigatedDate.Year;
int selectedMonth = navigatedDate.Month;
int daysInMonth = DateTime.DaysInMonth(selectedYear, selectedMonth);
int dayOfMonth = 1;
DateTime fistDayOfMonth = new(selectedYear, selectedMonth, dayOfMonth);
DayOfWeek endOfFirstWeek = dayOfMonth + (firstDayOfWeek + 7 - 1) - AdjustWeekDay(firstDayOfWeek, fistDayOfMonth.DayOfWeek);
DateTime endOfWeekRange = new(selectedYear, selectedMonth, (int)endOfFirstWeek);
dayOfMonth = endOfWeekRange.Day;
List <int>?weeksArray = new();
for (int i = 0; i < weeksInMonth; i++)
{
// Get week number for end of week
weeksArray.Add(GetWeekNumber(endOfWeekRange, firstDayOfWeek, firstWeekOfYear));
dayOfMonth += 7;
if (dayOfMonth > daysInMonth)
{
dayOfMonth = daysInMonth;
}
endOfWeekRange = new DateTime(selectedYear, selectedMonth, dayOfMonth);
}
return(weeksArray);
}
public static int DatePart(DateInterval Interval,
DateTime DateValue,
[Optional, DefaultParameterValue(FirstDayOfWeek.Sunday)]
FirstDayOfWeek FirstDayOfWeekValue,
[Optional, DefaultParameterValue(FirstWeekOfYear.Jan1)]
FirstWeekOfYear FirstWeekOfYearValue)
{
DayOfWeek firstDayOfWeek;
CalendarWeekRule calendarWeekRule = 0;
switch (Interval)
{
case DateInterval.Year:
return(CurrentCalendar.GetYear(DateValue));
case DateInterval.Quarter:
return(((DateValue.Month - 1) / 3) + 1);
case DateInterval.Month:
return(CurrentCalendar.GetMonth(DateValue));
case DateInterval.DayOfYear:
return(CurrentCalendar.GetDayOfYear(DateValue));
case DateInterval.Day:
return(CurrentCalendar.GetDayOfMonth(DateValue));
case DateInterval.WeekOfYear:
if (FirstDayOfWeekValue != FirstDayOfWeek.System)
{
firstDayOfWeek = (DayOfWeek)(FirstDayOfWeekValue - 1);
break;
}
firstDayOfWeek = Utils.GetCultureInfo().DateTimeFormat.FirstDayOfWeek;
break;
case DateInterval.Weekday:
return(Weekday(DateValue, FirstDayOfWeekValue));
case DateInterval.Hour:
return(CurrentCalendar.GetHour(DateValue));
case DateInterval.Minute:
return(CurrentCalendar.GetMinute(DateValue));
case DateInterval.Second:
return(CurrentCalendar.GetSecond(DateValue));
default:
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Interval" }));
}
switch (FirstWeekOfYearValue)
{
case FirstWeekOfYear.System:
calendarWeekRule = Utils.GetCultureInfo().DateTimeFormat.CalendarWeekRule;
break;
case FirstWeekOfYear.Jan1:
calendarWeekRule = CalendarWeekRule.FirstDay;
break;
case FirstWeekOfYear.FirstFourDays:
calendarWeekRule = CalendarWeekRule.FirstFourDayWeek;
break;
case FirstWeekOfYear.FirstFullWeek:
calendarWeekRule = CalendarWeekRule.FirstFullWeek;
break;
}
return(CurrentCalendar.GetWeekOfYear(DateValue, calendarWeekRule, firstDayOfWeek));
}
/// <summary>Returns an <see langword="Integer" /> value containing the specified component of a given <see langword="Date" /> value.</summary>
/// <param name="Interval">Required. <see langword="DateInterval" /> enumeration value or <see langword="String" /> expression representing the part of the date/time value you want to return.</param>
/// <param name="DateValue">Required. <see langword="Date" /> value that you want to evaluate.</param>
/// <param name="DayOfWeek">Optional. A value chosen from the <see langword="FirstDayOfWeek" /> enumeration that specifies the first day of the week. If not specified, <see langword="FirstDayOfWeek.Sunday" /> is used.</param>
/// <param name="WeekOfYear">Optional. A value chosen from the <see langword="FirstWeekOfYear" /> enumeration that specifies the first week of the year. If not specified, <see langword="FirstWeekOfYear.Jan1" /> is used.</param>
/// <returns>Returns an <see langword="Integer" /> value containing the specified component of a given <see langword="Date" /> value.</returns>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="Interval" /> is invalid. </exception>
/// <exception cref="T:System.InvalidCastException">
/// <paramref name="DateValue" /> is not coercible to <see langword="Date" />.</exception>
public static int DatePart(string Interval, object DateValue, FirstDayOfWeek DayOfWeek = FirstDayOfWeek.Sunday, FirstWeekOfYear WeekOfYear = FirstWeekOfYear.Jan1)
{
DateTime date;
try
{
date = Conversions.ToDate(DateValue);
}
catch (StackOverflowException ex)
{
throw ex;
}
catch (OutOfMemoryException ex)
{
throw ex;
}
catch (ThreadAbortException ex)
{
throw ex;
}
catch (Exception ex)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[1]
{
nameof(DateValue)
}));
}
return(DateAndTime.DatePart(DateAndTime.DateIntervalFromString(Interval), date, DayOfWeek, WeekOfYear));
}
private static String FormatDate(object _toFormat, string mask, FirstDayOfWeek dayOfWeek, FirstWeekOfYear weekOfYear)
#endif
{
DateTime input;
if (_toFormat is DateTime)
{
input = (DateTime)_toFormat;
}
else if (_toFormat is string)
{
string str = (string)_toFormat;
#if (NET35)
if (string.IsNullOrEmpty(str) || str.Trim().Length == 0)
#else
if (string.IsNullOrWhiteSpace(str))
#endif
{
return(String.Empty);
}
if (!DateTime.TryParse(str, out input))
{
return((String)_toFormat);
}
}
else
{
input = DateTime.FromOADate(Convert.ToDouble(_toFormat));
}
if (string.Equals(mask, "general date", StringComparison.OrdinalIgnoreCase))
{
if (input.Hour == 0 && input.Minute == 0 && input.Second == 0 && input.Millisecond == 0)
{
mask = "d";
}
else
{
mask = "G";
}
}
else
{
string lowerMask = mask.ToLower();
char[] maskArray = (lowerMask + "\0\0\0\0\0").ToCharArray();
StringBuilder maskBuilder = new StringBuilder();
char lastChar = maskArray[0];
char lastPattern = '\0';
int count = 1;
bool containsAMPM = (lowerMask.Contains("am/pm") || lowerMask.Contains("ampm") || lowerMask.Contains("a/p"));
for (int maskIndex = 1; maskIndex < maskArray.Length; maskIndex++)
{
while (maskArray[maskIndex] == lastChar)
{
count++;
maskIndex++;
}
bool wasPattern = true;
switch (lastChar)
{
case 'a':
if ((maskArray[maskIndex] == 'm' && maskArray[maskIndex + 1] == '/' && maskArray[maskIndex + 2] == 'p' && maskArray[maskIndex + 3] == 'm') ||
(maskArray[maskIndex] == 'm' && maskArray[maskIndex + 1] == 'p' && maskArray[maskIndex + 2] == 'm'))
{
maskBuilder.Append(lastChar, count - 1);
maskBuilder.Append("tt");
maskIndex += (maskArray[maskIndex + 1] == '/') ? 4 : 3;
}
else if (maskArray[maskIndex] == '/' && maskArray[maskIndex + 1] == 'p')
{
maskBuilder.Append(lastChar, count - 1);
maskBuilder.Append("t");
maskIndex += 2;
}
else
{
goto default;
}
break;
case 'h':
if (containsAMPM)
{
maskBuilder.Append('h', count);
}
else
{
maskBuilder.Append('H', count);
}
break;
case 'd':
case 'y':
case 's':
maskBuilder.Append(lastChar, count);
break;
case 'm':
if (lastPattern == 'h')
{
maskBuilder.Append('m', count);
}
else
{
maskBuilder.Append('M', count);
}
break;
case 'n':
maskBuilder.Append('m', count);
break;
case '\\':
int times = count / 2;
int remainder = count % 2;
maskBuilder.Append('\\', times * 2);
if (remainder == 1)
{
maskBuilder.Append(maskArray[maskIndex]);
maskIndex++;
}
break;
default:
for (int c = 0; c < count; c++)
{
maskBuilder.Append('\\');
maskBuilder.Append(lastChar);
}
wasPattern = false;
break;
}
if (wasPattern)
{
lastPattern = lastChar;
}
lastChar = maskArray[maskIndex];
if (lastChar == '\0')
{
break;
}
count = 1;
}
mask = maskBuilder.ToString();
}
return(input.ToString(mask));
}
public static long DateDiff(string Interval, object Date1, object Date2, FirstDayOfWeek DayOfWeek = 1, FirstWeekOfYear WeekOfYear = 1)
{
DateTime time;
DateTime time2;
try
{
time = Conversions.ToDate(Date1);
}
catch (StackOverflowException exception)
{
throw exception;
}
catch (OutOfMemoryException exception2)
{
throw exception2;
}
catch (ThreadAbortException exception3)
{
throw exception3;
}
catch (Exception)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[] { "Date1" }));
}
try
{
time2 = Conversions.ToDate(Date2);
}
catch (StackOverflowException exception4)
{
throw exception4;
}
catch (OutOfMemoryException exception5)
{
throw exception5;
}
catch (ThreadAbortException exception6)
{
throw exception6;
}
catch (Exception)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[] { "Date2" }));
}
return(DateDiff(DateIntervalFromString(Interval), time, time2, DayOfWeek, WeekOfYear));
}
public static String Format(object _toFormat, object _mask, FirstDayOfWeek dayOfWeek, FirstWeekOfYear weekOfYear)
#endif
{
string result = null;
if (_toFormat == null)
{
return(String.Empty);
}
string mask = _mask != null?_mask.ToString() : String.Empty;
if (string.Equals(mask, ">", StringComparison.Ordinal))
{
var str = _toFormat.ToString();
#if (NET35)
result = (string.IsNullOrEmpty(str) || str.Trim().Length == 0) ? String.Empty : str.ToUpper();
#else
result = string.IsNullOrWhiteSpace(str) ? String.Empty : str.ToUpper();
#endif
}
else if (string.Equals(mask, "<", StringComparison.Ordinal))
{
var str = _toFormat.ToString();
#if (NET35)
result = (string.IsNullOrEmpty(str) || str.Trim().Length == 0) ? String.Empty : str.ToLower();
#else
result = string.IsNullOrWhiteSpace(str) ? String.Empty : str.ToLower();
#endif
}
else if (string.Equals(mask, "General Date", StringComparison.OrdinalIgnoreCase))
{
result = FormatDate(_toFormat, mask, dayOfWeek, weekOfYear);
}
else if (string.Equals(mask, "Medium Date", StringComparison.OrdinalIgnoreCase))
{
result = FormatDate(_toFormat, "dd-mmm-yy", dayOfWeek, weekOfYear);
}
else if (string.Equals(mask, "Medium Time", StringComparison.OrdinalIgnoreCase))
{
result = FormatDate(_toFormat, "hh:mm AM/PM", dayOfWeek, weekOfYear);
}
else if (string.Equals(mask, "Short Time", StringComparison.OrdinalIgnoreCase))
{
result = FormatDate(_toFormat, "HH:mm", dayOfWeek, weekOfYear);
}
else if (string.Equals(mask, "General Number", StringComparison.OrdinalIgnoreCase))
{
result = FormatNumber(_toFormat, "G", dayOfWeek, weekOfYear);
}
else if (string.Equals(mask, "Fixed", StringComparison.OrdinalIgnoreCase))
{
result = FormatNumber(_toFormat, "F", dayOfWeek, weekOfYear);
}
else if (string.Equals(mask, "Standard", StringComparison.OrdinalIgnoreCase))
{
result = FormatNumber(_toFormat, "N", dayOfWeek, weekOfYear);
}
else if (string.Equals(mask, "Currency", StringComparison.OrdinalIgnoreCase))
{
result = FormatNumber(_toFormat, "C", dayOfWeek, weekOfYear);
}
else if (string.Equals(mask, "Percent", StringComparison.OrdinalIgnoreCase))
{
result = FormatNumber(_toFormat, "P2", dayOfWeek, weekOfYear);
}
else if (string.Equals(mask, "Scientific", StringComparison.OrdinalIgnoreCase))
{
result = FormatNumber(_toFormat, "0.00E+00", dayOfWeek, weekOfYear);
}
else
{
int maskSize = mask.Length;
for (int i = 0; i < maskSize; i++)
{
var c = mask[i];
switch (c)
{
case '#':
case '0':
result = FormatNumber(_toFormat, mask, dayOfWeek, weekOfYear);
goto truncateFormat;
case '@':
result = FormatString(_toFormat, mask, dayOfWeek, weekOfYear);
goto truncateFormat;
case 'Y':
case 'D':
case 'M':
case 'y':
case 'd':
case 'm':
case 'H':
case 'h':
case 'N':
case 'n':
result = FormatDate(_toFormat, mask, dayOfWeek, weekOfYear);
goto truncateFormat;
}
}
}
#if WPF || WINFORMS
//UpgradeHelpers.Helpers.NotUpgradedHelper.NotifyNotUpgradedElement("VB.Strings.Format");
#endif
if (result == null)
{
result = _toFormat.ToString();
}
// truncates the value to 255, as vb6 does
truncateFormat:
return(Left(result, VBAStringsFormatLimit));
}
public static int DatePart(DateInterval Interval, DateTime DateValue, FirstDayOfWeek FirstDayOfWeekValue = FirstDayOfWeek.Sunday, FirstWeekOfYear FirstWeekOfYearValue = FirstWeekOfYear.Jan1)
{
throw new NotImplementedException();
//return Microsoft.VisualBasic.DateAndTime.DatePart((Microsoft.VisualBasic.DateInterval) Interval, DateValue, (Microsoft.VisualBasic.FirstDayOfWeek) FirstDayOfWeekValue, (Microsoft.VisualBasic.FirstWeekOfYear) FirstWeekOfYearValue);
}
// Get a particular date part.
public static int DatePart
(DateInterval Interval, DateTime DateValue,
[Optional][DefaultValue(FirstDayOfWeek.Sunday)]
FirstDayOfWeek FirstDayOfWeekValue,
[Optional][DefaultValue(FirstWeekOfYear.Jan1)]
FirstWeekOfYear FirstWeekOfYearValue)
{
Calendar calendar = CultureInfo.CurrentCulture.Calendar;
switch (Interval)
{
case DateInterval.Year:
return(calendar.GetYear(DateValue));
case DateInterval.Quarter:
return(((calendar.GetMonth(DateValue) - 1) % 3) + 1);
case DateInterval.Month:
return(calendar.GetMonth(DateValue));
case DateInterval.DayOfYear:
return(calendar.GetDayOfYear(DateValue));
case DateInterval.Day:
return(calendar.GetDayOfMonth(DateValue));
case DateInterval.WeekOfYear:
{
if (FirstDayOfWeekValue == FirstDayOfWeek.System)
{
FirstDayOfWeekValue = SystemFirstDay();
}
CalendarWeekRule rule;
switch (FirstWeekOfYearValue)
{
case FirstWeekOfYear.System:
{
#if !ECMA_COMPAT
rule = CultureInfo.CurrentCulture
.DateTimeFormat.CalendarWeekRule;
#else
rule = CalendarWeekRule.FirstDay;
#endif
}
break;
case FirstWeekOfYear.Jan1:
{
rule = CalendarWeekRule.FirstDay;
}
break;
case FirstWeekOfYear.FirstFourDays:
{
rule = CalendarWeekRule.FirstFourDayWeek;
}
break;
case FirstWeekOfYear.FirstFullWeek:
{
rule = CalendarWeekRule.FirstFullWeek;
}
break;
default:
{
throw new ArgumentException
(S._("VB_InvalidWeekOfYear"),
"FirstWeekOfYearValue");
}
// Not reached.
}
return(calendar.GetWeekOfYear
(DateValue, rule,
(DayOfWeek)(((int)FirstDayOfWeekValue) - 1)));
}
// Not reached.
case DateInterval.Weekday:
return(Weekday(DateValue, FirstDayOfWeekValue));
case DateInterval.Hour:
return(DateValue.Hour);
case DateInterval.Minute:
return(DateValue.Minute);
case DateInterval.Second:
return(DateValue.Second);
}
throw new ArgumentException
(S._("VB_InvalidInterval"), "Interval");
}
public static int DatePart(string Interval, object DateValue, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear) {}
public static long DateDiff(string Interval, object Date1, object Date2, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear) {}
public static int DatePart(DateInterval Interval, System.DateTime DateValue, FirstDayOfWeek FirstDayOfWeekValue, FirstWeekOfYear FirstWeekOfYearValue) {}
public static long DateDiff(DateInterval Interval, System.DateTime Date1, System.DateTime Date2, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear) {}
public static long DateDiff(string Interval, object Date1, object Date2, FirstDayOfWeek DayOfWeek = 1, FirstWeekOfYear WeekOfYear = 1)
{
DateTime time;
DateTime time2;
try
{
time = Conversions.ToDate(Date1);
}
catch (StackOverflowException exception)
{
throw exception;
}
catch (OutOfMemoryException exception2)
{
throw exception2;
}
catch (ThreadAbortException exception3)
{
throw exception3;
}
catch (Exception)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[] { "Date1" }));
}
try
{
time2 = Conversions.ToDate(Date2);
}
catch (StackOverflowException exception4)
{
throw exception4;
}
catch (OutOfMemoryException exception5)
{
throw exception5;
}
catch (ThreadAbortException exception6)
{
throw exception6;
}
catch (Exception)
{
throw new InvalidCastException(Utils.GetResourceString("Argument_InvalidDateValue1", new string[] { "Date2" }));
}
return DateDiff(DateIntervalFromString(Interval), time, time2, DayOfWeek, WeekOfYear);
}
public static int DatePart(DateInterval Interval, DateTime DateValue, FirstDayOfWeek FirstDayOfWeekValue = 1, FirstWeekOfYear FirstWeekOfYearValue = 1)
{
DayOfWeek firstDayOfWeek;
CalendarWeekRule calendarWeekRule;
switch (Interval)
{
case DateInterval.Year:
return CurrentCalendar.GetYear(DateValue);
case DateInterval.Quarter:
return (((DateValue.Month - 1) / 3) + 1);
case DateInterval.Month:
return CurrentCalendar.GetMonth(DateValue);
case DateInterval.DayOfYear:
return CurrentCalendar.GetDayOfYear(DateValue);
case DateInterval.Day:
return CurrentCalendar.GetDayOfMonth(DateValue);
case DateInterval.WeekOfYear:
if (FirstDayOfWeekValue != FirstDayOfWeek.System)
{
firstDayOfWeek = (DayOfWeek) (FirstDayOfWeekValue - 1);
break;
}
firstDayOfWeek = Utils.GetCultureInfo().DateTimeFormat.FirstDayOfWeek;
break;
case DateInterval.Weekday:
return Weekday(DateValue, FirstDayOfWeekValue);
case DateInterval.Hour:
return CurrentCalendar.GetHour(DateValue);
case DateInterval.Minute:
return CurrentCalendar.GetMinute(DateValue);
case DateInterval.Second:
return CurrentCalendar.GetSecond(DateValue);
default:
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Interval" }));
}
switch (FirstWeekOfYearValue)
{
case FirstWeekOfYear.System:
calendarWeekRule = Utils.GetCultureInfo().DateTimeFormat.CalendarWeekRule;
break;
case FirstWeekOfYear.Jan1:
calendarWeekRule = CalendarWeekRule.FirstDay;
break;
case FirstWeekOfYear.FirstFourDays:
calendarWeekRule = CalendarWeekRule.FirstFourDayWeek;
break;
case FirstWeekOfYear.FirstFullWeek:
calendarWeekRule = CalendarWeekRule.FirstFullWeek;
break;
}
return CurrentCalendar.GetWeekOfYear(DateValue, calendarWeekRule, firstDayOfWeek);
}
private static String FormatNumber(object _toFormat, string mask, FirstDayOfWeek dayOfWeek, FirstWeekOfYear weekOfYear)
#endif
{
int intValue = 0;
decimal decimalValue = 0;
bool isInteger = false;
if (_toFormat is DateTime)
{
DateTime dateTime = (DateTime)_toFormat;
decimalValue = new decimal(dateTime.ToOADate());
}
else if (_toFormat is Int32)
{
int toFormatAsInt = (Int32)_toFormat;
intValue = toFormatAsInt;
isInteger = true;
}
else
{
var toFormatAsString = _toFormat.ToString();
#if (NET35)
if (string.IsNullOrEmpty(toFormatAsString) || toFormatAsString.Trim().Length == 0)
#else
if (string.IsNullOrWhiteSpace(toFormatAsString))
#endif
{
return(String.Empty);
}
if (Int32.TryParse(toFormatAsString, out intValue))
{
isInteger = true;
}
else
{
if (!Decimal.TryParse(toFormatAsString, out decimalValue))
{
return(toFormatAsString);
}
}
}
if (mask.Equals("P2", StringComparison.Ordinal))
{
if (isInteger)
{
decimalValue = intValue;
}
return((decimalValue * 100).ToString("F") + "%");
}
return(isInteger ? intValue.ToString(mask, System.Globalization.NumberFormatInfo.CurrentInfo) : decimalValue.ToString(mask, System.Globalization.NumberFormatInfo.CurrentInfo));
}
public static long DateDiff(string Interval, object Date1, object Date2, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear)
{
}
public static long DateDiff(DateInterval Interval, System.DateTime Date1, System.DateTime Date2, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear)
{
}
/// <summary>
/// Returns the String toFormat formatted with the given mask.
/// </summary>
/// <param name="_toFormat">The String object to format.</param>
/// <param name="_mask">The format to apply.</param>
/// <param name="dayOfWeek">A value chosen from the FirstDayOfWeek enumeration that specifies the first day of the week.</param>
/// <param name="weekOfYear">A value chosen from the FirstWeekOfYear enumeration that specifies the first week of the year.</param>
/// <returns>Empty String if toFormat is null or empty, othewise the formatted string.</returns>
public static String Format(object _toFormat, object _mask, FirstDayOfWeek dayOfWeek, FirstWeekOfYear weekOfYear)
{
//if (_toFormat == null) throw new ArgumentNullException("_toFormat");
//if (_mask == null) throw new ArgumentNullException("_mask");
string toFormat = Convert.ToString(_toFormat);
string mask = PreprocessMask(_toFormat, _mask);
DateTime dt;
if (String.IsNullOrEmpty(toFormat))
{
return(String.Empty);
}
else if (_toFormat is decimal)
{
return(((decimal)_toFormat).ToString(mask));
}
else if (_toFormat is double)
{
return(((double)_toFormat).ToString(mask));
}
else if (_toFormat is float)
{
return(((float)_toFormat).ToString(mask));
}
else if (_toFormat is int)
{
return(((int)_toFormat).ToString(mask));
}
else if (_toFormat is byte)
{
return(((byte)_toFormat).ToString(mask));
}
else if (_toFormat is DateTime)
{
return(((DateTime)_toFormat).ToString(mask));
}
else if (DateTime.TryParse(toFormat, out dt))
{
if (mask == "0")
{
return(dt.ToOADate().ToString());
}
else
{
return(dt.ToString(mask));
}
}
#if WPF || WINFORMS
//UpgradeHelpers.Helpers.NotUpgradedHelper.NotifyNotUpgradedElement("VB.Strings.Format");
#endif
return(toFormat);
}
public static int DatePart(DateInterval Interval, System.DateTime DateValue, FirstDayOfWeek FirstDayOfWeekValue, FirstWeekOfYear FirstWeekOfYearValue)
{
}
/// <summary>
/// Returns the String toFormat formatted with the given mask.
/// </summary>
/// <param name="toFormat">The String object to format.</param>
/// <param name="mask">The format to apply.</param>
/// <param name="weekOfYear">A value chosen from the FirstWeekOfYear enumeration that specifies the first week of the year.</param>
/// <returns>Empty String if toFormat is null or empty, othewise the formatted string.</returns>
public static String Format(object toFormat, object mask, FirstWeekOfYear weekOfYear)
{
return(Format(toFormat, mask, FirstDayOfWeek.Sunday, weekOfYear));
}
/// <summary>
/// Implementation of DatePart where DateValue is an object, in some cases this function is
/// expected to return null which is not done by Microsoft.VisualBasic.DateAndTime.DatePart.
/// </summary>
/// <param name="interval">DateInterval enumeration value or String expression representing
/// the part of the date/time value you want to return.
/// </param>
/// <param name="dateValue">Date value that you want to evaluate.</param>
/// <param name="dayOfWeek">A value chosen from the FirstDayOfWeek enumeration that specifies
/// the first day of the week. If not specified, FirstDayOfWeek.Sunday is used.</param>
/// <param name="weekOfYear">A value chosen from the FirstWeekOfYear enumeration that specifies
/// the first week of the year. If not specified, FirstWeekOfYear.Jan1 is used.</param>
/// <returns>Returns an Integer value containing the specified component of a given Date value
/// or null if DateValue is null.</returns>
public static object DatePart(string interval, object dateValue, FirstDayOfWeek dayOfWeek, FirstWeekOfYear weekOfYear)
{
if (dateValue == null)
{
return(null);
}
if (Convert.IsDBNull(dateValue))
{
return(null);
}
if ((dateValue is string) && (string.IsNullOrEmpty((string)dateValue)))
{
return(null);
}
return(DateAndTime.DatePart(interval, Convert.ToDateTime(dateValue), dayOfWeek, weekOfYear));
}
public static long DateDiff(string Interval, object Date1, object Date2, FirstDayOfWeek DayOfWeek = FirstDayOfWeek.Sunday, FirstWeekOfYear WeekOfYear = FirstWeekOfYear.Jan1)
{
throw new NotImplementedException();
//return Microsoft.VisualBasic.DateAndTime.DateDiff(Interval, Date1, Date2, (Microsoft.VisualBasic.FirstDayOfWeek)DayOfWeek, (Microsoft.VisualBasic.FirstWeekOfYear)WeekOfYear);
}
/// <summary>Returns a <see langword="Long" /> value specifying the number of time intervals between two <see langword="Date" /> values.</summary>
/// <param name="Interval">Required. <see langword="DateInterval" /> enumeration value or <see langword="String" /> expression representing the time interval you want to use as the unit of difference between <paramref name="Date1" /> and <paramref name="Date2" />.</param>
/// <param name="Date1">Required. <see langword="Date" />. The first date/time value you want to use in the calculation. </param>
/// <param name="Date2">Required. <see langword="Date" />. The second date/time value you want to use in the calculation.</param>
/// <param name="DayOfWeek">Optional. A value chosen from the <see langword="FirstDayOfWeek" /> enumeration that specifies the first day of the week. If not specified, <see langword="FirstDayOfWeek.Sunday" /> is used.</param>
/// <param name="WeekOfYear">Optional. A value chosen from the <see langword="FirstWeekOfYear" /> enumeration that specifies the first week of the year. If not specified, <see langword="FirstWeekOfYear.Jan1" /> is used.</param>
/// <returns>Returns a <see langword="Long" /> value specifying the number of time intervals between two <see langword="Date" /> values.</returns>
/// <exception cref="T:System.ArgumentException">Invalid <paramref name="Interval" />.</exception>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="Date1" />, <paramref name="Date2" />, or <paramref name="DayofWeek" /> is out of range.</exception>
/// <exception cref="T:System.InvalidCastException">
/// <paramref name="Date1" /> or <paramref name="Date2" /> is of an invalid type.</exception>
public static long DateDiff(DateInterval Interval, DateTime Date1, DateTime Date2, FirstDayOfWeek DayOfWeek = FirstDayOfWeek.Sunday, FirstWeekOfYear WeekOfYear = FirstWeekOfYear.Jan1)
{
TimeSpan timeSpan = Date2.Subtract(Date1);
switch (Interval)
{
case DateInterval.Year:
Calendar currentCalendar1 = DateAndTime.CurrentCalendar;
return((long)checked (currentCalendar1.GetYear(Date2) - currentCalendar1.GetYear(Date1)));
case DateInterval.Quarter:
Calendar currentCalendar2 = DateAndTime.CurrentCalendar;
return((long)checked ((currentCalendar2.GetYear(Date2) - currentCalendar2.GetYear(Date1)) * 4 + unchecked (checked (currentCalendar2.GetMonth(Date2) - 1) / 3) - unchecked (checked (currentCalendar2.GetMonth(Date1) - 1) / 3)));
case DateInterval.Month:
Calendar currentCalendar3 = DateAndTime.CurrentCalendar;
return((long)checked ((currentCalendar3.GetYear(Date2) - currentCalendar3.GetYear(Date1)) * 12 + currentCalendar3.GetMonth(Date2) - currentCalendar3.GetMonth(Date1)));
case DateInterval.DayOfYear:
case DateInterval.Day:
return(checked ((long)Math.Round(Conversion.Fix(timeSpan.TotalDays))));
case DateInterval.WeekOfYear:
Date1 = Date1.AddDays((double)checked (-DateAndTime.GetDayOfWeek(Date1, DayOfWeek)));
Date2 = Date2.AddDays((double)checked (-DateAndTime.GetDayOfWeek(Date2, DayOfWeek)));
return(checked ((long)Math.Round(Conversion.Fix(Date2.Subtract(Date1).TotalDays))) / 7L);
case DateInterval.Weekday:
return(checked ((long)Math.Round(Conversion.Fix(timeSpan.TotalDays))) / 7L);
case DateInterval.Hour:
return(checked ((long)Math.Round(Conversion.Fix(timeSpan.TotalHours))));
case DateInterval.Minute:
return(checked ((long)Math.Round(Conversion.Fix(timeSpan.TotalMinutes))));
case DateInterval.Second:
return(checked ((long)Math.Round(Conversion.Fix(timeSpan.TotalSeconds))));
default:
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[1]
{
nameof(Interval)
}));
}
}
/// <summary>
/// Implementation of DatePart where DateValue is an object, in some cases this function is
/// expected to return null which is not done by Microsoft.VisualBasic.DateAndTime.DatePart.
/// </summary>
/// <param name="Interval">DateInterval enumeration value or String expression representing
/// the part of the date/time value you want to return.
/// </param>
/// <param name="DateValue">Date value that you want to evaluate.</param>
/// <param name="DayOfWeek">A value chosen from the FirstDayOfWeek enumeration that specifies
/// the first day of the week. If not specified, FirstDayOfWeek.Sunday is used.</param>
/// <param name="WeekOfYear">A value chosen from the FirstWeekOfYear enumeration that specifies
/// the first week of the year. If not specified, FirstWeekOfYear.Jan1 is used.</param>
/// <returns>Returns an Integer value containing the specified component of a given Date value
/// or null if DateValue is null.</returns>
public static object DatePart(string Interval, object DateValue, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear)
{
if (DateValue == null)
{
return(null);
}
if (Convert.IsDBNull(DateValue))
{
return(null);
}
if ((DateValue is string) && (string.IsNullOrEmpty((string)DateValue)))
{
return(null);
}
return(Microsoft.VisualBasic.DateAndTime.DatePart(Interval, Convert.ToDateTime(DateValue), DayOfWeek, WeekOfYear));
}
/// <summary>Returns an <see langword="Integer" /> value containing the specified component of a given <see langword="Date" /> value.</summary>
/// <param name="Interval">Required. <see langword="DateInterval" /> enumeration value or <see langword="String" /> expression representing the part of the date/time value you want to return.</param>
/// <param name="DateValue">Required. <see langword="Date" /> value that you want to evaluate.</param>
/// <param name="FirstDayOfWeekValue">Optional. A value chosen from the <see langword="FirstDayOfWeek" /> enumeration that specifies the first day of the week. If not specified, <see langword="FirstDayOfWeek.Sunday" /> is used.</param>
/// <param name="FirstWeekOfYearValue">Optional. A value chosen from the <see langword="FirstWeekOfYear" /> enumeration that specifies the first week of the year. If not specified, <see langword="FirstWeekOfYear.Jan1" /> is used.</param>
/// <returns>Returns an <see langword="Integer" /> value containing the specified component of a given <see langword="Date" /> value.</returns>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="Interval" /> is not valid. </exception>
/// <exception cref="T:System.InvalidCastException">
/// <paramref name="DateValue" /> is not coercible to <see langword="Date" />.</exception>
public static int DatePart(DateInterval Interval, DateTime DateValue, FirstDayOfWeek FirstDayOfWeekValue = FirstDayOfWeek.Sunday, FirstWeekOfYear FirstWeekOfYearValue = FirstWeekOfYear.Jan1)
{
switch (Interval)
{
case DateInterval.Year:
return(DateAndTime.CurrentCalendar.GetYear(DateValue));
case DateInterval.Quarter:
return(checked (unchecked (checked (DateValue.Month - 1) / 3) + 1));
case DateInterval.Month:
return(DateAndTime.CurrentCalendar.GetMonth(DateValue));
case DateInterval.DayOfYear:
return(DateAndTime.CurrentCalendar.GetDayOfYear(DateValue));
case DateInterval.Day:
return(DateAndTime.CurrentCalendar.GetDayOfMonth(DateValue));
case DateInterval.WeekOfYear:
DayOfWeek firstDayOfWeek = FirstDayOfWeekValue != FirstDayOfWeek.System ? (DayOfWeek)(FirstDayOfWeekValue - 1) : Utils.GetCultureInfo().DateTimeFormat.FirstDayOfWeek;
CalendarWeekRule rule = CalendarWeekRule.FirstDay;
switch (FirstWeekOfYearValue)
{
case FirstWeekOfYear.System:
rule = Utils.GetCultureInfo().DateTimeFormat.CalendarWeekRule;
break;
case FirstWeekOfYear.Jan1:
rule = CalendarWeekRule.FirstDay;
break;
case FirstWeekOfYear.FirstFourDays:
rule = CalendarWeekRule.FirstFourDayWeek;
break;
case FirstWeekOfYear.FirstFullWeek:
rule = CalendarWeekRule.FirstFullWeek;
break;
}
return(DateAndTime.CurrentCalendar.GetWeekOfYear(DateValue, rule, firstDayOfWeek));
case DateInterval.Weekday:
return(DateAndTime.Weekday(DateValue, FirstDayOfWeekValue));
case DateInterval.Hour:
return(DateAndTime.CurrentCalendar.GetHour(DateValue));
case DateInterval.Minute:
return(DateAndTime.CurrentCalendar.GetMinute(DateValue));
case DateInterval.Second:
return(DateAndTime.CurrentCalendar.GetSecond(DateValue));
default:
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[1]
{
nameof(Interval)
}));
}
}
public static List <int> GetWeekNumbersInMonth(int weeksInMonth, DayOfWeek firstDayOfWeek, FirstWeekOfYear firstWeekOfYear, DateTime navigatedDate)
{
var selectedYear = navigatedDate.Year;
var selectedMonth = navigatedDate.Month;
int dayOfMonth = 1;
var fistDayOfMonth = new DateTime(selectedYear, selectedMonth, dayOfMonth);
var endOfFirstWeek = dayOfMonth + (firstDayOfWeek + 7 - 1) - AdjustWeekDay(firstDayOfWeek, fistDayOfMonth.DayOfWeek);
var endOfWeekRange = new DateTime(selectedYear, selectedMonth, (int)endOfFirstWeek);
dayOfMonth = endOfWeekRange.Day;
var weeksArray = new List <int>();
for (var i = 0; i < weeksInMonth; i++)
{
// Get week number for end of week
weeksArray.Add(GetWeekNumber(endOfWeekRange, firstDayOfWeek, firstWeekOfYear));
dayOfMonth += 7;
endOfWeekRange = new DateTime(selectedYear, selectedMonth, dayOfMonth);
}
return(weeksArray);
}
private static String FormatString(object _toFormat, string mask, FirstDayOfWeek dayOfWeek, FirstWeekOfYear weekOfYear)
#endif
{
string toFormat = _toFormat.ToString();
int atCount = mask.Count(x => { return(x == '@'); });
if (atCount >= toFormat.Length)
{
if (mask.StartsWith("!"))
{
toFormat = toFormat.PadRight(atCount + 1);
}
}
toFormat = toFormat.PadLeft(atCount);
char[] source = toFormat.ToCharArray();
int sourceIndex = 0;
char[] output = mask.ToCharArray();
for (int outputIndex = 0; outputIndex < output.Length; outputIndex++)
{
if (output[outputIndex] == '@' || output[outputIndex] == '!')
{
output[outputIndex] = source[sourceIndex];
sourceIndex++;
}
}
String retValue = new string(output);
if (sourceIndex < source.Length)
{
retValue += toFormat.Substring(sourceIndex);
}
return(retValue);
}
