IsFormatApplicable() private méthode

Gets value indicating whether this format provider is applicable to format strings that represent instances of given data type. This format provider is applicable if dataType is array.
private IsFormatApplicable ( Type dataType ) : bool
dataType System.Type Data type for which this format provider is tested.
Résultat bool
Exemple #1
0
        /// <summary>
        ///     Converts the value of a specified object to an equivalent string representation using
        ///     specified format and culture-specific formatting information.
        /// </summary>
        /// <param name="sb">String builder to which formatted string should be appended.</param>
        /// <param name="format">A format string containing formatting specifications.</param>
        /// <param name="arg">An object to format.</param>
        /// <param name="formatProvider">An object that supplies format information about the current instance.</param>
        /// <param name="maxLength">
        ///     Maximum number of characters allowed to the formatter. Formatting should fail (and return false)
        ///     if this number of characters is breached. Multi-lined formatters should ignore this parameter.
        ///     Negative value indicates that formatter has unlimited space available. On output contains remaining number of characters available.
        /// </param>
        /// <returns>
        ///     true if representation of <paramref name="arg" /> has been successfully appended to <paramref name="sb" />
        ///     within given number of allowed characters; otherwise false.
        /// </returns>
        internal override bool Format(StringBuilder sb, string format, object arg, IFormatProvider formatProvider, ref int maxLength)
        {
            var success        = true;
            var originalLength = sb.Length;

            var formatters        = new List <VerboseFormatInfoBase>();
            var singleLinedFormat = SingleLinedFormat;

            if (arg != null || InstanceDataType != null)
            {
                var type = GetInstanceType(arg);

                var sfi = new ScalarFormatInfo(this);
                sfi.MaximumFormattedLength = maxLength;

                if (sfi.IsFormatApplicable(type))
                {
                    if (IsMultiLinedFormat)
                    {
                        var singleLinedSfi = new ScalarFormatInfo(this);
                        FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedSfi);
                        singleLinedSfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
                        formatters.Add(singleLinedSfi);
                    }

                    formatters.Add(sfi);
                }

                if (formatters.Count == 0)
                {
                    var dfi = new DictionaryFormatInfo(this);
                    dfi.MaximumFormattedLength = maxLength;

                    if (dfi.IsFormatApplicable(type))
                    {
                        if (IsMultiLinedFormat)
                        {
                            var singleLinedDfi = new DictionaryFormatInfo(this);
                            FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedDfi);
                            singleLinedDfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
                            formatters.Add(singleLinedDfi);
                        }
                        formatters.Add(dfi);
                    }
                }

                if (formatters.Count == 0)
                {
                    var cmfi = new CompactMatrixFormatInfo(this);
                    cmfi.MaximumFormattedLength = maxLength;

                    if (cmfi.IsFormatApplicable(type))
                    {
                        //if (IsMultiLinedFormat)   // Uncomment these lines to enable inlining compactly presented matrices; that operation is not suggested
                        //{
                        //    CompactMatrixFormatInfo singleLinedCmfi = new CompactMatrixFormatInfo(this);
                        //    FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedCmfi);
                        //    singleLinedCmfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
                        //    formatters.Add(singleLinedCmfi);
                        //}
                        formatters.Add(cmfi);
                    }
                }

                if (formatters.Count == 0)
                {
                    var cafi = new CompactArrayFormatInfo(this);
                    cafi.MaximumFormattedLength = maxLength;

                    if (cafi.IsFormatApplicable(type))
                    {
                        if (IsMultiLinedFormat)
                        {
                            var singleLinedCafi = new CompactArrayFormatInfo(this);
                            FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedCafi);
                            singleLinedCafi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
                            formatters.Add(singleLinedCafi);
                        }
                        formatters.Add(cafi);
                    }
                }

                if (formatters.Count == 0)
                {
                    var afi = new ArrayFormatInfo(this);
                    afi.MaximumFormattedLength = maxLength;

                    if (afi.IsFormatApplicable(type))
                    {
                        if (IsMultiLinedFormat)
                        {
                            var singleLinedAfi = new ArrayFormatInfo(this);
                            FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedAfi);
                            singleLinedAfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
                            formatters.Add(singleLinedAfi);
                        }
                        formatters.Add(afi);
                    }
                }

                if (formatters.Count == 0)
                {
                    var efi = new EnumerableFormatInfo(this);
                    efi.MaximumFormattedLength = maxLength;

                    if (efi.IsFormatApplicable(type))
                    {
                        if (IsMultiLinedFormat)
                        {
                            var singleLinedEfi = new EnumerableFormatInfo(this);
                            FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedEfi);
                            singleLinedEfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
                            formatters.Add(singleLinedEfi);
                        }
                        formatters.Add(efi);
                    }
                }

                if (formatters.Count == 0)
                {
                    if (IsMultiLinedFormat)
                    {
                        var singleLinedGfi = new GeneralFormatInfo(this);
                        FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedGfi);
                        singleLinedGfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
                        formatters.Add(singleLinedGfi);
                    }

                    var gfi = new GeneralFormatInfo(this);
                    gfi.MaximumFormattedLength = maxLength;

                    formatters.Add(gfi);
                }
            }

            if (formatters.Count > 0)
            {
                success = success && FormatInfoUtils.BestTryFormat(sb, format, arg, formatters, ref maxLength);
            }

            if (!success)
            {
                sb.Length = originalLength;
            }

            return(success);
        }
		/// <summary>
		///     Converts the value of a specified object to an equivalent string representation using
		///     specified format and culture-specific formatting information.
		/// </summary>
		/// <param name="sb">String builder to which formatted string should be appended.</param>
		/// <param name="format">A format string containing formatting specifications.</param>
		/// <param name="arg">An object to format.</param>
		/// <param name="formatProvider">An object that supplies format information about the current instance.</param>
		/// <param name="maxLength">
		///     Maximum number of characters allowed to the formatter. Formatting should fail (and return false)
		///     if this number of characters is breached. Multi-lined formatters should ignore this parameter.
		///     Negative value indicates that formatter has unlimited space available. On output contains remaining number of characters available.
		/// </param>
		/// <returns>
		///     true if representation of <paramref name="arg" /> has been successfully appended to <paramref name="sb" />
		///     within given number of allowed characters; otherwise false.
		/// </returns>
		internal override bool Format(StringBuilder sb, string format, object arg, IFormatProvider formatProvider, ref int maxLength)
		{
			var success = true;
			var originalLength = sb.Length;

			var formatters = new List<VerboseFormatInfoBase>();
			var singleLinedFormat = SingleLinedFormat;

			if (arg != null || InstanceDataType != null)
			{
				var type = GetInstanceType(arg);

				var sfi = new ScalarFormatInfo(this);
				sfi.MaximumFormattedLength = maxLength;

				if (sfi.IsFormatApplicable(type))
				{
					if (IsMultiLinedFormat)
					{
						var singleLinedSfi = new ScalarFormatInfo(this);
						FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedSfi);
						singleLinedSfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
						formatters.Add(singleLinedSfi);
					}

					formatters.Add(sfi);
				}

				if (formatters.Count == 0)
				{
					var dfi = new DictionaryFormatInfo(this);
					dfi.MaximumFormattedLength = maxLength;

					if (dfi.IsFormatApplicable(type))
					{
						if (IsMultiLinedFormat)
						{
							var singleLinedDfi = new DictionaryFormatInfo(this);
							FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedDfi);
							singleLinedDfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
							formatters.Add(singleLinedDfi);
						}
						formatters.Add(dfi);
					}
				}

				if (formatters.Count == 0)
				{
					var cmfi = new CompactMatrixFormatInfo(this);
					cmfi.MaximumFormattedLength = maxLength;

					if (cmfi.IsFormatApplicable(type))
					{
						//if (IsMultiLinedFormat)   // Uncomment these lines to enable inlining compactly presented matrices; that operation is not suggested
						//{
						//    CompactMatrixFormatInfo singleLinedCmfi = new CompactMatrixFormatInfo(this);
						//    FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedCmfi);
						//    singleLinedCmfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
						//    formatters.Add(singleLinedCmfi);
						//}
						formatters.Add(cmfi);
					}
				}

				if (formatters.Count == 0)
				{
					var cafi = new CompactArrayFormatInfo(this);
					cafi.MaximumFormattedLength = maxLength;

					if (cafi.IsFormatApplicable(type))
					{
						if (IsMultiLinedFormat)
						{
							var singleLinedCafi = new CompactArrayFormatInfo(this);
							FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedCafi);
							singleLinedCafi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
							formatters.Add(singleLinedCafi);
						}
						formatters.Add(cafi);
					}
				}

				if (formatters.Count == 0)
				{
					var afi = new ArrayFormatInfo(this);
					afi.MaximumFormattedLength = maxLength;

					if (afi.IsFormatApplicable(type))
					{
						if (IsMultiLinedFormat)
						{
							var singleLinedAfi = new ArrayFormatInfo(this);
							FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedAfi);
							singleLinedAfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
							formatters.Add(singleLinedAfi);
						}
						formatters.Add(afi);
					}
				}

				if (formatters.Count == 0)
				{
					var efi = new EnumerableFormatInfo(this);
					efi.MaximumFormattedLength = maxLength;

					if (efi.IsFormatApplicable(type))
					{
						if (IsMultiLinedFormat)
						{
							var singleLinedEfi = new EnumerableFormatInfo(this);
							FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedEfi);
							singleLinedEfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
							formatters.Add(singleLinedEfi);
						}
						formatters.Add(efi);
					}
				}

				if (formatters.Count == 0)
				{
					if (IsMultiLinedFormat)
					{
						var singleLinedGfi = new GeneralFormatInfo(this);
						FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedGfi);
						singleLinedGfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
						formatters.Add(singleLinedGfi);
					}

					var gfi = new GeneralFormatInfo(this);
					gfi.MaximumFormattedLength = maxLength;

					formatters.Add(gfi);
				}
			}

			if (formatters.Count > 0)
			{
				success = success && FormatInfoUtils.BestTryFormat(sb, format, arg, formatters, ref maxLength);
			}

			if (!success)
			{
				sb.Length = originalLength;
			}

			return success;
		}