IFormatProvider.GetFormat メソッドとは？ わかりやすく解説

Weblio 辞書 > コンピュータ > .NET Framework クラス ライブラリ リファレンス > IFormatProvider.GetFormat メソッドの意味・解説 
.NET Framework クラス ライブラリ リファレンス
索引トップ 用語の索引 ランキング
日本マイクロソフト株式会社日本マイクロソフト株式会社

IFormatProvider.GetFormat メソッド

指定された型の書式指定サービスを提供するオブジェクトを取得します。

名前空間: System
アセンブリ: mscorlib (mscorlib.dll 内)
構文構文

Visual Basic (宣言)
Function GetFormat ( _
    formatType As Type _
) As Object
Visual Basic (使用法)
Dim instance As IFormatProvider
Dim formatType As Type
Dim returnValue As Object

returnValue = instance.GetFormat(formatType)
C#
Object GetFormat (
    Type formatType
)
C++
Object^ GetFormat (
    Type^ formatType
)
J#
Object GetFormat (
    Type formatType
)
JScript
function GetFormat (
    formatType : Type
) : Object

パラメータ

formatType

取得対象となる書式オブジェクトの型を指定するオブジェクト。

戻り値
formatType が現在のインスタンスと同じ型の場合は、現在のインスタンス。それ以外の場合は null 参照 (Visual Basic では Nothing)。

解説解説

このメソッドは、オブジェクトの文字列形式を生成または解析するメソッドにおいて、書式オブジェクトを使用するクラスに実装します。ToString メソッドと Parse メソッドは、そのようなメソッドの例です。

詳細については、CultureInfo.CurrentCulture のトピックを参照してください。

使用例使用例

次のコード例は、IFormatProvider インターフェイスと GetFormat メソッドを実装したクラスの使用方法を示したものです。AnyRadix クラスは、"Ra" 書式設定コードをサポートし、Int64 の値を 2 ～ 36 の指定された基数の文字列に変換します。GetFormat は、Type パラメータが ICustomFormatter を実装したクラスを参照している場合は、自分自身への参照を返します。それ以外の場合、GetFormat は null 参照 (Visual Basic では Nothing) を返します。

Visual Basic
' Sample for the IFormatProvider interface and
' the IFormatProvider.GetFormat( Type ) method.
Imports System
Imports Microsoft.VisualBasic

' This class implements the "Ra" formatting code. An instance
 of this 
' class should be passed to methods requiring an IFormatProvider.
Public Class AnyRadix
    Implements ICustomFormatter 
    Implements IFormatProvider

    ' The value to be formatted is returned as a signed string 
    ' of digits from the rDigits array. 
    Const radixCode As String
 = "Ra"
    Private Shared rDigits As
 Char( ) = { _
        "0"c, "1"c,
 "2"c, "3"c, "4"c,
 "5"c, "6"c, "7"c, "8"c, _
        "9"c, "A"c,
 "B"c, "C"c, "D"c,
 "E"c, "F"c, "G"c, "H"c, _
        "I"c, "J"c,
 "K"c, "L"c, "M"c,
 "N"c, "O"c, "P"c, "Q"c, _
        "R"c, "S"c,
 "T"c, "U"c, "V"c,
 "W"c, "X"c, "Y"c, "Z"c }
        
    ' This method returns an object that implements ICustomFormatter
 
    ' to do the formatting. 
    Public Function GetFormat( argType As
 Type ) As Object _
        Implements IFormatProvider.GetFormat

        ' Here, the same object (Me) is returned, but it would be 
        ' possible to return an object of a different type.
        If argType Is GetType(
 ICustomFormatter ) Then
            Return Me
        Else
            Return Nothing
        End If
    End Function 
        
    ' This method does the formatting only if it recognizes the 
    ' format codes. 
    Public Function Format( formatString As
 String, _
        argToBeFormatted As Object, _
        provider As IFormatProvider ) As String
 _
        Implements ICustomFormatter.Format
            
        ' If no format string is provided or the format string cannot
 
        ' be handled, use IFormattable or standard string processing.
        If formatString Is Nothing
 OrElse _
            Not formatString.Trim( ).StartsWith( radixCode ) Then

            If TypeOf argToBeFormatted Is
 IFormattable Then
                Return CType( argToBeFormatted, IFormattable ).
 _
                    ToString( formatString, provider )
            Else
                Return argToBeFormatted.ToString( )
            End If
        End If 

        ' The formatting is handled here.
        Dim digitIndex          As Integer
 = 0
        Dim radix               As Long
 
        Dim longToBeFormatted   As Long
 
        Dim longPositive        As Long
        Dim outDigits( 63 )     As Char
            
        ' Extract the radix from the format string.
        formatString = formatString.Replace( radixCode, ""
 )
        Try
            radix = Convert.ToInt64( formatString )
        Catch ex As Exception
            Throw New ArgumentException( String.Format(
 _
                "The radix ""{0}""
 is invalid.", _
                formatString ), ex )
        End Try

        ' Verify that the radix is in the proper range.
        If radix < 2 OrElse radix > 36
 Then
            Throw New ArgumentException( String.Format(
 _
                "The radix ""{0}""
 is not in the range 2..36.", _
                formatString ) )
        End If
            
        ' Verify that the argument can be converted to a long integer.
        Try
            longToBeFormatted = CType( argToBeFormatted, Long
 )
        Catch ex As Exception
            Throw New ArgumentException( String.Format(
 _
                "The argument ""{0}""
 cannot be " & _
                "converted to an integer value.",
 _
                argToBeFormatted ), ex )
        End Try
            
        ' Extract the magnitude for conversion.
        longPositive = Math.Abs( longToBeFormatted )

        ' Convert the magnitude to a digit string.
        For digitIndex = 0 To 64
            If longPositive = 0 Then Exit
 For

            outDigits( outDigits.Length - digitIndex - 1 ) = _
                rDigits( longPositive Mod radix )
            longPositive \= radix
        Next digitIndex
            
        ' Add a minus sign if the argument is negative.
        If longToBeFormatted < 0 Then
            outDigits( outDigits.Length - digitIndex - 1 ) = "-"c
 
            digitIndex += 1
        End If 

        Return New String(
 outDigits, _
            outDigits.Length - digitIndex, digitIndex )
    End Function 
End Class

Module IFormatProviderDemo
    
    Sub ConvertToAnyRadix( argToConvert As
 Object, _
        formatStr As String )

        Dim provider As New
 AnyRadix( )
        Dim messageStr As String
 = _
            String.Format( "{{0:{0}}}",
 formatStr )

        ' Write the first part of the output line.
        Console.Write( "{0,18}  {1,-6}", _ 
            argToConvert, formatStr )

        ' Convert the specified argument using the specified format.
        Try
            Console.WriteLine( String.Format( _
                provider, messageStr, argToConvert ) )
        Catch ex As Exception
            Dim lineEnd As Integer
 = _
                ex.ToString( ).IndexOf( vbLf )
            Console.WriteLine( _
                ex.ToString( ).Substring( 0, lineEnd ) )
            Console.WriteLine( )
        End Try
    End Sub 
        
    Sub Main( )
        Dim TwoToThe32      As Long
 = 4294967296
        Dim fifteenNines    As Long
 = 999999999999999
            
        Console.WriteLine( _
            "This example of the IFormatProvider interface "
 & _
            vbCrLf & "and the IFormatProvider."
 & _
            "GetFormat( Type ) method " & vbCrLf
 & _
            "generates the following output." &
 vbCrLf )
        Console.WriteLine( "{0,18} Format Result",
 "Number" )
        Console.WriteLine( "{0,18} ------ ------",
 "------" )
            
        ' These are valid conversions.
        ConvertToAnyRadix( TwoToThe32, "Ra2" )
        ConvertToAnyRadix( TwoToThe32, "Ra5" )
        ConvertToAnyRadix( TwoToThe32, "Ra16" )
        ConvertToAnyRadix( TwoToThe32, "Ra23" )
        ConvertToAnyRadix( TwoToThe32, "Ra36" )
        ConvertToAnyRadix( fifteenNines, "Ra2" )
        ConvertToAnyRadix( fifteenNines, "Ra3" )
        ConvertToAnyRadix( fifteenNines, "Ra8" )
        ConvertToAnyRadix( fifteenNines, "Ra11" )
        ConvertToAnyRadix( fifteenNines, "Ra16" )
        ConvertToAnyRadix( fifteenNines, "Ra23" )
        ConvertToAnyRadix( fifteenNines, "Ra36" )
        ConvertToAnyRadix( fifteenNines, "E16" )
        ConvertToAnyRadix( fifteenNines, "" )
            
        ' These are error conditions.
        ConvertToAnyRadix( fifteenNines, "Ra37" )
        ConvertToAnyRadix( "ABCDEFGHIJKLM", "Ra16"
 )
    End Sub 
End Module 

' This example of the IFormatProvider interface
' and the IFormatProvider.GetFormat( Type ) method
' generates the following output.
' 
'             Number Format Result
'             ------ ------ ------
'         4294967296  Ra2   100000000000000000000000000000000
'         4294967296  Ra5   32244002423141
'         4294967296  Ra16  100000000
'         4294967296  Ra23  1606K7IC
'         4294967296  Ra36  1Z141Z4
'    999999999999999  Ra2   11100011010111111010100100110001100111111111111111
'    999999999999999  Ra3   11212010201001210101011021212000
'    999999999999999  Ra8   34327724461477777
'    999999999999999  Ra11  26A6A3689065639
'    999999999999999  Ra16  38D7EA4C67FFF
'    999999999999999  Ra23  1134DIFHLMM4
'    999999999999999  Ra36  9UGXNORJLR
'    999999999999999  E16   9.9999999999999900E+014
'    999999999999999        999999999999999
'    999999999999999  Ra37  System.ArgumentException: The radix "37"
 is not in
' the range 2..36.
' 
'      ABCDEFGHIJKLM  Ra16  System.ArgumentException: The argument "ABCDEFGHIJK
' LM" cannot be converted to an integer value. ---> System.InvalidCastException
' : Cast from string "ABCDEFGHIJKLM" to type 'Long' is not
 valid. ---> System.F
' ormatException: Input string was not in a correct format.
C#
// Sample for the IFormatProvider interface and
// the IFormatProvider.GetFormat( Type ) method.
using System;

// This class implements the "Ra" formatting code. An instance
 of this 
// class should be passed to methods requiring an IFormatProvider.
public class AnyRadix : ICustomFormatter, IFormatProvider
{
    // The value to be formatted is returned as a signed string 
    // of digits from the rDigits array. 
    const string radixCode = "Ra";
    private static char[]
 rDigits = {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 
        'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 
        'U', 'V', 'W', 'X', 'Y', 'Z' };
        
    // This method returns an object that implements ICustomFormatter
 
    // to do the formatting. 
    public object GetFormat( Type argType )
    {
        // Here, the same object (this) is returned, but it would 
        // be possible to return an object of a different type.
        if ( argType == typeof( ICustomFormatter ) )
            return this;
        else
            return null;
    } 
        
    // This method does the formatting only if it recognizes the 
    // format codes. 
    public string Format( string
 formatString, 
        object argToBeFormatted, IFormatProvider provider )
    {
        // If no format string is provided or the format string cannot
 
        // be handled, use IFormattable or standard string processing.
        if( formatString == null || 
            ! formatString.Trim( ).StartsWith( radixCode ) )
        {
            if( argToBeFormatted is IFormattable )
                return ( (IFormattable)argToBeFormatted ).
                    ToString( formatString, provider );
            else
                return argToBeFormatted.ToString( );
        }

        // The formatting is handled here.
        int     digitIndex = 0;
        long    radix;
        long    longToBeFormatted;
        long    longPositive;
        char[ ] outDigits = new char[
 63 ];
            
        // Extract the radix from the format string.
        formatString = formatString.Replace( radixCode, "" );
        try
        {
            radix = Convert.ToInt64( formatString );
        }
        catch( Exception ex )
        {
            throw new ArgumentException( String.Format( 
                "The radix \"{0}\" is invalid.", 
                formatString ), ex );
        }

        // Verify that the radix is in the proper range.
        if( radix <2 || radix > 36 )
            throw new ArgumentException( String.Format( 
                "The radix \"{0}\" is not in the
 range 2..36.", 
                formatString ) );
            
        // Verify that the argument can be converted to a long integer.
        try
        {
            longToBeFormatted = (long)argToBeFormatted;
        }
        catch( Exception ex )
        {
            throw new ArgumentException( String.Format(
                "The argument \"{0}\" cannot be " +
                "converted to an integer value.", 
                argToBeFormatted ), ex );
        }
            
        // Extract the magnitude for conversion.
        longPositive = Math.Abs( longToBeFormatted );

        // Convert the magnitude to a digit string.
        for( digitIndex = 0; digitIndex <= 64; digitIndex++
 )
        {
            if( longPositive == 0 ) break;

            outDigits[ outDigits.Length - digitIndex - 1 ] = 
                rDigits[ longPositive % radix ];
            longPositive /= radix;
        }
            
        // Add a minus sign if the argument is negative.
        if( longToBeFormatted < 0 )
            outDigits[ outDigits.Length - digitIndex++ - 1 ] = 
                '-';

        return new string(
 outDigits, 
            outDigits.Length - digitIndex, digitIndex );
    } 
} 

class IFormatProviderDemo
{
    static void ConvertToAnyRadix( object argToConvert,
 
        string formatStr )
    {
        AnyRadix    provider = new AnyRadix( );
        string      messageStr = 
            String.Format( "{{0:{0}}}", formatStr );

        // Write the first part of the output line.
        Console.Write( "{0,18}  {1,-6}", argToConvert, formatStr );

        // Convert the specified argument using the specified format.
        try
        {
            Console.WriteLine( String.Format( 
                provider, messageStr, argToConvert ) );
        }
        catch( Exception ex )
        {
            // Display the exception without the stack trace.
            int lineEnd = ex.ToString( ).IndexOf( '\n' );
            Console.WriteLine( "{0}\n",
                ex.ToString( ).Substring( 0, lineEnd ) );
        }
    } 
        
    static void Main( )
    {
        long twoToThe32 = 4294967296;
        long fifteenNines = 999999999999999;
            
        Console.WriteLine(
            "This example of the IFormatProvider interface \n" +
            "and the IFormatProvider.GetFormat( Type ) method " +
            "\ngenerates the following output.\n" );
        Console.WriteLine( "{0,18} Format Result", "Number" );
        Console.WriteLine( "{0,18} ------ ------", "------" );
            
        // These are valid conversions.
        ConvertToAnyRadix( twoToThe32, "Ra2" );
        ConvertToAnyRadix( twoToThe32, "Ra5" );
        ConvertToAnyRadix( twoToThe32, "Ra16" );
        ConvertToAnyRadix( twoToThe32, "Ra23" );
        ConvertToAnyRadix( twoToThe32, "Ra36" );
        ConvertToAnyRadix( fifteenNines, "Ra2" );
        ConvertToAnyRadix( fifteenNines, "Ra3" );
        ConvertToAnyRadix( fifteenNines, "Ra8" );
        ConvertToAnyRadix( fifteenNines, "Ra11" );
        ConvertToAnyRadix( fifteenNines, "Ra16" );
        ConvertToAnyRadix( fifteenNines, "Ra23" );
        ConvertToAnyRadix( fifteenNines, "Ra36" );
        ConvertToAnyRadix( fifteenNines, "E16" );
        ConvertToAnyRadix( fifteenNines, "" );
            
        // These are error conditions.
        ConvertToAnyRadix( fifteenNines, "Ra37" );
        ConvertToAnyRadix( "ABCDEFGHIJKLM", "Ra16" );
    } 
} 

/*
This example of the IFormatProvider interface
and the IFormatProvider.GetFormat( Type ) method
generates the following output.

            Number Format Result
            ------ ------ ------
        4294967296  Ra2   100000000000000000000000000000000
        4294967296  Ra5   32244002423141
        4294967296  Ra16  100000000
        4294967296  Ra23  1606K7IC
        4294967296  Ra36  1Z141Z4
   999999999999999  Ra2   11100011010111111010100100110001100111111111111111
   999999999999999  Ra3   11212010201001210101011021212000
   999999999999999  Ra8   34327724461477777
   999999999999999  Ra11  26A6A3689065639
   999999999999999  Ra16  38D7EA4C67FFF
   999999999999999  Ra23  1134DIFHLMM4
   999999999999999  Ra36  9UGXNORJLR
   999999999999999  E16   9.9999999999999900E+014
   999999999999999        999999999999999
   999999999999999  Ra37  System.ArgumentException: The radix "37" is not
 in th
e range 2..36.

     ABCDEFGHIJKLM  Ra16  System.ArgumentException: The argument "ABCDEFGHIJKLM
" cannot be converted to an integer value. ---> System.InvalidCastException:
 Sp
ecified cast is not valid.
*/
C++
// Sample for the IFormatProvider interface and
// the IFormatProvider::GetFormat( Type* ) method.
using namespace System;

// This class implements the "Ra" formatting code. An instance
 of this 
// class should be passed to methods requiring an IFormatProvider.
ref class AnyRadix: public IFormatProvider,
 public ICustomFormatter
{
private:
   static Object^ null = nullptr;

   // The value to be formatted is returned as a signed string 
   // of digits from the rDigits array. 
   static String^ radixCode = "Ra";
   static array<Char>^rDigits = {'0','1','2','3','4','5'
,'6','7','8','9','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P'
,'Q','R','S','T','U','V','W','X','Y','Z'};

public:

   // This method returns an object that implements ICustomFormatter
 
   // to do the formatting. 
   virtual Object^ GetFormat( Type^ argType )
   {
      
      // Here, the same object (this) is returned, but it would 
      // be possible to return an object of a different type.
      if ( argType == ICustomFormatter::typeid )
            return this;
      else
            return null;
   }


   // This method does the formatting only if it recognizes the 
   // format codes. 
   virtual String^ Format( String^ formatString, Object^ argToBeFormatted, IFormatProvider^
 provider )
   {
      
      // If no format string is provided or the format string cannot
 
      // be handled, use IFormattable or standard string processing.
      if ( formatString == null ||  !formatString->Trim()->StartsWith(
 radixCode ) )
      {
         if ( dynamic_cast<IFormattable^>(argToBeFormatted)
 != nullptr )
                  return static_cast<IFormattable^>(argToBeFormatted)->ToString(
 formatString, provider );
         else
                  return argToBeFormatted->ToString();
      }

      
      // The formatting is handled here.
      int digitIndex = 0;
      __int64 radix;
      __int64 longToBeFormatted;
      __int64 longPositive;
      array<Char>^outDigits = gcnew array<Char>(64);
      
      // Extract the radix from the format string.
      formatString = formatString->Replace( radixCode,  "" );
      try
      {
         radix = Convert::ToInt64( formatString );
      }
      catch ( Exception^ ex ) 
      {
         throw gcnew ArgumentException( String::Format( "The radix \"{0}\"
 is invalid.\n", formatString ),ex );
      }

      
      // Verify that the radix is in the proper range.
      if ( radix < 2 || radix > 36 )
            throw gcnew ArgumentException( String::Format( "The radix \"{0}\"
 is not in the range 2..36.", formatString ) );

      
      // Verify that the argument can be converted to a long integer.
      try
      {
         longToBeFormatted =  *static_cast<__int64^>(argToBeFormatted);
      }
      catch ( Exception^ ex ) 
      {
         throw gcnew ArgumentException( String::Format( "The argument \"{0}\"
 cannot be "
         "converted to an integer value.", argToBeFormatted ),ex );
      }

      
      // Extract the magnitude for conversion.
      longPositive = Math::Abs( longToBeFormatted );
      
      // Convert the magnitude to a digit string.
      for ( digitIndex = 0; longPositive != 0 && digitIndex
 <= 64; digitIndex++ )
      {
         outDigits[ outDigits->Length - digitIndex - 1 ] = rDigits[ longPositive
 % radix ];
         longPositive /= radix;

      }
      
      // Add a minus sign if the argument is negative.
      if ( longToBeFormatted < 0 )
            outDigits[ outDigits->Length - digitIndex++ - 1 ] = '-';

      return gcnew String( outDigits,outDigits->Length - digitIndex,digitIndex
 );
   }

};

void ConvertToAnyRadix( Object^ argToConvert, String^ formatStr
 )
{
   AnyRadix^ provider = gcnew AnyRadix;
   String^ messageStr = String::Format( "{{0:{0}}}", formatStr );
   
   // Write the first part of the output line.
   Console::Write( "{0,18}  {1,-6}", argToConvert, formatStr );
   
   // Convert the specified argument using the specified format.
   try
   {
      array<Object^>^argArray = {argToConvert};
      Console::WriteLine( String::Format( provider, messageStr, argArray ) );
   }
   catch ( Exception^ ex ) 
   {
      
      // Display the exception without the stack trace.
      int lineEnd = ex->ToString()->IndexOf( '\n' );
      Console::WriteLine( "{0}\n", ex->ToString()->Substring( 0,
 lineEnd ) );
   }

}

int main()
{
   __int64 twoToThe32 = 4294967296;
   __int64 fifteenNines = 999999999999999;
   Console::WriteLine( "This example of the IFormatProvider interface \n"
   "and the IFormatProvider::GetFormat( Type* ) method "
   "\ngenerates the following output.\n" );
   Console::WriteLine( "{0,18} Format Result", "Number" );
   Console::WriteLine( "{0,18} ------ ------", "------" );
   
   // These are valid conversions.
   ConvertToAnyRadix( twoToThe32, "Ra2" );
   ConvertToAnyRadix( twoToThe32, "Ra5" );
   ConvertToAnyRadix( twoToThe32, "Ra16" );
   ConvertToAnyRadix( twoToThe32, "Ra23" );
   ConvertToAnyRadix( twoToThe32, "Ra36" );
   ConvertToAnyRadix( fifteenNines, "Ra2" );
   ConvertToAnyRadix( fifteenNines, "Ra3" );
   ConvertToAnyRadix( fifteenNines, "Ra8" );
   ConvertToAnyRadix( fifteenNines, "Ra11" );
   ConvertToAnyRadix( fifteenNines, "Ra16" );
   ConvertToAnyRadix( fifteenNines, "Ra23" );
   ConvertToAnyRadix( fifteenNines, "Ra36" );
   ConvertToAnyRadix( fifteenNines, "E16" );
   ConvertToAnyRadix( fifteenNines, "" );
   
   // These are error conditions.
   ConvertToAnyRadix( fifteenNines, "Ra37" );
   ConvertToAnyRadix( "ABCDEFGHIJKLM", "Ra16" );
}

/*
This example of the IFormatProvider interface
and the IFormatProvider::GetFormat( Type* ) method
generates the following output.

            Number Format Result
            ------ ------ ------
        4294967296  Ra2   100000000000000000000000000000000
        4294967296  Ra5   32244002423141
        4294967296  Ra16  100000000
        4294967296  Ra23  1606K7IC
        4294967296  Ra36  1Z141Z4
   999999999999999  Ra2   11100011010111111010100100110001100111111111111111
   999999999999999  Ra3   11212010201001210101011021212000
   999999999999999  Ra8   34327724461477777
   999999999999999  Ra11  26A6A3689065639
   999999999999999  Ra16  38D7EA4C67FFF
   999999999999999  Ra23  1134DIFHLMM4
   999999999999999  Ra36  9UGXNORJLR
   999999999999999  E16   9.9999999999999900E+014
   999999999999999        999999999999999
   999999999999999  Ra37  System.ArgumentException: The radix "37" is not
 in th
e range 2..36.

     ABCDEFGHIJKLM  Ra16  System.ArgumentException: The argument "ABCDEFGHIJKLM
" cannot be converted to an integer value. ---> System.InvalidCastException:
 Sp
ecified cast is not valid.
*/
J#
// Sample for the IFormatProvider interface and
// the IFormatProvider.GetFormat( Type ) method.
import System.*;

// This class implements the "Ra" formatting code. An instance
 of this
// class should be passed to methods requiring an IFormatProvider.
public class AnyRadix implements ICustomFormatter
,IFormatProvider
{
    // The value to be formatted is returned as a signed string 
    // of digits from the rDigits array. 
    private String radixCode = "Ra";
    private static char
 rDigits[] = {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 
        'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 
        'U', 'V', 'W', 'X', 'Y', 'Z' };
   
    // This method returns an object that implements ICustomFormatter
 
    // to do the formatting. 
    public Object GetFormat(Type argType)
    {
        // Here, the same object (this) is returned, but it would 
        // be possible to return an object of a different type.
        if ( argType.Equals(ICustomFormatter.class.ToType())
 ) {
            return this ;
        }
        else {
            return null ;
        }
    } //GetFormat
    
    // This method does the formatting only if it recognizes the 
    // format codes. 
    public String Format(String formatString, Object argToBeFormatted
,
                        IFormatProvider provider) 
    {
        // If no format string is provided or the format string cannot
 
        // be handled, use IFormattable or standard string processing.
        if(formatString == null||!(formatString.Trim().StartsWith(radixCode)))
 {
            if ( argToBeFormatted instanceof IFormattable  ) {
                return((IFormattable)(argToBeFormatted)).
                    ToString(formatString,provider);
            }
            else {
                return argToBeFormatted.ToString();
            }
        }

        // The formatting is handled here.
        int digitIndex = 0;
        long radix;
        long longToBeFormatted;
        long longPositive;
        char outDigits[] = new char[63];
      
        // Extract the radix from the format string.
        formatString = formatString.Replace(radixCode, "");
        try {
            radix = Convert.ToInt64(formatString);
        }
        catch(System.Exception  ex) {
            throw new ArgumentException(String.Format(
                "The radix \"{0}\" is invalid.", formatString),
 ex);
        }
      
        // Verify that the radix is in the proper range.
        if ( radix < 2 || radix > 36  ) {
            throw new ArgumentException(String.Format(
                "The radix \"{0}\" is not in the
 range 2..36.", formatString));
        }
      
        // Verify that the argument can be converted to a long integer.
        try {
            longToBeFormatted =(long)System.Convert.ToUInt64(argToBeFormatted);
        }
        catch(System.Exception  ex) {
            throw new ArgumentException(String.Format(
                "The argument \"{0}\" cannot be "
                + "converted to an integer value.", argToBeFormatted),
 ex);
        }
      
        // Extract the magnitude for conversion.
        longPositive = System.Math.Abs(longToBeFormatted);

        // Convert the magnitude to a digit string.
        for(digitIndex = 0;digitIndex <= 64;digitIndex++) {
            if ( longPositive == 0  ) {
                break ;
            }        
            outDigits[outDigits.length - digitIndex - 1] = 
                rDigits[(int)(longPositive % radix)];
            longPositive /= radix;
        }      
        // Add a minus sign if the argument is negative.
        if ( longToBeFormatted < 0  ) {
            outDigits [outDigits.length - digitIndex ++ - 1] = '-';
        }      
        return new String(outDigits, outDigits.length
 - digitIndex, digitIndex);
    } //Format
} //AnyRadix

class IFormatProviderDemo
{   
    static void ConvertToAnyRadix(Object argToConvert,
 String formatStr) 
    {
        AnyRadix provider = new AnyRadix();        
        String messageStr = String.Format("{{0:{0}}}", formatStr);
        
        // Write the first part of the output line.
        Console.Write("{0,18}  {1,-6}", argToConvert, formatStr);
        
        // Convert the specified argument using the specified format.
        try {
            Console.WriteLine(String.Format((IFormatProvider)provider,
                messageStr,new Object[]{ argToConvert}));
        }
        catch(System.Exception ex) {
            // Display the exception without the stack trace.
            int lineEnd = ex.ToString().IndexOf('\n');       
     
            Console.WriteLine("{0}\n", ex.ToString().Substring(0, lineEnd));
        }
    } //ConvertToAnyRadix  
   
    public static void main(String[]
 args)
    {
        long twoToThe32 = 4294967296L;
        long fifteenNines = 999999999999999L;

        Console.WriteLine(("This example of the IFormatProvider interface \n"
            + "and the IFormatProvider.GetFormat( Type ) method "
            + "\ngenerates the following output.\n"));
        Console.WriteLine("{0,18} Format Result", "Number");
        Console.WriteLine("{0,18} ------ ------", "------");

        // These are valid conversions.
        ConvertToAnyRadix(((System.UInt64 )(twoToThe32)), "Ra2");
        ConvertToAnyRadix(((System.UInt64)(twoToThe32)), "Ra5");
        ConvertToAnyRadix(((System.UInt64)(twoToThe32)), "Ra16");
        ConvertToAnyRadix(((System.UInt64)(twoToThe32)), "Ra23");
        ConvertToAnyRadix(((System.UInt64)(twoToThe32)), "Ra36");
        ConvertToAnyRadix(((System.UInt64)(fifteenNines)), "Ra2");
        ConvertToAnyRadix(((System.UInt64)(fifteenNines)), "Ra3");
        ConvertToAnyRadix(((System.UInt64)(fifteenNines)), "Ra8");
        ConvertToAnyRadix(((System.UInt64)(fifteenNines)), "Ra11");
        ConvertToAnyRadix(((System.UInt64)(fifteenNines)), "Ra16");
        ConvertToAnyRadix(((System.UInt64)(fifteenNines)), "Ra23");
        ConvertToAnyRadix(((System.UInt64)(fifteenNines)), "Ra36");
        ConvertToAnyRadix(((System.UInt64)(fifteenNines)), "E16");
        ConvertToAnyRadix(((System.UInt64)(fifteenNines)), "");

        // These are error conditions.
        ConvertToAnyRadix(((System.UInt64)(fifteenNines)), "Ra37");
        ConvertToAnyRadix("ABCDEFGHIJKLM", "Ra16");
    } //main
} //IFormatProviderDemo

/*
This example of the IFormatProvider interface
and the IFormatProvider.GetFormat( Type ) method
generates the following output.

            Number Format Result
            ------ ------ ------
        4294967296  Ra2   100000000000000000000000000000000
        4294967296  Ra5   32244002423141
        4294967296  Ra16  100000000
        4294967296  Ra23  1606K7IC
        4294967296  Ra36  1Z141Z4
   999999999999999  Ra2   11100011010111111010100100110001100111111111111111
   999999999999999  Ra3   11212010201001210101011021212000
   999999999999999  Ra8   34327724461477777
   999999999999999  Ra11  26A6A3689065639
   999999999999999  Ra16  38D7EA4C67FFF
   999999999999999  Ra23  1134DIFHLMM4
   999999999999999  Ra36  9UGXNORJLR
   999999999999999  E16   9.9999999999999900E+014
   999999999999999        999999999999999
   999999999999999  Ra37  System.ArgumentException: The radix "37" is not
 in th
e range 2..36.

     ABCDEFGHIJKLM  Ra16  System.ArgumentException: The argument "ABCDEFGHIJKLM"
 cannot be converted to an integer value. ---> System.FormatException: Input str
ing was not in a correct format.
*/
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0、1.0
参照参照
関連項目
IFormatProvider インターフェイス
IFormatProvider メンバ
System 名前空間

急上昇のことば

亀田京之介
親の心子知らず!?
くぱぁ
福本亜細亜
ソルジャー
このページでは「.NET Framework クラス ライブラリ リファレンス」からIFormatProvider.GetFormat メソッドを検索した結果を表示しています。
Weblioに収録されているすべての辞書からIFormatProvider.GetFormat メソッドを検索する場合は、下記のリンクをクリックしてください。
 全ての辞書からIFormatProvider.GetFormat メソッド を検索
英和和英テキスト翻訳>> Weblio翻訳
英語⇒日本語日本語⇒英語
  

辞書ショートカット

カテゴリ一覧

全て

＋ ビジネス

＋ 業界用語

＋ コンピュータ

＋ 電車

＋ 自動車・バイク

＋ 船

＋ 工学

＋ 建築・不動産

＋ 学問

＋ 文化

＋ 生活

＋ ヘルスケア

＋ 趣味

＋ スポーツ

＋ 生物

＋ 食品

＋ 人名

＋ 方言

＋ 辞書・百科事典

すべての辞書の索引

あいうえお
かきくけこ
さしすせそ
たちつてと
なにぬねの
はひふへほ
まみむめも
やゆよ
らりるれろ
わをん
がぎぐげご
ざじずぜぞ
だぢづでど
ばびぶべぼ
ぱぴぷぺぽ
ＡＢＣＤＥ
ＦＧＨＩＪ
ＫＬＭＮＯ
ＰＱＲＳＴ
ＵＶＷＸＹ
Ｚ
１２３４５
６７８９０
記号

Weblioのサービス

「IFormatProvider.GetFormat メソッド」の関連用語

1
DateTimeFormatInfo.GetInstance メソッド
.NET Framework クラス ライブラリ リファレンス
58% |||||

2
NumberFormatInfo.GetInstance メソッド
.NET Framework クラス ライブラリ リファレンス
58% |||||

3
DateTimeFormatInfo.GetFormat メソッド
.NET Framework クラス ライブラリ リファレンス
52% |||||

4
NumberFormatInfo.GetFormat メソッド
.NET Framework クラス ライブラリ リファレンス
52% |||||

5
CultureInfo.GetFormat メソッド
.NET Framework クラス ライブラリ リファレンス
38% |||||

6
IFormatProvider インターフェイス
.NET Framework クラス ライブラリ リファレンス
36% |||||

7
Convert.ToString メソッド
.NET Framework クラス ライブラリ リファレンス
12% |||||

8
Convert.ToChar メソッド
.NET Framework クラス ライブラリ リファレンス
10% |||||

9
Convert.ToDateTime メソッド
.NET Framework クラス ライブラリ リファレンス
6% |||||

10
Convert.ToUInt16 メソッド
.NET Framework クラス ライブラリ リファレンス
6% |||||

IFormatProvider.GetFormat メソッドのお隣キーワード

IFolderProjectItem.AddDocument メソッド

IFolderProjectItem.AddFolder メソッド

IFolderProjectItem.Children プロパティ

IFormatProvider インターフェイス

IFormatProvider メソッド

IFormatProvider メンバ

IFormatProvider.GetFormat メソッド

IFormattable インターフェイス

IFormattable メソッド

IFormattable メンバ

IFormattable.ToString メソッド

IFormatter.Binder プロパティ

IFormatter.Context プロパティ

検索ランキング

   

 英語⇒日本語
日本語⇒英語		    


IFormatProvider.GetFormat メソッドのページの著作権
Weblio 辞書 情報提供元は 参加元一覧 にて確認できます。

   
日本マイクロソフト株式会社日本マイクロソフト株式会社
© 2025 Microsoft.All rights reserved.

©2025 GRAS Group, Inc.RSS