Często zdarza się że podczas tworzenia aplikacji chcemy w odpowiednim formacie wyświetlić dane liczbowe, do tej czynności służy metoda Format klasy String. W metodzie String.Format(); w nawiasie ustalamy nasz styl wyświetlania liczby lub wiadomości.

Formatowanie wiadomości tekstowych

w metodzie String.Format(); w ciągu znaków między cudzysłowami ”dowolny tekst” możemy dodać w nawiasach klamrowych {} liczby począwszy od zera {0} {1}. Liczba w nawiasie klamrowym {liczba} oznacza, który parametr za przecinkiem w miejscu wystąpienia {liczba} ma być wyświetlony, liczenie parametrów zaczynamy liczyć od 0, zobaczmy przykład:

static void Main() {
 	string przykład =  String.Format("Na wypłatę w tym miesiącu dostanę: {0} przy czym moja premia wynosi: {1}",10000,200);
           Console.WriteLine();
           Console.WriteLine(przykład);     
           Console.ReadKey();
        } 

Wynik działania naszej aplikacji:

1

Oczywiście w miejsce naszych liczb, które daliśmy jako parametr, możemy użyć np. zmiennych czy metod z obiektu, które zwracają jakieś wartości lub własności danego obiektu:

Napiszmy prostą strukturę Car, która będzie się składać z dwóch pól prywatnych color oraz carBrand. Do struktury napiszemy dwie automatyczne własności abyśmy mieli możliwość odczytywać i zapisywać dane.

struct Car {
        private string color;
        private string carBrand;

        public string Color {
            get;
            set;
        }
        public string CarBrand {
            get;
            set;
        }        
    }

Użyjmy teraz naszej struktury w przykładzie:

   static void Main(string[] args) {

            Car carA = new Car();
            carA.Color = "czarny";
            carA.CarBrand = "fiat";
            
           string przykład =  String.Format("Mam samochód marki: {1},który ma kolor: {0}",carA.Color,carA.CarBrand);
           Console.WriteLine();
           Console.WriteLine(przykład);     
           Console.ReadKey();
        }

Rezultat działania naszej aplikacji:

2

Formatowanie liczb

W nawiasie klamrowym za liczbą określającą nr parametru po dwukropku {liczba:znak}, możemy dodać znak, który będzie odpowiadał za formatowanie liczb:
– C lub c – definiuje domyślną walutę.
Przykład:

static void Main() {
            string przykład = String.Format("Na wypłatę w tym miesiącu dostanę: {0:c} premia wynosi: {1:C}", 1000, 200);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

3

Jak widzimy dodany dostał dopisek zł oraz dopełniono liczbę do dwóch miejsc po przecinku, dodano separator.

– D lub d – formatowanie liczb dziesiętnych
Przykład:

   static void Main() {   
            string przykład = String.Format("Przykład1: {0:d} przykład2: {1:d}", 1000, 200);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

4

Po znaku formatującym d lub D możemy dodać minimalną liczbę cyfr, które wypełnią zapis {liczba:znakWypełnienie}

static void Main() {   
            string przykład = String.Format("Przykład1: {0:d10} przykład2: {1:d5}", 1000, 200);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

6

Jak widzimy przed liczbą 100 dodane zostały 0 tak aby uzupełnić zapis do 10 cyfr.
– F lub f – formatowanie liczb stało punktowych
Przykład:

class Program {
        static void Main() {
            string przykład = String.Format("Przykład1: {0:F} przykład2: {1:F}", 1000.12, 200.12);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }     
}

Oto rezultat działania naszej aplikacji:

6

Możemy po znaku określającym formatowanie dopisać liczbę, która będzie nam określać ile cyfr po przecinku będzie wyświetlane:

static void Main() {
            string przykład = String.Format("Przykład1: {0:F6} przykład2: {1:F0}", 1000.12, 200.99);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

7

Jak widzimy liczba 1000.12 została uzupełniona do 6 cyfr po przecinku. Liczba 200.99 została obcięta do 0 znaków po przecinku i automatycznie zaokrąglona do 201. Format ten nie dodaje separatora.
– N lub n – formatowanie liczb zmiennoprzecinkowych
Przykład:

static void Main() {
            string przykład = String.Format("Przykład1: {0:n} przykład2: {1:n}", 1000.4546, 200.91231239);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

8

Jak widzimy w przeciwieństwie do znaku formatującego f, został dodany separator. Nie wpisując znaku uzupełniającego cyfry po przecinku, automatycznie liczba zostaje zaokrąglona do dwóch znaków po przecinku.

– G lub g – formatuje liczbę do najbardziej zwartej notacji stałoprzecinkowej lub naukowej
Przykład:

static void Main() {
            string przykład = String.Format("Przykład1: {0:G4} przykład2: {1:G}", 123.4546, 200.99);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

9

Jak widzimy liczbę 123.4546 zaokrągliło nam do liczby 123.5

– X lub x – formatowanie szesnastkowe
Przykład:

static void Main() {
            string przykład = String.Format("Przykład1: {0:x} przykład2: {1:x}", 28, 16);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

10

Wpisując dużą literę X formatowana liczba szesnastkowa będzie zawierała duże litery:

static void Main() {
            string przykład = String.Format("Przykład1: {0:X} przykład2: {1:X}", 28, 16);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

11

Jak widzimy liczba 1C jest teraz wyświetlona z dużymi literami.
-P lub p formatowanie, które mnoży liczbę przez 100 i wyświetla ją z symbolem procentu
Przykład:

static void Main() {
            string przykład = String.Format("Przykład1: {0:p4} przykład2: {1:P}", 34, 0.02);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

12

Jak widzimy został dodany separator. Liczba wpisana po znaku formatowania odpowiada za ilość cyfr po przecinku w liczbie.

Inny typ zapisu

W nawiasie klamrowym po liczbie określającej parametr, możemy napisać dwukropek, a następnie zamiast znaku odpowiadającego za format liczby możemy wpisać własny format w następujący sposób:
{0:00000.00} pierwszy znak 0 oznacza kolejność parametru, znaki 0 przed kropką oznaczają do ilu cyfr liczba ma być uzupełniona, znaki 0 po kropce oznaczają ilość cyfr jakie mają być uzupełnione po przecinku, do ilu znaków liczba ma być zaokrąglona.
Przykład:

static void Main() {
            string przykład = String.Format("Przykład1: {0:0000000000.00} przykład2: {1:0.00}", 123123.876, 13232.12);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        } 

Oto rezultat działania naszej aplikacji:

13

Jak widzimy nasza liczba została uzupełniona do właściwej liczby cyfr oraz została prawidłowo zaokrąglona.
Znaki 0 możemy zastąpić dowolnym innym znakiem uzupełnienia pamięta.
Możemy dodać separator poprzez dopisanie symbolu przecinka w następujący sposób: {0:0,0.00}
Przykład:

 static void Main() {
            string przykład = String.Format("Przykład1: {0:0,0.00} przykład2: {1:0.00}", 1123123.876, 13232.12);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

14

Jak widzimy został dodany separator w przypadku pierwszej liczby.
Zamiast 0 możemy dodać znak # różnica polega na tym, że po dodaniu znaku # liczba nie zostaje uzupełniona, oto przykład:

static void Main() {
            string przykład = String.Format("Przykład1: {0:0,0.0000} przykład2: {1:0,0.####}", 1123123.876, 1123123.876);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

15

Inny przykład:

static void Main() {
            string przykład = String.Format("Przykład1: {0:#.##} przykład2: {1:#.#}", 0.036, 0.0);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }
 

pop13
Jak widzimy w przypadku pierwszej liczby nie uzupełniło nam całości do 1 cyfry i została wyświetlona wartość po przecinku. W przypadku drugiej liczby nie została uzupełniona cyfra, która odpowiada za całości jak i wartości dziesiętne, przez co nie zostało nic wyświetlone.
Zmieniając znaki # na 0 otrzymamy:

16

Znaki między cyframi

W metodzie Format klasy String możemy dodać znaki między cyframi w liczbie. W nawiasie klamrowym pomiędzy znakami # lub cyfrą 0 możemy dopisywać własne znaki lub tekst oto przykład:

static void Main() {
            string przykład = String.Format("Przykład1: {0:###-###-###} przykład2: {1:#^##V###@##} ", 232897678, 89387676.01);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

17

Liczby ujemne lub wartość zerowa

W metodzie Format klasy String możemy określić co zostanie wyświetlone w przypadku gdy liczba będzie ujemna lub gdy będzie zerem. Zobaczmy przykład:
– liczby ujemne możemy zapisać w następujący sposób {(liczba określająca parametr):(znak # lub 0); (dowolny znak czy napis zastępujący znak -) (standardowe formatowanie cyfr)}

static void Main() {
            string przykład = String.Format("Przykład1: {0:#;minus 0.00} przykład2: {1:0.0}", -10.036, -1000.0);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

18

Jak widzimy znak – został zastąpiony napisem minus.
Bez użycia znaku ; otrzymamy zapis z znakiem – oraz napisem minus

19

– wartość zerową możemy zapisać w następujący sposób { (liczba określająca parametr): (znak # lub 0);(znak – lub napis w przypadku liczb ujemnych)(standardowe formatowanie cyfr); (dowolny znak lub napis zastępujący wartość 0)) Przykład:

static void Main() {
            string przykład = String.Format("Przykład1: {0:#;minus 0.00;nic} przykład2: {1:#;minus 0.00;nic}", 0.0, -1000.0);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

20

Jak widzimy w przypadku liczby 0 otrzymujemy napis nic . W przypadku liczby drugiej liczby, która jest ujemna dostajemy zamiast znaku – napis minus
– Możemy określić aby liczby dodatnie i ujemne oraz zero zostały wyświetlane jako napisy :

static void Main() {
            string przykład = String.Format("Przykład1: {0:Dodatnia;Ujemna;Zero} przykład2: {1:Dodatnia;Ujemna;Zero} przykład3: {2:Dodatnia;Ujemna;Zero} ", 10.0, 0.0, -100);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

21

Marginesy (puste znaki)

W metodzie Format klasy String możemy dodać puste znaki z prawej lub lewej strony liczby . W nawiasie klamrowym po liczbie określającej parametr piszemy przecinek, a następnie liczbę, która określa ilość pustych znaków. Dodatnia liczba określa lewą stronę, ujemna prawą, oto przykład:

static void Main() {
            string przykład = String.Format("Przykład1: {0,-10:0.0} przykład2: {1,10:0.0} przykład3: {2:0.0} ", 10.0, 0.0, -100);
            Console.WriteLine();
            Console.WriteLine(przykład);
            Console.ReadKey();
        }

Oto rezultat działania naszej aplikacji:

22

Podsumowanie
Metoda Format klasy Sting daje nam dużo możliwości odnośnie formatowania liczb. Dzięki jej zastosowaniu możemy wyświetlać taki komunikat jaki nas interesuje. Pamiętajmy, że metody