public string ToString(string format, IFormatProvider formatProvider = null) { //Supported formats: C - compact, F - full, I - only id, J - json if (format == null) { format = "G"; } format = format.ToLower(); if (formatProvider?.GetFormat(GetType()) is ICustomFormatter formatter) { return(formatter.Format(format, this, formatProvider)); } switch (format) { case "c": return($"{Id}-{Name}"); case "f": return($"{Id}({Name}):[IsUp={!IsProducerDown},Timestamp={LastTimestampBeforeDisconnect:dd.MM.yyyy-HH:mm:ss.fff}]"); case "i": return(Id.ToString()); //case "g": default: return($"{Id}({Name}):[IsUp={!IsProducerDown},Timestamp={LastTimestampBeforeDisconnect:dd.MM.yyyy-HH:mm:ss.fff}]"); } }
/// <summary> /// 将字节流转换为指定对象 /// </summary> /// <param name="bytes"> </param> /// <param name="formatProvider"> 它提供有关当前实例的格式信息 </param> /// <returns> </returns> public virtual T Deserialize <T>(byte[] bytes, IFormatProvider formatProvider) { try { var instance = Activator.CreateInstance <T>(); var props = PropertyHandlerCollection.Get(typeof(T)); var kv = Deserialize(bytes, formatProvider); if (kv == null) { throw new NotSupportedException("无法转为实体"); } foreach (var o in kv) { props[o.Key]?.SetValue(instance, o.Value); } return(instance); } catch (Exception ex) { if (bytes?.Length > 0) { var charset = formatProvider?.GetFormat(typeof(Encoding)) as Encoding; if (charset == null) { ex.Data["ResponseBody"] = ex.Source = "base64:" + Convert.ToBase64String(bytes); } else { ex.Data["ResponseBody"] = ex.Source = charset.GetString(bytes); } } throw; } }
public string ToString(string format, IFormatProvider formatProvider) { if (formatProvider != null) { ICustomFormatter fmt = formatProvider.GetFormat(this.GetType()) as ICustomFormatter; if (fmt != null) return fmt.Format(format, this, formatProvider); } switch (format) { case "g": { string s = Group.ToString("x4"); string x = String.Empty; x += ((Mask & 0xf0000000) != 0) ? s[0] : 'x'; x += ((Mask & 0x0f000000) != 0) ? s[1] : 'x'; x += ((Mask & 0x00f00000) != 0) ? s[2] : 'x'; x += ((Mask & 0x000f0000) != 0) ? s[3] : 'x'; return x; } case "e": { string s = Element.ToString("x4"); string x = String.Empty; x += ((Mask & 0x0000f000) != 0) ? s[0] : 'x'; x += ((Mask & 0x00000f00) != 0) ? s[1] : 'x'; x += ((Mask & 0x000000f0) != 0) ? s[2] : 'x'; x += ((Mask & 0x0000000f) != 0) ? s[3] : 'x'; return x; } case "G": default: { return String.Format("({0},{1})", this.ToString("g", null), this.ToString("e", null)); } } }
public static bool TryParse(string value, IFormatProvider formatProvider, out Money result) { if (value == null) { result = default; return(false); } NumberFormatInfo numberFormat = (NumberFormatInfo)formatProvider?.GetFormat(typeof(NumberFormatInfo)) ?? NumberFormatInfo.CurrentInfo; var currencyString = ExtractCurrencyString(value, numberFormat); if (!Currency.TryParse(currencyString, out Currency currency)) { currency = Currency.None; } numberFormat = (NumberFormatInfo)numberFormat.Clone(); numberFormat.CurrencySymbol = currency != Currency.None ? currencyString : "¤"; if (decimal.TryParse(value, NumberStyles.Currency, numberFormat, out decimal amount)) { result = new Money(amount, currency); return(true); } else { result = default; return(false); } }
public string ToString(string format, IFormatProvider formatProvider) { if (formatProvider == null) { return this.ToString(); } ICustomFormatter fmt = formatProvider.GetFormat(this.GetType()) as ICustomFormatter; if (fmt != null) { return fmt.Format(format, this, formatProvider); } switch (format) { case "V": return this.Value; case "O": return this.Operator.ToString(); case "G": default: return this.ToString(); } }
public DateTime ConvertFrom(RedisValue value, IFormatProvider provider) { var dateOnly = false; var kind = DateTimeKind.Local; var formatInfo = provider?.GetFormat(typeof(DateTimeConvertionInfo)) as DateTimeConvertionInfo; if (formatInfo != null) { kind = formatInfo.Kind; dateOnly = formatInfo.DateOnly; } var dateTime = DateTime.SpecifyKind( DateTime.ParseExact((string)value, dateOnly ? DateOnlyFormat : DateTimeFormat, CultureInfo.InvariantCulture), dateOnly ? DateTimeKind.Unspecified : DateTimeKind.Utc); if (dateOnly == false && kind == DateTimeKind.Local) { return(dateTime.ToLocalTime()); } else { return(dateTime); } }
/// <summary>Formats the value of the current instance using the specified format.</summary> /// <returns>The value of the current instance in the specified format.</returns> /// <param name="format"> /// The format to use.-or- A null reference (Nothing in Visual Basic) to use the default format /// defined for the type of the <see cref="T:System.IFormattable" /> implementation. /// </param> /// <param name="formatProvider"> /// The provider to use to format the value.-or- A null reference (Nothing in Visual Basic) to /// obtain the numeric format information from the current locale setting of the operating system. /// </param> public string ToString(string format, IFormatProvider formatProvider = null) { //Supported formats: C - compact, F - full, I - only id, J - json if (format == null) { format = "G"; } format = format.ToLower(); var formatter = formatProvider?.GetFormat(GetType()) as ICustomFormatter; if (formatter != null) { return(formatter.Format(format, this, formatProvider)); } switch (format) { case "c": return(PrintC()); case "f": return(PrintF()); case "j": return(PrintJ()); //case "i": //case "g": default: return(PrintI()); } }
private TimeTextInfo GetTimeTextInfo(IFormatProvider provider) { if (provider != null) { // See if the provider can give us what we want: var timeTextInfo = (TimeTextInfo)provider.GetFormat(typeof (TimeTextInfo)); if (timeTextInfo != null) { return timeTextInfo; } // See if there is a rule for this culture: var cultureInfo = provider as CultureInfo; if (cultureInfo != null) { timeTextInfo = CommonLanguagesTimeTextInfo.GetTimeTextInfo(cultureInfo.TwoLetterISOLanguageName); // If cultureInfo was supplied, // we will always return, even if null: return timeTextInfo; } } // Return the default if the provider couldn't provide: return CommonLanguagesTimeTextInfo.GetTimeTextInfo(defaultTwoLetterISOLanguageName); }
/// <summary> /// Default formats: /// <para>t - SemVer 2.0 formatted tag [beta.1]</para> /// <para>l - Legacy SemVer tag with the tag number padded. [beta1]</para> /// <para>lp - Legacy SemVer tag with the tag number padded. [beta0001]. Can specify an integer to control padding (i.e., lp5)</para> /// </summary> public string ToString(string?format, IFormatProvider?formatProvider) { if (formatProvider?.GetFormat(GetType()) is ICustomFormatter formatter) { return(formatter.Format(format, this, formatProvider)); } if (format.IsNullOrEmpty()) { format = "t"; } format = format.ToLower(); if (format.StartsWith("lp", StringComparison.Ordinal)) { // Handle format var padding = 4; if (format.Length > 2) { // try to parse if (int.TryParse(format.Substring(2), out var p)) { padding = p; } } return(Number.HasValue ? FormatLegacy(GetLegacyName(), Number.Value.ToString("D" + padding)) : FormatLegacy(GetLegacyName())); } return(format switch { "t" => (Number.HasValue ? Name.IsNullOrEmpty() ? $"{Number}" : $"{Name}.{Number}" : Name ?? string.Empty), "l" => (Number.HasValue ? FormatLegacy(GetLegacyName(), Number.Value.ToString()) : FormatLegacy(GetLegacyName())), _ => throw new FormatException($"Unknown format '{format}'.") });
/// <summary>Initializes the builder.</summary> /// <param name="scratchBuffer">A buffer temporarily transferred to the builder for use as part of its formatting. Contents may be overwritten.</param> /// <param name="provider">An object that supplies culture-specific formatting information.</param> private InterpolatedStringBuilder(Span <char> scratchBuffer, IFormatProvider?provider) { _provider = provider; _customFormatter = provider?.GetFormat(typeof(ICustomFormatter)); _arrayToReturnToPool = null; _chars = scratchBuffer; _pos = 0; }
public string ToString(string format, IFormatProvider formatProvider) { NumberFormatInfo numberFormat = (NumberFormatInfo)formatProvider?.GetFormat(typeof(NumberFormatInfo)) ?? NumberFormatInfo.CurrentInfo; return(_amount.ToString(format, CustomizeNumberFormat(numberFormat))); }
/// <summary>Initializes the builder.</summary> /// <param name="initialCapacity">Approximated capacity required to support the interpolated string. The final size may be smaller or larger.</param> /// <param name="provider">An object that supplies culture-specific formatting information.</param> private InterpolatedStringBuilder(int initialCapacity, IFormatProvider?provider) { _provider = provider; _customFormatter = provider?.GetFormat(typeof(ICustomFormatter)); _chars = _arrayToReturnToPool = ArrayPool <char> .Shared.Rent(initialCapacity); _pos = 0; }
/// <summary> /// Formats the value of the current instance using the specified format. The numbers are however culture invariant. /// </summary> /// <returns> /// The value of the current instance in the specified format. /// </returns> /// <param name="format">The format to use. /// <list type="table"> /// <listheader><term>symbol</term><description>description</description></listheader> /// <item><term>G</term><description>General format: numerator/denominator</description></item> /// <item><term>n</term><description>Numerator</description></item> /// <item><term>d</term><description>Denominator</description></item> /// <item><term>z</term><description>The fraction as integer</description></item> /// <item><term>r</term><description>The positive remainder of all digits after the decimal point using the format: numerator/denominator or <see cref="string.Empty"/> if the fraction is a valid integer without digits after the decimal point.</description></item> /// <item><term>m</term><description>The fraction as mixed number e.g. "2 1/3" instead of "7/3"</description></item> /// </list> /// -or- A null reference (Nothing in Visual Basic) to use the default format defined for the type of the <see cref="T:System.IFormattable"/> implementation. </param> /// <param name="formatProvider">The provider to use to format the value. -or- A null reference (Nothing in Visual Basic) to obtain the numeric format information from the current locale setting of the operating system.</param> /// <filterpriority>2</filterpriority> public string ToString(string format, IFormatProvider formatProvider) { var formatter = formatProvider?.GetFormat(GetType()) as ICustomFormatter; return(formatter != null ? formatter.Format(format, this, formatProvider) : DefaultFractionFormatter.Instance.Format(format, this, formatProvider)); }
private string Pluralize(string name, IFormatProvider formatProvider) { var pluralizer = formatProvider?.GetFormat <IPluralizer>() ?? _standardPluralizer; return(pluralizer.Pluralize(name)); }
private void AppendCustomFormatter <T>(T value, string?format) { ICustomFormatter?formatter = (ICustomFormatter?)formatProvider?.GetFormat(typeof(ICustomFormatter)); if (formatter is not null && formatter.Format(format, value, formatProvider) is string customFormatted) { AppendStringDirect(customFormatted); } }
/// <summary> /// Returns a string representation of this file size, using the provided format modifier /// and provider. /// </summary> /// <remarks> /// The format modifier either specifies only a unit size (e.g. 'B', 'KB', 'MB', or the special 'FS') or /// a number formatter plus unit size, separated by a colon (e.g. 'N2:GB' for a gigabyte representation /// to 2 decimal places). /// </remarks> /// <param name="format">The format to use.</param> /// <param name="formatProvider">A format provider which may contain a custom formatter to use instead /// of the default provided by this method.</param> /// <returns>A string representation of this file size.</returns> public string ToString(string format, IFormatProvider formatProvider) { if (formatProvider?.GetFormat(typeof(FileSize)) is ICustomFormatter formatter) { return(formatter.Format(format, this, formatProvider)); } return(GetUnitSizeForFormat(format, this.Bytes).Format(this.Bytes)); }
/// <summary> /// An alternative for the ToString() method of DateTime to work around a problem with implementing custom formatters for DateTime objects /// The default implementation, even if given a good IFormatProvider implementation, would never call a custom formatter. It would /// still use the default formatter. /// </summary> /// <param name="dateTime">The date time object.</param> /// <param name="provider">The provider.</param> /// <param name="format">The format.</param> /// <returns></returns> public static string ToStringExtended(this DateTime dateTime, string format, IFormatProvider provider) { var formatter = provider.GetFormat(typeof(DateTimeFormatInfo)) as ICustomFormatter; if (formatter != null) { return formatter.Format(format, dateTime, provider); } throw new ArgumentException("The format provider argument did not return an instance that implements ICustomFormatter", "provider"); }
/// <summary> /// 将字节流转换为键值对枚举 /// </summary> /// <param name="bytes"> </param> /// <param name="formatProvider"> 它提供有关当前实例的格式信息 </param> /// <returns> </returns> public override IEnumerable <KeyValuePair <string, object> > Deserialize(byte[] bytes, IFormatProvider formatProvider) { if (bytes?.Length > 0) { var charset = formatProvider?.GetFormat(typeof(Encoding)) as Encoding ?? Encoding.Default; var text = charset.GetString(bytes); yield return(new KeyValuePair <string, object>(null, text)); } }
/// <summary> /// Gets a string representation of the current instance, using the specified format provider, /// which should be able to return an instance of <see cref="IFormatsFraction"/>. /// </summary> /// <returns>The string representation.</returns> /// <param name="format">The format specifier.</param> /// <param name="formatProvider">A format provider, which should be able to return an <see cref="IFormatsFraction"/>.</param> public string ToString(string format, IFormatProvider formatProvider) { var formatter = formatProvider?.GetFormat(typeof(IFormatsFraction)) as IFormatsFraction; if (formatter == null) { return(ToString()); } return(formatter.Format(this, format)); }
public object GetFormat(Type formatType) { if (_provider != null) { } else { } return(_provider?.GetFormat(formatType)); }
public static DateTimeFormatInfo GetInstance(IFormatProvider fp) { if (fp != null) { DateTimeFormatInfo dtf = (DateTimeFormatInfo)fp.GetFormat(typeof(DateTimeFormatInfo)); if (dtf != null) { return dtf; } } return CurrentInfo; }
private bool AppendCustomFormatter <T>(T value, string?format) { ICustomFormatter?formatter = (ICustomFormatter?)formatProvider?.GetFormat(typeof(ICustomFormatter)); if (formatter is not null && formatter.Format(format, value, formatProvider) is string customFormatted) { return(AppendStringDirect(customFormatted)); } return(true); }
/// <summary> /// 指定された型の書式設定サービスを取得します。 /// </summary> /// <param name="formatType">書式設定サービスの種類です。</param> /// <returns>書式設定サービスを表すオブジェクトです。</returns> public virtual object?GetFormat(Type?formatType) { if (formatType?.IsAssignableFrom(this.GetType()) ?? false) { return(this); } else { return(_provider?.GetFormat(formatType)); } }
/// <summary> /// Convert Enum to RedisValue /// </summary> /// <param name="value">enum value to convert</param> /// <param name="type">enum type to convert</param> /// <param name="provider">provider controls how enum value is converted</param> /// <returns>RedisValue represents enum value</returns> public static RedisValue ConvertTo(object value, Type type, IFormatProvider provider) { var format = "g"; var formatInfo = provider?.GetFormat(typeof(EnumConvertionInfo)) as EnumConvertionInfo; if (formatInfo != null && formatInfo.Convertion == EnumConvertion.AsNumeric) { format = "d"; } return(Enum.Format(type, value, format)); }
/// <summary> /// <para>s - Default SemVer [1.2.3-beta.4+5]</para> /// <para>f - Full SemVer [1.2.3-beta.4+5]</para> /// <para>i - Informational SemVer [1.2.3-beta.4+5.Branch.main.BranchType.main.Sha.000000]</para> /// <para>j - Just the SemVer part [1.2.3]</para> /// <para>t - SemVer with the tag [1.2.3-beta.4]</para> /// <para>l - Legacy SemVer tag for systems which do not support SemVer 2.0 properly [1.2.3-beta4]</para> /// <para>lp - Legacy SemVer tag for systems which do not support SemVer 2.0 properly (padded) [1.2.3-beta0004]</para> /// </summary> public string ToString(string format, IFormatProvider formatProvider = null) { if (string.IsNullOrEmpty(format)) { format = "s"; } if (formatProvider?.GetFormat(GetType()) is ICustomFormatter formatter) { return(formatter.Format(format, this, formatProvider)); } // Check for lp first because the param can vary format = format.ToLower(); if (format.StartsWith("lp", StringComparison.Ordinal)) { // handle the padding return(PreReleaseTag.HasTag() ? $"{ToString("j")}-{PreReleaseTag.ToString(format)}" : ToString("j")); } switch (format) { case "j": return($"{Major}.{Minor}.{Patch}"); case "s": return(PreReleaseTag.HasTag() ? $"{ToString("j")}-{PreReleaseTag}" : ToString("j")); case "t": return(PreReleaseTag.HasTag() ? $"{ToString("j")}-{PreReleaseTag.ToString("t")}" : ToString("j")); case "l": return(PreReleaseTag.HasTag() ? $"{ToString("j")}-{PreReleaseTag.ToString("l")}" : ToString("j")); case "f": { var buildMetadata = BuildMetaData.ToString(); return(!string.IsNullOrEmpty(buildMetadata) ? $"{ToString("s")}+{buildMetadata}" : ToString("s")); } case "i": { var buildMetadata = BuildMetaData.ToString("f"); return(!string.IsNullOrEmpty(buildMetadata) ? $"{ToString("s")}+{buildMetadata}" : ToString("s")); } default: throw new ArgumentException($"Unrecognised format '{format}'", nameof(format)); } }
/// <summary> /// Represents a customer in the specified format and culture /// </summary> /// <param name="format">Format string</param> /// <param name="provider">Format provider</param> /// <returns>Formatted string</returns> public string ToString(string format, IFormatProvider provider) { string currentFormat = string.IsNullOrEmpty(format) ? GeneralFormatStr : format; ICustomFormatter formatter = provider?.GetFormat(GetType()) as ICustomFormatter; if (formatter != null) { return(formatter.Format(currentFormat, this, provider)); } return(GetFormattedString(currentFormat, provider)); }
public decimal Parse(IFormatProvider provider, decimal defaultValue = default(decimal), bool round = false) { var result = _converter.Parse(provider, defaultValue); if (round) { provider = provider ?? CultureInfo.CurrentCulture; var numberFormat = (NumberFormatInfo)provider.GetFormat(typeof(NumberFormatInfo)) ?? CultureInfo.CurrentCulture.NumberFormat; return Math.Round(result, numberFormat.CurrencyDecimalDigits); } return result; }
private static bool UnsignedFormat(this ulong value, Span <char> target, out int charsWritten, IFormatProvider provider = null) { charsWritten = 0; var info = provider?.GetFormat(typeof(NumberFormatInfo)) as NumberFormatInfo ?? NumberFormatInfo.CurrentInfo; if (value == 0) { if (info.NativeDigits[0].AsSpan().TryCopyTo(target)) { charsWritten = info.NativeDigits[0].Length; return(true); } else { return(false); } } var ind = 0; var n = value.SignificantDigitsCount(); Span <char> buff = stackalloc char[4 * n]; while (value != 0) { var rem = value % 10u; var digit = info.NativeDigits[rem].AsSpan(); digit.CopyTo(buff.Slice(ind)); ind += digit.Length; value /= 10u; } if (ind >= target.Length) { return(false); } for (var i = 0; i < ind; i++) { target[i] = buff[ind - i - 1]; } charsWritten = ind; return(true); }
public void Parse(out BigRational result, string s, IFormatProvider provider) { NumberFormatInfo numberFormatProvider = (NumberFormatInfo)provider?.GetFormat(typeof(NumberFormatInfo)); if (numberFormatProvider == null) { numberFormatProvider = CultureInfo.CurrentCulture.NumberFormat; } int pos = s.IndexOf(numberFormatProvider.NumberDecimalSeparator); if (pos < 0) { var value = BigInteger.Parse(s, provider); result = new BigRational(value); } else { var strWholePart = s.Substring(0, pos).TrimStart(); var strFractPart = pos < s.Length ? s.Substring(pos + 1) : string.Empty; BigInteger bigWholePart = BigInteger.Zero; if (!string.IsNullOrEmpty(strWholePart) && strWholePart != "-") { bigWholePart = BigInteger.Parse(strWholePart, provider); } BigInteger bigFractPart = BigInteger.Zero; if (!string.IsNullOrEmpty(strFractPart)) { var pow = new BigRational((long)Math.Pow(10, strFractPart.Length)); bigFractPart = BigInteger.Parse(strFractPart, provider); if (bigWholePart.Sign < 0 || (bigWholePart.IsZero && strWholePart.StartsWith(numberFormatProvider.NegativeSign))) { bigFractPart = BigInteger.Negate(bigFractPart); } var rationalWhole = new BigRational(bigWholePart); var rationalFract = new BigRational(bigFractPart); rationalFract.Divide(out rationalFract, ref pow); rationalWhole.Add(out result, ref rationalFract); } else { result = new BigRational(bigWholePart); } } }
public static bool HasFormatted( this IFormatProvider? @this, object obj, string?format, [NotNullWhen(true)] out string?result) { if (@this?.GetFormat(obj.GetType()) is ICustomFormatter customFormatter) { result = customFormatter.Format(format, obj, @this); return(true); } else { result = null; return(false); } }
internal static CultureInfo?FormatProviderToCultureInfo(IFormatProvider?formatProvider) { if (formatProvider is CultureInfo ci) { return(ci); } else if (formatProvider?.GetFormat(typeof(CultureInfo)) is CultureInfo ci2) { return(ci2); } else { return(CultureInfo.CurrentCulture); } }
public decimal? Parse(IFormatProvider provider, bool round = false) { var result = _converter.Parse(provider); if (!result.HasValue) return null; if (round) { provider = provider ?? CultureInfo.CurrentCulture; var numberFormat = (NumberFormatInfo)provider.GetFormat(typeof(NumberFormatInfo)) ?? CultureInfo.CurrentCulture.NumberFormat; return Math.Round(result.Value, numberFormat.CurrencyDecimalDigits); } return result; }
/// <summary> /// Sets a DateTime formatter to be used for outputting the DateTime values /// </summary> /// <param name="formatProvider">Format provider</param> /// <returns>A Collapse instance, used for chaining</returns> public Collapse SetDateTimeFormat(IFormatProvider formatProvider) { if(formatProvider == null) throw new ArgumentNullException("formatProvider", "Format provider was not supplied."); DateTimeFormatInfo formatInfo = formatProvider.GetFormat(typeof(DateTimeFormatInfo)) as DateTimeFormatInfo; if (formatInfo == null) throw new DateTimeFormatInvalidException(); SetDateTimeFormat( String.Format("{0} {1}", formatInfo.ShortDatePattern, formatInfo.LongTimePattern)); return this; }
private bool TryFormatter(string format, IFormatProvider formatProvider, out string formattedString) { var formatted = false; formattedString = null; var formatter = formatProvider?.GetFormat(typeof(Version)) as ICustomFormatter; if (formatter != null) { formatted = true; formattedString = formatter.Format(format, this, formatProvider); } return(formatted); }
public override byte[] Serialize(string format, IEnumerable <KeyValuePair <string, object> > body, IFormatProvider formatProvider) { var data = body.FirstOrDefault(it => it.Key == null).Value; var bytes = data as byte[]; if (bytes != null) { return(bytes); } var charset = formatProvider?.GetFormat(typeof(Encoding)) as Encoding ?? Encoding.Default; var str = data as string; if (str != null) { return(charset.GetBytes(str)); } throw new NotSupportedException("不支持"); }
public RedisValue ConvertTo(DateTime value, IFormatProvider provider) { var dateOnly = false; var formatInfo = provider?.GetFormat(typeof(DateTimeConvertionInfo)) as DateTimeConvertionInfo; if (formatInfo != null) { dateOnly = formatInfo.DateOnly; } if (dateOnly) { return(value.ToString(DateOnlyFormat)); } else { return(value.ToUniversalTime().ToString(DateTimeFormat)); } }
/// <summary> /// 将正文内容(<paramref name="arg" />)按照<paramref name="formatProvider" />中的编码信息转为等效的字符串 /// </summary> /// <exception cref="FormatException"> <paramref name="arg" />必须是 IEnumerable<KeyValuePair<string, object>>. </exception> public virtual string Format(string format, object arg, IFormatProvider formatProvider) { if (arg == null) { return(null); } var body = arg as IEnumerable <KeyValuePair <string, object> >; if (body == null) { throw new FormatException(nameof(arg) + "必须是" + nameof(IEnumerable <KeyValuePair <string, object> >)); } var bytes = Serialize(format, body, formatProvider); if (bytes?.Length > 0) { var charset = formatProvider?.GetFormat(typeof(Encoding)) as Encoding ?? Encoding.Default; return(charset.GetString(bytes)); } return(null); }
NumberFormatInfo(IFormatProvider provider) { if(provider == null) { return System.Globalization.NumberFormatInfo.CurrentInfo; } else { NumberFormatInfo nfi = (NumberFormatInfo) provider.GetFormat( typeof(System.Globalization.NumberFormatInfo)); if(nfi != null) { return nfi; } else { return System.Globalization.NumberFormatInfo.CurrentInfo; } } }
public int ToInt32(IFormatProvider provider) { bool toMinValue = true; if (provider != null) { TestFormatProvider format = provider.GetFormat(typeof(TestFormatProvider)) as TestFormatProvider; if ((format != null) && format.ToInt16MaxValue) { toMinValue = false; } } if (toMinValue) { return Int32.MinValue; } else { return Int32.MaxValue; } }
public string ToString(string format, IFormatProvider formatProvider) { if (formatProvider != null) { ICustomFormatter fmt = formatProvider.GetFormat(this.GetType()) as ICustomFormatter; if (fmt != null) { return fmt.Format(format, this, formatProvider); } } switch (format) { case "n": return Name; case "p": return PhoneNumber; case "a": return Name + PhoneNumber; default: return Name; } }
/// <summary> /// This method returns a string representation of the DicomTag. /// Use one of the following formats as parameter: /// - "G": returns for example "(0028,0010)" for public and "(0029,1001:MYPRIVATE)" for private tags /// - "X": returns for example "(0028,0010)" for public and "(0029,xx01:MYPRIVATE)" for private tags /// - "J": returns for example "00280010" for public and "00291001" for private tags /// </summary> public string ToString(string format, IFormatProvider formatProvider) { if (formatProvider?.GetFormat(GetType()) is ICustomFormatter fmt) { return(fmt.Format(format, this, formatProvider)); } switch (format) { case "X": { return((PrivateCreator != null) ? string.Format("({0:x4},xx{1:x2}:{2})", Group, Element & 0xff, PrivateCreator.Creator) : string.Format("({0:x4},{1:x4})", Group, Element)); } case "g": { return((PrivateCreator != null) ? string.Format("{0:x4},{1:x4}:{2}", Group, Element, PrivateCreator.Creator) : string.Format("{0:x4},{1:x4}", Group, Element)); } case "J": { return(string.Format("{0:X4}{1:X4}", Group, Element)); } case "G": default: { return((PrivateCreator != null) ? string.Format("({0:x4},{1:x4}:{2})", Group, Element, PrivateCreator.Creator) : string.Format("({0:x4},{1:x4})", Group, Element)); } } }
public static string ToJavaFormatString(string format, IFormatProvider provider, DateTimeKind kind, bool dateTimeOffset, out bool useInvariant, out bool foundDateTimeKind, out bool useUtc) { if (string.IsNullOrEmpty(format)) format = "G"; DateTimeFormatInfo dtfi = null; if (provider != null) dtfi = (DateTimeFormatInfo)provider.GetFormat(typeof(DateTimeFormatInfo)); if (dtfi == null) dtfi = DateTimeFormatInfo.CurrentInfo; bool needsTranslation = true; if (format.Length == 1 && dtfi != null) { format = GetStandardPattern(format[0], dtfi, dateTimeOffset, out useUtc, out useInvariant, out needsTranslation); if (format == null) throw new FormatException( "format is not one of the format specifier characters defined for DateTimeFormatInfo"); } else { useInvariant = false; useUtc = false; } if (needsTranslation) format = ConvertFormatStringNetToJava(format, kind, out foundDateTimeKind); else foundDateTimeKind = false; return format; }
public string Format(string format, object arg, IFormatProvider formatProvider) { if (formatProvider != null) { ICustomFormatter fmt = formatProvider.GetFormat(this.GetType()) as ICustomFormatter; if (fmt != null) { return fmt.Format(format, this, formatProvider); } } Question question = null; if (arg is Question) { question = arg as Question; } else { var questions = arg as Question[]; question = questions.First(e => e.Key == format); } if (question.Value != null) return question.Value.ToString(); return string.Format(format, "{0}", arg); }
public StringBuilder AppendFormat(IFormatProvider provider, String format, params Object[] args) { if (format == null || args == null) { throw new ArgumentNullException((format == null) ? "format" : "args"); } Contract.Ensures(Contract.Result<StringBuilder>() != null); Contract.EndContractBlock(); int pos = 0; int len = format.Length; char ch = '\x0'; ICustomFormatter cf = null; if (provider != null) { cf = (ICustomFormatter)provider.GetFormat(typeof(ICustomFormatter)); } while (true) { int p = pos; int i = pos; while (pos < len) { ch = format[pos]; pos++; if (ch == '}') { if (pos < len && format[pos] == '}') // Treat as escape character for }} pos++; else FormatError(); } if (ch == '{') { if (pos < len && format[pos] == '{') // Treat as escape character for {{ pos++; else { pos--; break; } } Append(ch); } if (pos == len) break; pos++; if (pos == len || (ch = format[pos]) < '0' || ch > '9') FormatError(); int index = 0; do { index = index * 10 + ch - '0'; pos++; if (pos == len) FormatError(); ch = format[pos]; } while (ch >= '0' && ch <= '9' && index < 1000000); if (index >= args.Length) throw new FormatException(Environment.GetResourceString("Format_IndexOutOfRange")); while (pos < len && (ch = format[pos]) == ' ') pos++; bool leftJustify = false; int width = 0; if (ch == ',') { pos++; while (pos < len && format[pos] == ' ') pos++; if (pos == len) FormatError(); ch = format[pos]; if (ch == '-') { leftJustify = true; pos++; if (pos == len) FormatError(); ch = format[pos]; } if (ch < '0' || ch > '9') FormatError(); do { width = width * 10 + ch - '0'; pos++; if (pos == len) FormatError(); ch = format[pos]; } while (ch >= '0' && ch <= '9' && width < 1000000); } while (pos < len && (ch = format[pos]) == ' ') pos++; Object arg = args[index]; StringBuilder fmt = null; if (ch == ':') { pos++; p = pos; i = pos; while (true) { if (pos == len) FormatError(); ch = format[pos]; pos++; if (ch == '{') { if (pos < len && format[pos] == '{') // Treat as escape character for {{ pos++; else FormatError(); } else if (ch == '}') { if (pos < len && format[pos] == '}') // Treat as escape character for }} pos++; else { pos--; break; } } if (fmt == null) { fmt = new StringBuilder(); } fmt.Append(ch); } } if (ch != '}') FormatError(); pos++; String sFmt = null; String s = null; if (cf != null) { if (fmt != null) { sFmt = fmt.ToString(); } s = cf.Format(sFmt, arg, provider); } if (s == null) { IFormattable formattableArg = arg as IFormattable; #if FEATURE_LEGACYNETCF if(CompatibilitySwitches.IsAppEarlierThanWindowsPhone8) { // TimeSpan does not implement IFormattable in Mango if(arg is TimeSpan) { formattableArg = null; } } #endif if (formattableArg != null) { if (sFmt == null && fmt != null) { sFmt = fmt.ToString(); } s = formattableArg.ToString(sFmt, provider); } else if (arg != null) { s = arg.ToString(); } } if (s == null) s = String.Empty; int pad = width - s.Length; if (!leftJustify && pad > 0) Append(' ', pad); Append(s); if (leftJustify && pad > 0) Append(' ', pad); } return this; }
private string ToString(string format, IFormatProvider provider) { if (this.IsEmpty) { return "Empty"; } if (provider == null) { provider = CultureInfo.CurrentCulture; } if (format == null) { format = string.Empty; } string separator = ","; NumberFormatInfo numberFormat = provider.GetFormat(typeof(NumberFormatInfo)) as NumberFormatInfo; if (numberFormat != null && numberFormat.NumberDecimalSeparator == separator) { separator = ";"; } string rectFormat = string.Format( "{{0:{0}}}{1}{{1:{0}}}{1}{{2:{0}}}{1}{{3:{0}}}", format, separator); return string.Format(provider, rectFormat, this.x, this.y, this.width, this.height); }
internal static StringBuilder FormatHelper(StringBuilder result, IFormatProvider provider, string format, params object[] args) { if (format == null) throw new ArgumentNullException("format"); if (args == null) throw new ArgumentNullException("args"); if (result == null) { /* Try to approximate the size of result to avoid reallocations */ int i, len; len = 0; for (i = 0; i < args.Length; ++i) { string s = args[i] as string; if (s != null) len += s.Length; else break; } result = new StringBuilder(); } int ptr = 0; int start = ptr; var formatter = provider != null ? provider.GetFormat(typeof (ICustomFormatter)) as ICustomFormatter : null; while (ptr < format.Length) { char c = format[ptr ++]; if (c == '{') { result.Append(format, start, ptr - start - 1); // check for escaped open bracket if (format[ptr] == '{') { start = ptr ++; continue; } // parse specifier int n, width; bool left_align; string arg_format; ParseFormatSpecifier(format, ref ptr, out n, out width, out left_align, out arg_format); if (n >= args.Length) throw new FormatException("Index (zero based) must be greater than or equal to zero and less than the size of the argument list."); // format argument object arg = args[n]; string str; if (arg == null) str = ""; else if (formatter != null) str = formatter.Format(arg_format, arg, provider); else str = null; if (str == null) { if (arg is IFormattable) str = ((IFormattable)arg).ToString(arg_format, provider); else str = arg.ToString(); } // pad formatted string and append to result if (width > str.Length) { const char padchar = ' '; int padlen = width - str.Length; if (left_align) { result.Append(str); result.Append(padchar, padlen); } else { result.Append(padchar, padlen); result.Append(str); } } else { result.Append(str); } start = ptr; } else if (c == '}' && ptr < format.Length && format[ptr] == '}') { result.Append(format, start, ptr - start - 1); start = ptr ++; } else if (c == '}') { throw new FormatException("Input string was not in a correct format."); } } if (start < format.Length) result.Append(format, start, format.Length - start); return result; }
/// <include file='doc\StringBuilder.uex' path='docs/doc[@for="StringBuilder.AppendFormat4"]/*' /> public StringBuilder AppendFormat(IFormatProvider provider, String format, params Object[] args) { if (format == null || args == null) { throw new ArgumentNullException((format==null)?"format":"args"); } char[] chars = format.ToCharArray(0, format.Length); int pos = 0; int len = chars.Length; char ch = '\x0'; ICustomFormatter cf = null; if (provider!=null) { cf=(ICustomFormatter)provider.GetFormat(typeof(ICustomFormatter)); } while (true) { int p = pos; int i = pos; while (pos < len) { ch = chars[pos]; pos++; if (ch == '}') { if(pos < len && chars[pos]=='}') // Treat as escape character for }} pos++; else FormatError(); } if (ch == '{') { if(pos < len && chars[pos]=='{') // Treat as escape character for {{ pos++; else { pos--; break; } } chars[i++] = ch; } if (i > p) Append(chars, p, i - p); if (pos == len) break; pos++; if (pos == len || (ch = chars[pos]) < '0' || ch > '9') FormatError(); int index = 0; do { index = index * 10 + ch - '0'; pos++; if (pos == len) FormatError(); ch = chars[pos]; } while (ch >= '0' && ch <= '9' && index < 1000000); if (index >= args.Length) throw new FormatException(Environment.GetResourceString("Format_IndexOutOfRange")); while (pos < len && (ch=chars[pos]) == ' ') pos++; bool leftJustify = false; int width = 0; if (ch == ',') { pos++; while (pos < len && chars[pos] == ' ') pos++; if (pos == len) FormatError(); ch = chars[pos]; if (ch == '-') { leftJustify = true; pos++; if (pos == len) FormatError(); ch = chars[pos]; } if (ch < '0' || ch > '9') FormatError(); do { width = width * 10 + ch - '0'; pos++; if (pos == len) FormatError(); ch = chars[pos]; } while (ch >= '0' && ch <= '9' && width < 1000000); } while (pos < len && (ch=chars[pos]) == ' ') pos++; Object arg = args[index]; String fmt = null; if (ch == ':') { pos++; p = pos; i = pos; while (true) { if (pos == len) FormatError(); ch = chars[pos]; pos++; if (ch == '{') { if(pos < len && chars[pos]=='{') // Treat as escape character for {{ pos++; else FormatError(); } else if (ch == '}') { if(pos < len && chars[pos]=='}') // Treat as escape character for }} pos++; else { pos--; break; } } chars[i++] = ch; } if (i > p) fmt = new String(chars, p, i - p); } if (ch != '}') FormatError(); pos++; String s = null; if (cf != null) { s = cf.Format(fmt, arg, provider); } if (s==null) { if (arg is IFormattable) { s = ((IFormattable)arg).ToString(fmt, provider); } else if (arg != null) { s = arg.ToString(); } } if (s == null) s = String.Empty; int pad = width - s.Length; if (!leftJustify && pad > 0) Append(' ', pad); Append(s); if (leftJustify && pad > 0) Append(' ', pad); } return this; }
internal StringBuilder AppendFormatHelper(IFormatProvider provider, String format, ParamsArray args) { if (format == null) throw new ArgumentNullException("format"); int pos = 0; int len = format.Length; char ch = '\x0'; StringBuilder unescapedItemFormat = null; ICustomFormatter cf = null; if (provider != null) { cf = (ICustomFormatter)provider.GetFormat(typeof(ICustomFormatter)); } while (true) { while (pos < len) { ch = format[pos]; pos++; if (ch == '}') { if (pos < len && format[pos] == '}') // Treat as escape character for }} pos++; else FormatError(); } if (ch == '{') { if (pos < len && format[pos] == '{') // Treat as escape character for {{ pos++; else { pos--; break; } } Append(ch); } if (pos == len) break; pos++; if (pos == len || (ch = format[pos]) < '0' || ch > '9') FormatError(); int index = 0; do { index = index * 10 + ch - '0'; pos++; if (pos == len) FormatError(); ch = format[pos]; } while (ch >= '0' && ch <= '9' && index < 1000000); if (index >= args.Length) throw new FormatException(SR.Format_IndexOutOfRange); while (pos < len && (ch = format[pos]) == ' ') pos++; bool leftJustify = false; int width = 0; if (ch == ',') { pos++; while (pos < len && format[pos] == ' ') pos++; if (pos == len) FormatError(); ch = format[pos]; if (ch == '-') { leftJustify = true; pos++; if (pos == len) FormatError(); ch = format[pos]; } if (ch < '0' || ch > '9') FormatError(); do { width = width * 10 + ch - '0'; pos++; if (pos == len) FormatError(); ch = format[pos]; } while (ch >= '0' && ch <= '9' && width < 1000000); } while (pos < len && (ch = format[pos]) == ' ') pos++; Object arg = args[index]; String itemFormat = null; if (ch == ':') { pos++; int startPos = pos; while (true) { if (pos == len) FormatError(); ch = format[pos]; pos++; if (ch == '}' || ch == '{') { if (ch == '{') { if (pos < len && format[pos] == '{') // Treat as escape character for {{ pos++; else FormatError(); } else { if (pos < len && format[pos] == '}') // Treat as escape character for }} pos++; else { pos--; break; } } // Reaching here means the brace has been escaped // so we need to build up the format string in segments if (unescapedItemFormat == null) { unescapedItemFormat = new StringBuilder(); } unescapedItemFormat.Append(format, startPos, pos - startPos - 1); startPos = pos; } } if (unescapedItemFormat == null || unescapedItemFormat.Length == 0) { if (startPos != pos) { // There was no brace escaping, extract the item format as a single string itemFormat = format.Substring(startPos, pos - startPos); } } else { unescapedItemFormat.Append(format, startPos, pos - startPos); itemFormat = unescapedItemFormat.ToString(); unescapedItemFormat.Clear(); } } if (ch != '}') FormatError(); pos++; String s = null; if (cf != null) { s = cf.Format(itemFormat, arg, provider); } if (s == null) { IFormattable formattableArg = arg as IFormattable; if (formattableArg != null) { s = formattableArg.ToString(itemFormat, provider); } else if (arg != null) { s = arg.ToString(); } } if (s == null) s = String.Empty; int pad = width - s.Length; if (!leftJustify && pad > 0) Append(' ', pad); Append(s); if (leftJustify && pad > 0) Append(' ', pad); } return this; }
string System.IFormattable.ToString (string format, IFormatProvider provider) { if (String.IsNullOrEmpty (format)) format = null; if (provider != null) { ICustomFormatter cp = (ICustomFormatter) provider.GetFormat (typeof (ICustomFormatter)); if (cp != null) { return String.Format ("{0}{1}{2}", cp.Format (format, x, provider), cp.Format (null, ',', provider), cp.Format (format, y, provider)); } } return String.Format ("{0},{1}", x.ToString (format, provider), y.ToString (format, provider)); }
public static DateTimeFormatInfo GetInstance(IFormatProvider provider) { // Fast case for a regular CultureInfo DateTimeFormatInfo info; CultureInfo cultureProvider = provider as CultureInfo; if (cultureProvider != null && !cultureProvider.m_isInherited) { return cultureProvider.DateTimeFormat; } // Fast case for a DTFI; info = provider as DateTimeFormatInfo; if (info != null) { return info; } // Wasn't cultureInfo or DTFI, do it the slower way if (provider != null) { info = provider.GetFormat(typeof(DateTimeFormatInfo)) as DateTimeFormatInfo; if (info != null) { return info; } } // Couldn't get anything, just use currentInfo as fallback return CurrentInfo; }
internal StringBuilder AppendFormatHelper(IFormatProvider provider, String format, ParamsArray args) { if (format == null) { throw new ArgumentNullException("format"); } Contract.Ensures(Contract.Result<StringBuilder>() != null); Contract.EndContractBlock(); int pos = 0; int len = format.Length; char ch = '\x0'; ICustomFormatter cf = null; if (provider != null) { cf = (ICustomFormatter)provider.GetFormat(typeof(ICustomFormatter)); } while (true) { while (pos < len) { ch = format[pos]; pos++; if (ch == '}') { if (pos < len && format[pos] == '}') // Treat as escape character for }} pos++; else FormatError(); } if (ch == '{') { if (pos < len && format[pos] == '{') // Treat as escape character for {{ pos++; else { pos--; break; } } Append(ch); } if (pos == len) break; pos++; if (pos == len || (ch = format[pos]) < '0' || ch > '9') FormatError(); int index = 0; do { index = index * 10 + ch - '0'; pos++; if (pos == len) FormatError(); ch = format[pos]; } while (ch >= '0' && ch <= '9' && index < 1000000); if (index >= args.Length) throw new FormatException(Environment.GetResourceString("Format_IndexOutOfRange")); while (pos < len && (ch = format[pos]) == ' ') pos++; bool leftJustify = false; int width = 0; if (ch == ',') { pos++; while (pos < len && format[pos] == ' ') pos++; if (pos == len) FormatError(); ch = format[pos]; if (ch == '-') { leftJustify = true; pos++; if (pos == len) FormatError(); ch = format[pos]; } if (ch < '0' || ch > '9') FormatError(); do { width = width * 10 + ch - '0'; pos++; if (pos == len) FormatError(); ch = format[pos]; } while (ch >= '0' && ch <= '9' && width < 1000000); } while (pos < len && (ch = format[pos]) == ' ') pos++; Object arg = args[index]; StringBuilder fmt = null; if (ch == ':') { pos++; while (true) { if (pos == len) FormatError(); ch = format[pos]; pos++; if (ch == '{') { if (pos < len && format[pos] == '{') // Treat as escape character for {{ pos++; else FormatError(); } else if (ch == '}') { if (pos < len && format[pos] == '}') // Treat as escape character for }} pos++; else { pos--; break; } } if (fmt == null) { fmt = new StringBuilder(); } fmt.Append(ch); } } if (ch != '}') FormatError(); pos++; String sFmt = null; String s = null; if (cf != null) { if (fmt != null) { sFmt = fmt.ToString(); } s = cf.Format(sFmt, arg, provider); } if (s == null) { IFormattable formattableArg = arg as IFormattable; if (formattableArg != null) { if (sFmt == null && fmt != null) { sFmt = fmt.ToString(); } s = formattableArg.ToString(sFmt, provider); } else if (arg != null) { s = arg.ToString(); } } if (s == null) s = String.Empty; int pad = width - s.Length; if (!leftJustify && pad > 0) Append(' ', pad); Append(s); if (leftJustify && pad > 0) Append(' ', pad); } return this; }
string IFormattable.ToString (string value, IFormatProvider formatProvider) { if (value == null) return ToString (formatProvider); if (formatProvider != null) { ICustomFormatter cp = (ICustomFormatter) formatProvider.GetFormat (typeof (ICustomFormatter)); if (cp != null) { return String.Format ("sc#{0}{1} {2}{3} {4}{5} {6}", cp.Format (value, A, formatProvider), cp.Format (value, ',', formatProvider), cp.Format (value, R, formatProvider), cp.Format (value, ',', formatProvider), cp.Format (value, G, formatProvider), cp.Format (value, ',', formatProvider), cp.Format (value, B, formatProvider)); } } return String.Format ("sc#{0}{1} {2}{3} {4}{5} {6}", A.ToString (value, formatProvider), ','.ToString (formatProvider), R.ToString (value, formatProvider), ','.ToString (formatProvider), G.ToString (value, formatProvider), ','.ToString (formatProvider), B.ToString (value, formatProvider)); }
public override string ToString(string format, IFormatProvider provider) { if (provider != null) { ICustomFormatter formatter = provider.GetFormat(GetType()) as ICustomFormatter; if (formatter != null) return formatter.Format(format, this, provider); } var builder = new System.Text.StringBuilder(); DoToString(builder, format, 0); return builder.ToString(); }
public string ToString (IFormatProvider provider) { if (provider == null) return ToString (); if (provider != null) { ICustomFormatter cp = (ICustomFormatter) provider.GetFormat (typeof (ICustomFormatter)); if (cp != null) { return String.Format ("#{0}{1}{2}{3}", cp.Format ("X2", A, provider), cp.Format ("X2", R, provider), cp.Format ("X2", G, provider), cp.Format ("X2", B, provider)); } } return String.Format ("#{0}{1}{2}{3}", A.ToString ("X2", provider), R.ToString ("X2", provider), G.ToString ("X2", provider), B.ToString ("X2", provider)); }
/// <include file='doc\DateTimeFormatInfo.uex' path='docs/doc[@for="DateTimeFormatInfo.GetInstance"]/*' /> public static DateTimeFormatInfo GetInstance(IFormatProvider provider) { if (provider != null) { Object service = provider.GetFormat(typeof(DateTimeFormatInfo)); if (service != null) return (DateTimeFormatInfo)service; } return (CurrentInfo); }
public sbyte ToSByte(IFormatProvider provider) { bool toMinValue = true; if (provider != null) { TestFormatProvider format = provider.GetFormat(typeof(TestFormatProvider)) as TestFormatProvider; if ((format != null) && format.ToSByteMaxValue) { toMinValue = false; } } if (toMinValue) { return SByte.MinValue; } else { return SByte.MaxValue; } }
private const int Width_Limit = 1000000; // Note: -Width_Limit < ArgAlign < Width_Limit internal StringBuilder AppendFormatHelper(IFormatProvider provider, String format, ParamsArray args) { if (format == null) { throw new ArgumentNullException("format"); } Contract.Ensures(Contract.Result<StringBuilder>() != null); Contract.EndContractBlock(); int pos = 0; int len = format.Length; char ch = '\x0'; StringBuilder unescapedItemFormat = null; ICustomFormatter cf = null; if (provider != null) { cf = (ICustomFormatter)provider.GetFormat(typeof(ICustomFormatter)); } while (true) { while (pos < len) { ch = format[pos]; pos++; // Is it a closing brace? if (ch == '}') { // Check next character (if there is one) to see if it is escaped. eg }} if (pos < len && format[pos] == '}') pos++; else // Otherwise treat it as an error (Mismatched closing brace) FormatError(); } // Is it a opening brace? if (ch == '{') { // Check next character (if there is one) to see if it is escaped. eg {{ if (pos < len && format[pos] == '{') pos++; else { // Otherwise treat it as the opening brace of an Argument Hole. pos--; break; } } // If it neither then treat the character as just text. Append(ch); } // // Start of parsing of Argument Hole. // Argument Hole ::= { Index (, WS* Alignment WS*)? (: Formatting)? } // if (pos == len) break; // // Start of parsing required Index parameter. // Index ::= ('0'-'9')+ WS* // pos++; // If reached end of text then error (Unexpected end of text) // or character is not a digit then error (Unexpected Character) if (pos == len || (ch = format[pos]) < '0' || ch > '9') FormatError(); int index = 0; do { index = index * 10 + ch - '0'; pos++; // If reached end of text then error (Unexpected end of text) if (pos == len) FormatError(); ch = format[pos]; // so long as character is digit and value of the index is less than 1000000 ( index limit ) } while (ch >= '0' && ch <= '9' && index < Index_Limit); // If value of index is not within the range of the arguments passed in then error (Index out of range) if (index >= args.Length) throw new FormatException(Environment.GetResourceString("Format_IndexOutOfRange")); // Consume optional whitespace. while (pos < len && (ch = format[pos]) == ' ') pos++; // End of parsing index parameter. // // Start of parsing of optional Alignment // Alignment ::= comma WS* minus? ('0'-'9')+ WS* // bool leftJustify = false; int width = 0; // Is the character a comma, which indicates the start of alignment parameter. if (ch == ',') { pos++; // Consume Optional whitespace while (pos < len && format[pos] == ' ') pos++; // If reached the end of the text then error (Unexpected end of text) if (pos == len) FormatError(); // Is there a minus sign? ch = format[pos]; if (ch == '-') { // Yes, then alignment is left justified. leftJustify = true; pos++; // If reached end of text then error (Unexpected end of text) if (pos == len) FormatError(); ch = format[pos]; } // If current character is not a digit then error (Unexpected character) if (ch < '0' || ch > '9') FormatError(); // Parse alignment digits. do { width = width * 10 + ch - '0'; pos++; // If reached end of text then error. (Unexpected end of text) if (pos == len) FormatError(); ch = format[pos]; // So long a current character is a digit and the value of width is less than 100000 ( width limit ) } while (ch >= '0' && ch <= '9' && width < Width_Limit); // end of parsing Argument Alignment } // Consume optional whitespace while (pos < len && (ch = format[pos]) == ' ') pos++; // // Start of parsing of optional formatting parameter. // Object arg = args[index]; String itemFormat = null; // Is current character a colon? which indicates start of formatting parameter. if (ch == ':') { pos++; int startPos = pos; while (true) { // If reached end of text then error. (Unexpected end of text) if (pos == len) FormatError(); ch = format[pos]; pos++; // Is character a opening or closing brace? if (ch == '}' || ch == '{') { if (ch == '{') { // Yes, is next character also a opening brace, then treat as escaped. eg {{ if (pos < len && format[pos] == '{') pos++; else // Error Argument Holes can not be nested. FormatError(); } else { // Yes, is next character also a closing brace, then treat as escaped. eg }} if (pos < len && format[pos] == '}') pos++; else { // No, then treat it as the closing brace of an Arg Hole. pos--; break; } } // Reaching here means the brace has been escaped // so we need to build up the format string in segments if (unescapedItemFormat == null) { unescapedItemFormat = new StringBuilder(); } unescapedItemFormat.Append(format, startPos, pos - startPos - 1); startPos = pos; } } if (unescapedItemFormat == null || unescapedItemFormat.Length == 0) { if (startPos != pos) { // There was no brace escaping, extract the item format as a single string itemFormat = format.Substring(startPos, pos - startPos); } } else { unescapedItemFormat.Append(format, startPos, pos - startPos); itemFormat = unescapedItemFormat.ToString(); unescapedItemFormat.Clear(); } } // If current character is not a closing brace then error. (Unexpected Character) if (ch != '}') FormatError(); // Construct the output for this arg hole. pos++; String s = null; if (cf != null) { s = cf.Format(itemFormat, arg, provider); } if (s == null) { IFormattable formattableArg = arg as IFormattable; if (formattableArg != null) { s = formattableArg.ToString(itemFormat, provider); } else if (arg != null) { s = arg.ToString(); } } // Append it to the final output of the Format String. if (s == null) s = String.Empty; int pad = width - s.Length; if (!leftJustify && pad > 0) Append(' ', pad); Append(s); if (leftJustify && pad > 0) Append(' ', pad); // Continue to parse other characters. } return this; }
public static DateTimeFormatInfo GetInstance(IFormatProvider provider) { if (provider != null) { DateTimeFormatInfo dtfi; dtfi = (DateTimeFormatInfo)provider.GetFormat(typeof(DateTimeFormatInfo)); if (dtfi != null) return dtfi; } return CurrentInfo; }
public static NumberFormatInfo GetInstance(IFormatProvider formatProvider) { // Fast case for a regular CultureInfo NumberFormatInfo info; CultureInfo cultureProvider = formatProvider as CultureInfo; if (cultureProvider != null && !cultureProvider.m_isInherited) { info = cultureProvider.numInfo; if (info != null) { return info; } else { return cultureProvider.NumberFormat; } } // Fast case for an NFI; info = formatProvider as NumberFormatInfo; if (info != null) { return info; } if (formatProvider != null) { info = formatProvider.GetFormat(typeof(NumberFormatInfo)) as NumberFormatInfo; if (info != null) { return info; } } return CurrentInfo; }
public StringBuilder AppendFormat(IFormatProvider provider, string format, params object[] args) { if (format == null || args == null) throw new ArgumentNullException(format == null ? "format" : "args"); int index1 = 0; int length = format.Length; char ch = char.MinValue; ICustomFormatter customFormatter = (ICustomFormatter) null; if (provider != null) customFormatter = (ICustomFormatter) provider.GetFormat(typeof (ICustomFormatter)); while (true) { bool flag; int repeatCount; do { if (index1 < length) { ch = format[index1]; ++index1; if ((int) ch == 125) { if (index1 < length && (int) format[index1] == 125) ++index1; else StringBuilder.FormatError(); } if ((int) ch == 123) { if (index1 >= length || (int) format[index1] != 123) --index1; else goto label_10; } else goto label_12; } if (index1 != length) { int index2 = index1 + 1; if (index2 == length || (int) (ch = format[index2]) < 48 || (int) ch > 57) StringBuilder.FormatError(); int index3 = 0; do { index3 = index3 * 10 + (int) ch - 48; ++index2; if (index2 == length) StringBuilder.FormatError(); ch = format[index2]; } while ((int) ch >= 48 && (int) ch <= 57 && index3 < 1000000); if (index3 >= args.Length) throw new FormatException(Environment.GetResourceString("Format_IndexOutOfRange")); while (index2 < length && (int) (ch = format[index2]) == 32) ++index2; flag = false; int num = 0; if ((int) ch == 44) { ++index2; while (index2 < length && (int) format[index2] == 32) ++index2; if (index2 == length) StringBuilder.FormatError(); ch = format[index2]; if ((int) ch == 45) { flag = true; ++index2; if (index2 == length) StringBuilder.FormatError(); ch = format[index2]; } if ((int) ch < 48 || (int) ch > 57) StringBuilder.FormatError(); do { num = num * 10 + (int) ch - 48; ++index2; if (index2 == length) StringBuilder.FormatError(); ch = format[index2]; } while ((int) ch >= 48 && (int) ch <= 57 && num < 1000000); } while (index2 < length && (int) (ch = format[index2]) == 32) ++index2; object obj = args[index3]; StringBuilder stringBuilder = (StringBuilder) null; if ((int) ch == 58) { int index4 = index2 + 1; while (true) { if (index4 == length) StringBuilder.FormatError(); ch = format[index4]; ++index4; if ((int) ch == 123) { if (index4 < length && (int) format[index4] == 123) ++index4; else StringBuilder.FormatError(); } else if ((int) ch == 125) { if (index4 < length && (int) format[index4] == 125) ++index4; else break; } if (stringBuilder == null) stringBuilder = new StringBuilder(); stringBuilder.Append(ch); } index2 = index4 - 1; } if ((int) ch != 125) StringBuilder.FormatError(); index1 = index2 + 1; string format1 = (string) null; string str = (string) null; if (customFormatter != null) { if (stringBuilder != null) format1 = ((object) stringBuilder).ToString(); str = customFormatter.Format(format1, obj, provider); } if (str == null) { IFormattable formattable = obj as IFormattable; if (formattable != null) { if (format1 == null && stringBuilder != null) format1 = ((object) stringBuilder).ToString(); str = formattable.ToString(format1, provider); } else if (obj != null) str = obj.ToString(); } if (str == null) str = string.Empty; repeatCount = num - str.Length; if (!flag && repeatCount > 0) this.Append(' ', repeatCount); this.Append(str); } else goto label_76; } while (!flag || repeatCount <= 0); goto label_75; label_10: ++index1; label_12: this.Append(ch); continue; label_75: this.Append(' ', repeatCount); } label_76: return this; }