NumberFormatInfo.CurrencyNegativePattern Propriedade

Definição

Obtém ou define o padrão de formato para valores negativos de moeda.

public:
 property int CurrencyNegativePattern { int get(); void set(int value); };
public int CurrencyNegativePattern { get; set; }
member this.CurrencyNegativePattern : int with get, set
Public Property CurrencyNegativePattern As Integer

Valor da propriedade

O padrão de formato para valores negativos de moeda. O padrão para InvariantInfo é 0, que representa "($n)", em que "$" é o CurrencySymbol e n é um número.

Exceções

A propriedade é definida como um valor menor que 0 ou maior que 16. No .NET Core 3.1 e em versões anteriores, essa exceção será gerada se o valor for maior que 15.

A propriedade está sendo definida e o objeto NumberFormatInfo é somente leitura.

Exemplos

O exemplo a seguir mostra como a CurrencyNegativePattern propriedade define o formato de valores de moeda negativos. Ele recupera todas as culturas específicas definidas no computador host e exibe o valor da propriedade de CurrencyNegativePattern cada cultura, seu padrão associado e um número formatado como um valor de moeda.

using System;
using System.Collections.Generic;
using System.Globalization;

public class Example : IComparer<CultureInfo>
{
   public static void Main()
   {
      // Assign possible values and their associated patterns to a
      // generic Dictionary object.
      Dictionary<int, String> patterns = new Dictionary<int, String>();
      string[] patternStrings= { "($n)", "-$n", "$-n", "$n-", "(n$)",
                                 "-n$", "n-$", "n$-", "-n $", "-$ n",
                                 "n $-", "$ n-", "$ -n", "n- $", "($ n)",
                                 "(n $)", "$- n" };
      for (int ctr = patternStrings.GetLowerBound(0);
           ctr <= patternStrings.GetUpperBound(0); ctr++)
         patterns.Add(ctr, patternStrings[ctr]);

      // Retrieve all specific cultures.
      CultureInfo[] cultures = CultureInfo.GetCultures(CultureTypes.SpecificCultures);
      Array.Sort(cultures, new Example());

      double number = -16.335;
      // Display the culture, CurrencyNegativePattern value, associated pattern, and result.
      foreach (var culture in cultures)
         Console.WriteLine("{0,-15} {1,2} ({2,5}) {3,15}", culture.Name + ":",
                           culture.NumberFormat.CurrencyNegativePattern,
                           patterns[culture.NumberFormat.CurrencyNegativePattern],
                           number.ToString("C", culture));
   }

   public int Compare(CultureInfo x, CultureInfo y)
   {
      return String.Compare(x.Name, y.Name);
   }
}
// A portion of the output appears as follows:
//       ca-ES:           8 ( -n $)        -16,34 €
//       co-FR:           8 ( -n $)        -16,34 €
//       cs-CZ:           8 ( -n $)       -16,34 Kč
//       cy-GB:           1 (  -$n)         -£16.34
//       da-DK:          12 ( $ -n)      kr. -16,34
//       de-AT:           9 ( -$ n)        -€ 16,34
//       de-CH:           2 (  $-n)       Fr.-16.34
//       de-DE:           8 ( -n $)        -16,34 €
//       de-LI:           2 (  $-n)       CHF-16.34
//       de-LU:           8 ( -n $)        -16,34 €
//       dsb-DE:          8 ( -n $)        -16,34 €
//       luy-KE:         16 ( $- n)      Ksh- 16.34
//
// The result shown here happens only if using ICU.
// Apps that use NLS, for example, .NET Framework apps, might see different results.
// Globalization data can change, which would also change these results.
Imports System.Collections.Generic
Imports System.Globalization

Public Class Example : Implements IComparer(Of CultureInfo)
   Public Shared Sub Main()
      ' Assign possible values and their associated patterns to a 
      ' generic Dictionary object.
      Dim patterns As New Dictionary(Of Integer, String)
      Dim patternStrings() As String = { "($n)", "-$n", "$-n", "$n-", "(n$)", 
                                         "-n$", "n-$", "n$-", "-n $", "-$ n",
                                         "n $-", "$ n-", "$ -n", "n- $", "($ n)",
                                         "(n $)", "$- n" }    
      For ctr As Integer = patternStrings.GetLowerBound(0) To patternStrings.GetUpperBound(0)
         patterns.Add(ctr, patternStrings(ctr))
      Next

      ' Retrieve all specific cultures.
      Dim cultures() As CultureInfo = CultureInfo.GetCultures(CultureTypes.SpecificCultures)
      Array.Sort(cultures, New Example())
      
      Dim number As Double = -16.335
      ' Display the culture, CurrencyNegativePattern value, associated pattern, and result.
      For Each culture In cultures
         Console.WriteLine("{0,-15} {1,2} ({2,5}) {3,15}", culture.Name + ":", 
                           culture.NumberFormat.CurrencyNegativePattern,
                           patterns.Item(culture.NumberFormat.CurrencyNegativePattern),
                           number.ToString("C", culture))
      Next
   End Sub
   
   Public Function Compare(x As CultureInfo, y As CultureInfo) As Integer _
                           Implements IComparer(Of CultureInfo).Compare
      Return String.Compare(x.Name, y.Name)                           
   End Function                           
End Class
' A portion of the output appears as follows:
'       ca-ES:           8 ( -n $)        -16,34 €
'       co-FR:           8 ( -n $)        -16,34 €
'       cs-CZ:           8 ( -n $)       -16,34 Kč
'       cy-GB:           1 (  -$n)         -£16.34
'       da-DK:          12 ( $ -n)      kr. -16,34
'       de-AT:           9 ( -$ n)        -€ 16,34
'       de-CH:           2 (  $-n)       Fr.-16.34
'       de-DE:           8 ( -n $)        -16,34 €
'       de-LI:           2 (  $-n)       CHF-16.34
'       de-LU:           8 ( -n $)        -16,34 €
'       dsb-DE:          8 ( -n $)        -16,34 €
'       luy-KE:         16 ( $- n)      Ksh- 16.34
'
' The result shown here happens only if using ICU.
' Apps that use NLS, for example, .NET Framework apps, might see different results.
' Globalization data can change, which would also change these results.

Comentários

A CurrencyNegativePattern propriedade é usada com a cadeia de caracteres de formato padrão "C" para definir o padrão de valores de moeda negativos. Para obter mais informações, confira Cadeias de caracteres de formato numérico padrão. Essa propriedade tem um dos valores na tabela a seguir. O símbolo "$" é o CurrencySymbol, o símbolo "-" é o NegativeSigne n é um número.

Valor Padrão associado
0 ($n)
1 -$n
2 $-n
3 $n-
4 (n$)
5 -n$
6 n-$
7 n$-
8 -n $
9 -$ n
10 n $-
11 $ n-
12 $ -n
13 n- $
14 ($ n)
15 (n $)
16 $- n

Aplica-se a

Confira também