Personalizando Sequências de Caracteres de Formato
O .NET estrutura oferece suporte para estender seu mecanismo de formatação interno para que você possa criar seus próprios ToString método que aceita seqüências de caracteres de formato definido pelo usuário ou crie um provedor de formato que chama sua própria Format método para executar a formatação personalizada de um tipo. Criar seu próprio ToString método Implementando o IFormattable interface e seu próprio Format método Implementando o ICustomFormatter e IFormatProvider interfaces.
As informações contidas nesta seção são limitadas a adicionar sequências de caracteres de formato personalizado definidos pelo usuário e tipos base existentes, mas os princípios descritos podem ser aplicados a qualquer tipo.
Adicionando sequências de formato personalizado para tipos personalizados
Se você criar seu próprio tipo personalizado, você pode adicionar suporte para o processamento de suas próprias seqüências de formato personalizado, Implementando o IFormattable Essa interface e ToString método. Isso significa que você pode controlar quais sequências de formato são reconhecidas pelo seu tipo personalizado.O benefício da implementação da interface IFormattable em vez de simplesmente adicionar um método ToString para seu tipo personalizado é que você pode garantir aos usuários sintaxe predefinidas de chamada e tipo de retorno do seu método ToString.
O método ToString da interface IFormattable utiliza um parâmetro de sequência de caracteres de formato e um parâmetro provedor de formato.Se o parâmetro de sequência de formato for uma sequência de caracteres vazia ou Null ( Nothing no Visual Basic), é executada a formatação padrão.Se o provedor de formato for null, use um provedor de formato padrão.
Se uma sequência de caracteres de formato personalizado é passada para sua versão personalizada do ToString, é executada a formatação adequada; caso contrário, é chamado um método do .NET Framework adequado para executar a formatação padrão.
No exemplo a seguir, o tipo personalizado MyType implementa a interface IFormattable.Se você criar uma nova instância da classe MyType e passar a sequência de caracteres de formato personalizado "b" para a instância do método ToString, uma sobrecarga do Convert.ToString retorna a representação binária da sequência de caracteres (base 2) do valor da instância.Se "b" não for passado, o valor da instância é formatado por seu próprio método ToString; ou seja, o inteiro myValue é formatado pelo método System.Int32.ToString.
Public Class MyType
Implements IFormattable
' Assign a value for the class.
Private myValue As Integer
' Add a constructor.
Public Sub New(value As Integer)
myValue = value
End Sub
' Write a custom Format method for the type.
Public Overloads Function ToString(format As String, _
fp As IFormatProvider) As String _
Implements IFormattable.ToString
If format.Equals("b") Then
Return Convert.ToString(myValue, 2)
Else
Return myValue.ToString(format, fp)
End If
End Function
End Class
public class MyType : IFormattable
{
// Assign a value for the class.
private int myValue;
// Add a constructor.
public MyType( int value )
{
myValue = value;
}
// Write a custom Format method for the type.
public string ToString(string format, IFormatProvider fp)
{
if (format.Equals ("b"))
{
return Convert.ToString (myValue, 2);
}
else
{
return myValue.ToString(format, fp);
}
}
}
O exemplo a seguir demonstra como a classe MyType e a sequência de caracteres de formato "b" são usados.
Dim mtype As New MyType(42)
Dim myString As String = mtype.ToString("b", Nothing)
Dim yourString As String = mtype.ToString("d", Nothing)
Console.WriteLine(myString)
Console.WriteLine(yourString)
' The example produces the following output:
' 101010
' 42
MyType mtype = new MyType(42);
String myString = mtype.ToString("b", null);
String yourString = mtype.ToString("d", null);
Console.WriteLine(myString);
Console.WriteLine(yourString);
// The example produces the following output:
// 101010
// 42
Adicionando sequências de formato personalizado ao tipos existentes
Você pode controlar como um tipo base existente é formatado e fornecer códigos adicionais para a formatação, criando um classe provedora de formato que implementa ICustomFormatter e IFormatProvider.
Quando você passa um provedor de formato para o métodobToStringde um tipo base, esse tipo usa o provedor de formato passado para definir suas regras de formatação ao invés do provedor de formato padrão.Para criar um provedor de formato personalizado, você deve fazer o seguinte:
Define uma classe que implementa as duas interfaces mencionadas anteriormente e substitui GetFormat e Format.
Passa essa classe em um método (como String.Format) que leva o IFormatProvider como um parâmetro.Isso faz com que String.Format reconheça o esquema do formato personalizado na classe do provedor do novo formato.
O exemplo a seguir define uma classe que adiciona um método Format personalizado que pode produzir diferentes valores base de um número inteiro.
Public Class MyFormat
Implements IFormatProvider
Implements ICustomFormatter
' String.Format calls this method to get an instance of an
' ICustomFormatter to handle the formatting.
Public Function GetFormat(service As Type) As Object _
Implements IFormatProvider.GetFormat
If service.ToString() = GetType(ICustomFormatter).ToString() Then
Return Me
Else
Return Nothing
End If
End Function
' After String.Format gets the ICustomFormatter, it calls this format
' method on each argument.
Public Function Format(theformat As String, arg As Object, _
provider As IFormatProvider) As String _
Implements ICustomFormatter.Format
If theformat Is Nothing Then
Return String.Format("{0}", arg)
End If
Dim i As Integer = theformat.Length
' If the object to be formatted supports the IFormattable
' interface, pass the format specifier to the
' objects ToString method for formatting.
If Not theformat.StartsWith("B") Then
' If the object to be formatted supports the IFormattable
' interface, pass the format specifier to the
' objects ToString method for formatting.
If TypeOf arg Is IFormattable Then
return CType(arg, IFormattable).ToString(theformat, provider)
' If the object does not support IFormattable,
' call the objects ToString method with no additional
' formatting.
ElseIf (arg Is Nothing) Then
return arg.ToString()
End If
End If
' Uses the format string to
' form the output string.
theformat = theformat.Trim(New Char() {"B"c})
Dim b As Integer = Convert.ToInt32(theformat)
Return Convert.ToString(CInt(arg), b)
End Function
End Class
public class MyFormat : IFormatProvider, ICustomFormatter
{
// String.Format calls this method to get an instance of an
// ICustomFormatter to handle the formatting.
public object GetFormat (Type service)
{
if (service == typeof (ICustomFormatter))
{
return this;
}
else
{
return null;
}
}
// After String.Format gets the ICustomFormatter, it calls this format
// method on each argument.
public string Format(string format, object arg, IFormatProvider provider)
{
if (format == null)
{
return String.Format ("{0}", arg);
}
// If the format is not a defined custom code,
// use the formatting support in ToString.
if (!format.StartsWith("B"))
{
//If the object to be formatted supports the IFormattable
//interface, pass the format specifier to the
//objects ToString method for formatting.
if (arg is IFormattable)
{
return ((IFormattable)arg).ToString(format, provider);
}
//If the object does not support IFormattable,
//call the objects ToString method with no additional
//formatting.
else if (arg != null)
{
return arg.ToString();
}
}
// Uses the format string to
// form the output string.
format = format.Trim (new char [] {'B'});
int b = Convert.ToInt32 (format);
return Convert.ToString ((int)arg, b);
}
}
No exemplo a seguir, a Format método usa o custom Formato método definidoMyFormat Para exibir a representação de 16 base do MyInt.
Dim myInt As Integer = 42
Dim myString As String = String.Format(New MyFormat(), _
"{0} in the custom B16 format is {1:B16}", _
New Object() {MyInt, MyInt})
Console.WriteLine(myString)
' The example displays the following output:
' 42 in the custom B16 format is 2a
int MyInt = 42;
string myString = String.Format(new MyFormat(),
"{0} in the custom B16 format is {1:B16}",
new object[] {MyInt, MyInt});
Console.WriteLine(myString);
// The example displays the following output:
// 42 in custom B16 format is 2a