Největší číslo

1. NejvetsiZe2Cisel

Vytvořte aplikaci pro porovnání dvou zadaných celých čísel provedeného v hlavním programu a zároveň pomocí podprogramu. Vypište v konzoli největší hodnotu z těchto zadaných čísel.

Účel příkladu

• Podmínka

Typ aplikace

• Konzolová aplikace

Popis úkolu 

• Porovnání dvou zadaných celých čísel 

Funkčnosti

• V konzolové aplikaci se v hlavním programu provede porovnání dvou zadaných celých čísel
• Dále se provede porovnání pomocí zavolaného podprogramu (funkce), který bude porovnávat dvě předaná čísla
• V konzoli se vypíše, které číslo je největší

Výstup programu

Výstup programu: Ukázka výpisu hodnot v hlavní metodě programu NejvetsiZe2Cisel

1.1. Analýza a návrh řešení

Nabízí se triviální řešení, jak bychom tento příklad řešili v pseudokódu:

pokud a > b potom 
     "a je největší";
jinak 
     "b je největší";

Na základě předchozí pseudokódu lze vytvořit následující vývojový diagram - viz Obrázek 1.

Obrázek 1: Porovnání dvou zadaných čísel (bez rovnosti) v hlavním programu (bez volání podprogramu)

Efektivnější způsob porovnání čísel je vytvořit si podprogram (funkci) na určení většího čísla ze dvou - viz Obrázek 2.

Obrázek 2: Podprogram (funkce) Vetsi

V hlavním programu můžeme využít návrat funkce přímo pro výpis výsledku v textu - viz Obrázek 3.

Obrázek 3: Porovnání dvou čísel v hlavním programu a volání podprogramu (funkce) Vetsi v hlavním programu

1.2. C# kód

Následující zdrojový kód hlavní statické metody v C# pro konzolovou aplikaci je transformací algoritmu NejvetsiZe2Cisel - viz Kód 1.  Tělo hlavní metody v sobě zahrnuje porovnání dvou zadaných celých čísel bez použití volání jiné metody. Dále zdrojový kód zahrnuje volání metody Vetsi s celočíselným návratem většího ze dvou přijímaných celých čísel v podobě formálních parametrů předaných hodnotou. Jednotlivé sekce porovnání zadaných čísel jsou od sebe odděleny výpisy, abychom věděli, která část zdrojového kódu byla pro porovnání použita.

static void Main(string[] args)
{
    // Deklarace: 'a' ... první zadané celé číslo; 'b' ... druhé zadané celé číslo
    int a, b;
    
    //Výzva k zadání
    Console.Write("Zadejte a: ");
    // Načtení prvního celého čísla
    a = int.Parse(Console.ReadLine());
    //Výzva k zadání
    Console.Write("Zadejte b: ");
    // Načtení druhého celého čísla
    b = int.Parse(Console.ReadLine());
    // Výpis textu pro oddělení porovnání v hlavním programu
    Console.WriteLine("Porovnání dvou čísel v hlavním programu:");
    
    // Test, zda první číslo je větší než druhé
    if (a > b)
    {
        // První číslo je větší než druhé
        Console.WriteLine("Největší je: " + a);
    }
    else
    {
        // Druhé číslo je větší než první
        Console.WriteLine("Největší je: " + b);
    }
    
    // Výpis textu pro oddělení porovnání provedeného pomocí zavolání podprogramu
    Console.WriteLine("Porovnání dvou čísel pomocí podprogramu:");
 
    // Vypsání textu spolu s návratem funkce (výsledek porovnání)
    Console.Write("Největší je: " + Vetsi(a, b));
 
    //Čekání na stisk klávesy -> ukončení programu
    Console.ReadKey();
}

Kód 1: Program NejvetsiZe2Cisel - deklarace hlavní statické metody Main 

V těle metody Vetsi je provedeno porovnání  dvou předaných celých čísel - viz Kód 2. Tato čísla nejsou testována na rovnost. Návratem funkce je větší z těchto dvou čísel. 

// Metoda s celočíselným návratem
// 'x' ... první celé číslo; 'y' ... druhé celé číslo
static int Vetsi(int x, int y)
{
    //Deklarace lokální proměnné
    int z;
    // Test, zda první předané číslo je větší než druhé
    if (x > y)
    {
        // První číslo je větší než druhé, výsledek funkce je první číslo
        z = x;
    }
    else
    {
        // Druhé číslo je větší než první, výsledek funkce je druhé číslo
        z = y;
    }            
    //Návrat většího čísla
    return z;
}

Kód 2: Deklarace statické metody s návratem s názvem Vetsi

Metodu bychom samozřejmě mohli zkrátit, tj. nepoužívat lokální proměnnou, ale návratu metody rovnou přiřadit větší číslo - viz Kód 3.

static int Vetsi(int x, int y)
{
    // Test, zda první předané číslo je větší než druhé
    if (x > y)
        // První číslo je větší než druhé, návrat funkce je první číslo
        return x;
    else
        // Druhé číslo je větší než první, návrat funkce je druhé číslo
        return y;
}

Kód 3: Deklarace statické metody s návratem s názvem Vetsi - bez použití lokální proměnné

Celou předchozí metodu s návratem můžeme velice zkrátit, pomocí ternárního operátoru - viz Kód 4.

// Metoda s celočíselným návratem - použití ternárního operátoru
static int Vetsi(int x, int y)
{
    //Návrat většího čísla - použití ternárního operátoru
    return (x > y ? x : y); 
}

Kód 4: Deklarace statické metody s návratem s názvem Vetsi - použití ternárního operátoru

1.3. Výsledný kód

Následující zdrojový kód je kompletací předešlých kódů programu NejvetsiZe2Cisel, který je umístěn v souboru Program.cs - viz Kód 1.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace NejvetsiZe2Cisel
{
    class Program
    {
        static void Main(string[] args)
        {
            // Deklarace: 'a' ... první zadané celé číslo; 'b' ... druhé zadané celé číslo
            int a, b;
 
            //Výzva k zadání
            Console.Write("Zadejte a: ");
            // Načtení prvního celého čísla
            a = int.Parse(Console.ReadLine());
            //Výzva k zadání
            Console.Write("Zadejte b: ");
            // Načtení druhého celého čísla
            b = int.Parse(Console.ReadLine());
            // Výpis textu pro oddělení porovnání v hlavním programu
            Console.WriteLine("Porovnání dvou čísel v hlavním programu:");
 
            // Test, zda první číslo je větší než druhé
            if (a > b)
            {
                // První číslo je větší než druhé
                Console.WriteLine("Největší je: " + a);
            }
            else
            {
                // Druhé číslo je větší než první
                Console.WriteLine("Největší je: " + b);
            }
 
            // Výpis textu pro oddělení porovnání provedeného pomocí zavolání podprogramu
            Console.WriteLine("Porovnání dvou čísel pomocí podprogramu:");
 
            // Vypsání textu spolu s návratem funkce (výsledek porovnání)
            Console.Write("Největší je: " + Vetsi(a, b));
 
            //Čekání na stisk klávesy -> ukončení programu
            Console.ReadKey();
        }
 
 
        // Metoda s celočíselným návratem
        // 'x' ... první celé číslo; 'y' ... druhé celé číslo
        static int Vetsi(int x, int y)
        {
            //Deklarace lokální proměnné
            int z;
            // Test, zda první předané číslo je větší než druhé
            if (x > y)
            {
                // První číslo je větší než druhé, výsledek funkce je první číslo
                z = x;
            }
            else
            {
                // Druhé číslo je větší než první, výsledek funkce je druhé číslo
                z = y;
            }
            //Návrat většího čísla
            return z;
        }
    }
}

Kód 1: Program NejvetsiZe2Cisel - deklarace hlavní statické metody Main včetně deklarací dalších metod

Výstup programu

Na následujícím výstupu programu vidíme výpis největší hodnoty z obou porovnaných hodnot - viz Výstup programu - Kód 1. Jednotlivá porovnání jsou rozděleny do různých sekcí, abychom věděli, zda porovnání bylo provedeno v hlavní metodě, nebo pomocí metody s návratem. Po provedení výpisu konzolová aplikace čeká na stisk klávesy, aby po stisku klávesy byla následně ukončena. 

Výstup programu - Kód 1: Ukázka výpisu hodnot v hlavní metodě programu NejvetsiZe2Cisel

2. NejvetsiZe2CiselVcetneRovnosti

Vytvořte aplikaci pro porovnání dvou zadaných celých čísel, včetně porovnání jejich možné rovnosti, provedeného v hlavním programu a zároveň pomocí podprogramu. V programu se bude testovat, zda je možné provést konverzi číslic na celé číslo. Vypište v konzoli největší hodnotu z těchto zadaných čísel včetně identifikátoru proměnné, ve které je největší hodnota uložena.

Účel příkladu

• Podmínka
• Test konverze textu na celé číslo

Typ aplikace

• Konzolová aplikace

Popis úkolu 

• Porovnání dvou zadaných celých čísel včetně porovnání jejich možné rovnosti

Funkčnosti

• V konzolové aplikaci se v hlavním programu provede porovnání dvou zadaných celých čísel včetně výpisu identifikátoru proměnné, ve které je největší hodnota uložena
• Po zadání hodnot v konzoli proběhne test konverze (zadaných číslic) na celé číslo
• Dále se provede porovnání pomocí zavolaného podprogramu, který přijímá čtyři formální parametry (dva typu celé číslo - porovnávané celočíselné hodnoty, dva typu textový řetězec - identifikátory proměnných předaných z hlavního programu). Podprogram bude porovnávat dvě předaná čísla. Tento podprogram navrátí největší hodnotu, včetně identifikátoru proměnné, ve které je největší hodnota uložena
• V konzoli se vypíše, které číslo je největší (oddělte výpis v hlavním programu a výpis využívající výstup podprogramu)

Výstup programu

Výstup programu: Ukázka výpisu větší hodnoty v hlavní statické metodě programu NejvetsiZe2CiselVcetneRovnosti

2.1. Analýza a návrh řešení

Jak název příkladu NejvetsiZe2CiselVcetneNerovnosti napovídá, tento příklad je modifikací předchozí příkladu NejvetsiZe2Cisel. Pokud uvažujeme již 3 relační operátory "Větší/Rovno/Menší" pro obecné řešení vznikají celkem 3 případy v závislosti na relačních operátorech (>, = , <):

• A > B
• A = B
• A < B

V tomto případu však potřebujeme vypsat nejen největší hodnotu, ale také název proměnné, ve které je tato hodnota uložena. V řešení příkladu jsme u výpisu použili spojení textu určujícím název proměnné maxima a její hodnoty. Druhým způsobem je použití podprogramu ve formě funkce, jejíž návrat představuje textový řetězec obsahující název proměnné určující větší číslo a hodnotu této proměnné (u Flowgorithm nemusíme využívat konverze čísla na text a opačně, protože aplikace jí provádí sama). 

Ve vývojovém diagramu také nejsou zaznamenány výjimky, které mohou být vyvolány chybnou konverzí zadaného textu na celé číslo. Konverzi na celé číslo lze ve Flowgorithm provést pomocí příkazu (zavolání funkce) ToInteger, který přijímá textový řetězec a následně jej konvertuje na celé číslo. Pokud nastane chyba při konverzi, aplikace sama vyvolá výjimku, ve které bude uživatele informovat o nastalém problému. 

Vývojový diagram může vypadat následovně - viz Obrázek 1. Při volání podprogramu VetsiRovno jsou předány jak skutečné parametry, tak i jejich názvy - výsledný návratový textový řetězec bude obsahovat nejprve identifikátor (název) proměnné a její hodnotu. 

Obrázek 1: Porovnání dvou zadaných čísel včetně rovnosti

V deklaraci funkce VetsiRovno vidíme specifikované čtyři formální parametry - první dva slouží pro uložení hodnot z proměnných předaných z hlavního programu a další dva, které slouží pro uložení názvu těchto proměnných - viz Obrázek 2.  Podstata porovnání je stejná jako v hlavním programu s tím rozdílem, že do textové lokální proměnné podprogramu, uložíme text obsahující identifikátor (název) proměnné v hlavním programu - text v parametru a hodnotu parametru.

Obrázek 2: Podprogram (funkce) VetsiRovno

Další možností jak řešit daný problém, je volat dvě funkce - jednu s návratem hodnoty, druhou pro návrat názvu proměnné, ve které je uloženo větší číslo. Lze také použít podprogram, který bude vracet dva výstupy - název parametru a hodnotu většího čísla uloženého v parametru. Takových řešení existuje více a je jen na nás, jak efektivně budeme problém řešit. 

2.2. C# kód

Následující zdrojový kód hlavní statické metody v C# pro konzolovou aplikaci je transformací algoritmu NejvetsiZe2CiselVcetneRovnosti - viz Kód 1.  V těle hlavní metody je po deklaraci a výzvě k zadání prvního celého čísla demonstrován test konverze zadaných číslic uživatelem a následný převod na celé číslo uložené do první proměnné a, která je zároveň parametrem jednotlivých volaných metod. Informace o provedení bezchybné konverze pomocí metody TryParse (implementované ve třídě týkající se celých čísel a nejen nich) je uložena do booleanovské logické proměnné konverze (datový typ bool). Pokud nastala chyba při konverzi, je vypsána chybová hláška a hlavní metoda je ukončena pomocí příkazu return. Po provedení testu konverze u obou čísel je v hlavní metodě provedeno porovnání včetně testování rovnosti obou zadaných celých čísel. Výsledek tohoto porovnání je následně vypsán.

Ve zdrojovém kódu hlavní metody je použito volání metody VetsiRovno. Této metodě s celočíselným návratem většího ze dvou přijímaných celých čísel jsou předány v hlavní metodě čtyři skutečné parametry. První dva parametry slouží pro předání hodnot uložených v lokální proměnných hlavní metody a další dva slouží pro určení identifikátoru (názvu) proměnné, abychom byli schopni identifikovat, kde je uložena větší hodnota (pozor záleží na pořadí předávaných parametrů). Výpisy největší hodnoty jsou realizovány pomocí indexování jednotlivých proměnných v příkazu výpisu (na rozdíl od předchozího příkladu, kde byl použit operátor + pro spojování textových řetězců a hodnot). 

Další volanou metodou je přetížená metoda (metoda se stejným názvem, ale jiným počtem parametrů) s výstupními parametry, které jsou inicializovány uvnitř metody. Pro tento účel byly v hlavní metodě deklarovány další lokální proměnné: celočíselná proměnná max - slouží pro uložení hodnoty většího čísla a druhá nazevMax, která slouží pro uložení názvu proměnné, ve které je uložena větší hodnota.

Poslední volanou metodou v hlavní metodě je metoda VetsiRovno2Vystupy. Tato metoda navrací dva výstupy, které jsou v hlavní metodě uloženy do proměnných nazevMax a Max. 

Jednotlivé sekce porovnání zadaných čísel jsou od sebe odděleny výpisy, abychom věděli, která část zdrojového kódu byla pro porovnání použita.

static void Main(string[] args)
  {
      /* Deklarace: 'a' ... první zadané celé číslo; 'b' ... druhé zadané celé číslo;
       * 'max' ... hodnota většího čísla  */
      int a, b, max;
      // Deklarace: 'text' ... textový řetězec pro uložení prvního výstupu metody se 2 výstupy  
      string nazevMax;
 
      // Výzva k zadání prvního celého čísla
      Console.Write("Zadejte a: ");
      /* Načtení prvního celého čísla a test, zda proběhla konverze celého 
       * čísla (návrat metody konverze je boolean) */
      bool konverze = int.TryParse(Console.ReadLine(), out a);
      // Pokud neproběhla konverze
      if (konverze == false)
      {
          // Výpis chyby při konverzi
          Console.WriteLine("Chyba při konverzi na celé číslo");
          // Ukončení programu
          return;
      }
 
      // Výzva k zadání druhého celého čísla
      Console.Write("Zadejte b: ");
      // Test, zda neproběhla konverze celého čísla (návrat metody konverze je boolean)
      if (int.TryParse(Console.ReadLine(), out b) == false)
      {
          // Výpis chyby při konverzi
          Console.WriteLine("Chyba při konverzi na celé číslo");
          // Ukončení programu
          return;
      }
 
      // Výpis textu pro oddělení porovnání v hlavním programu
      Console.WriteLine("Porovnání dvou čísel v hlavním programu:");
      // Test, zda první číslo je větší než druhé
      if (a > b)
      {
          // První číslo je větší než druhé
          Console.WriteLine("Největší je a = {0}", a);
      }
      else
      {
          // Test, zda zadaná čísla jsou si rovny
          if (a == b)
          {
              // Rovnost obou zadaných čísel
              Console.WriteLine("Největší je a = b = {0}", b);
          }
          else
          {
              /* První zadané číslo 'a' není rovné druhému číslu 'b' 
               * a zároveň druhé číslo 'b' je větší než první 'a' */
              Console.WriteLine("Největší je b = {0}", b);
          }
      }
 
      // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody s návratem
      Console.WriteLine("Porovnání dvou čísel pomocí metody s návratem:");
 
      // Vypsání textu spolu s návratem funkce (výsledek porovnání)
      Console.WriteLine("Největší je {0}", VetsiRovno(a, b, "a", "b"));
 
      // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody se dvěma návraty
      Console.WriteLine("Porovnání dvou čísel pomocí metody s dvěma návraty:");
 
      // Volání metody se 2 návraty a přiřazení do proměnných
      (nazevMax, max) = VetsiRovno2Vystupy(a, b, "a", "b");
 
      // Vypsání textu spolu s návratem názvu proměnné a její hodnoty (výsledek porovnání)
      Console.WriteLine("Největší je {0}{1}", nazevMax, max);
 
      // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody s výstupními parametry
      Console.WriteLine("Porovnání dvou čísel pomocí metody s výstupními parametry:");
 
      // Volání metody se 2 návraty a přiřazení do proměnných
      VetsiRovno(a, b, "a", "b", out nazevMax, out max);
 
      // Vypsání textu spolu s návratem názvu proměnné a její hodnoty (výsledek porovnání)
      Console.WriteLine("Největší je {0}{1}", nazevMax, max);
 
      // Čekání na stisk klávesy -> ukončení programu
      Console.ReadKey();
  }

Kód 1: Program NejvetsiZe2CiselVcetneRovnosti - deklarace hlavní statické metody Main 

Metoda VetsiRovno navrací textovou lokální proměnnou identifikatorHodnotaVetsiho obsahující identifikátory proměnných, které byly načteny v hlavní metodě. Díky tomu jsme schopni identifikovat, ve kterém parametru (předaného názvu proměnné z hlavního programu) je uložena větší hodnota. Tento návratový textový řetězec také obsahuje hodnotu většího z obou předaných celých čísel. V těle příkazu pro rozhodování jsou v závislosti na rozhodovacích podmínkách výstupu přiřazeny jednotlivé identifikátory, včetně hodnoty většího čísla.  Pokud jsou si hodnoty rovny, jsou v textu uvedeny oba názvy parametrů.

// Metoda s celočíselným návratem
/* 'x' ... hodnota prvního celého čísla; 'y' ... hodnota druhého celého čísla;
 * 'identifikatorPrvniCislo' ... identifikátor prvního celého čísla uloženého 
 * do formálního parametru metody; 'identifikatorDruheCislo' ... identifikátor 
 * druhého celého čísla */
 
static string VetsiRovno(int x, int y, string identifikatorPrvniCislo, 
    string identifikatorDruheCislo)
{
    string identifikatorHodnotaVetsiho;
 
    // Test, zda první číslo je větší než druhé
    if (x > y)
    {
        // První číslo je větší než druhé číslo
        identifikatorHodnotaVetsiho = identifikatorPrvniCislo + " = " + x;
    }
    else
    {
        // Test, zda zadaná čísla jsou si rovny
        if (x == y)
        {
            // Rovnost obou zadaných čísel
            identifikatorHodnotaVetsiho = identifikatorPrvniCislo + " = " + identifikatorDruheCislo + " = " + y;
        }
        else
        {
            // První zadané číslo není rovné druhému číslu (a zároveň druhé číslo je větší než první)
            identifikatorHodnotaVetsiho = identifikatorDruheCislo + " = " + y;
        }
    }
 
    // Návrat názvu a hodnoty většího čísla
    return identifikatorHodnotaVetsiho;
}

 Kód 2: Deklarace statické metody s návratem s názvem VetsiRovno

Další metoda bez návratu s výstupními parametry, tentokrát přetížená metoda, která nese stejný název jako předchozí metoda, ale obsahuje jiný počet parametrů - viz Kód 3. Na rozdíl od předchozí metody obsahuje navíc výstupní parametr identifikatorMax, který obsahuje název proměnné. Výstupní parametr max obsahuje hodnotu většího čísla. Jak vidíme, metoda je bez návratu (klíčové slovo void), proto v těle metody není použito klíčové slovo return, ale jsou pouze uvnitř metody inicializovány výstupní parametry uvedené klíčovým slovem out.

// Přetížená metoda s výstupními parametry
static void VetsiRovno(int x, int y, string identifikatorPrvniCislo,
    string identifikatorDruheCislo, out string identifikatorMax, out int max)
{
    // Test, zda první číslo je větší než druhé
    if (x > y)
    {
        // Přiřazení názvu ve formálnímu parametru výstupnímu parametru 
        identifikatorMax = identifikatorPrvniCislo + " = ";
        // Přiřazení hodnoty většího čísla výstupnímu parametru (první číslo je větší)
        max = x;
    }
    else
    {
        // Test, zda zadaná čísla jsou si rovnym
        if (x == y)
        {
            // Přiřazení názvu ve formálnímu parametru výstupnímu parametru 
            identifikatorMax = identifikatorPrvniCislo + " = " + identifikatorDruheCislo + " = ";
            // Přiřazení hodnoty většího čísla výstupnímu parametru (obě čísla jsou si rovna)
            max = y;
        }
        else
        {
            // Přiřazení názvu ve formálnímu parametru výstupnímu parametru 
            identifikatorMax = identifikatorDruheCislo + " = ";
            // Přiřazení hodnoty většího čísla výstupnímu parametru (první číslo je větší)
            max = y;
        }
    }
}

Kód 2: Deklarace přetížené statické metody Vetsi s výstupními parametry

Poslední deklarovanou metodou VetsiRovno2Vystupy je metoda se dvěma návraty - viz Kód 3. V prvním návratu datového typu string je uložen název parametru a v druhém typu int je uložena hodnota většího čísla. 

//Metoda se dvěma návraty
static (string, int) VetsiRovno2Vystupy(int x, int y, string identifikatorPrvniCislo,
    string identifikatorDruheCislo)
{
    // Test, zda první číslo je větší než druhé
    if (x > y)
    {
        // Návrat názvu a hodnoty většího čísla(první číslo je větší)
        return (identifikatorPrvniCislo + " = ", x);
    }
    else
    {
        // Test, zda zadaná čísla jsou si rovny
        if (x == y)
        {
            // Návrat názvu a hodnoty většího čísla (rovnost obou zadaných čísel)
            return (identifikatorPrvniCislo + " = " + identifikatorDruheCislo + " = ", y);
        }
        else
        {
            // Návrat názvu a hodnoty většího čísla (druhé číslo je větší)
            return (identifikatorDruheCislo + " = ", y);
        }
    }
}

Kód 3: Deklarace statické metody se dvěma návraty s názvem VetsiRovno2Vystupy

2.3. Výsledný kód

Následující zdrojový kód je kompletací předešlých kódů programu NejvetsiZe2CiselVcetneRovnosti, který je umístěn v souboru Program.cs - viz Kód 1.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace NejvetsiZe2CiselVcetneRovnosti
{
    class Program
    {
        static void Main(string[] args)
        {
            /* Deklarace: 'a' ... první zadané celé číslo; 'b' ... druhé zadané celé číslo;
             * 'max' ... hodnota většího čísla  */
            int a, b, max;
            // Deklarace: 'text' ... textový řetězec pro uložení prvního výstupu metody se 2 výstupy  
            string nazevMax;
 
            // Výzva k zadání prvního celého čísla
            Console.Write("Zadejte a: ");
            /* Načtení druhého celého čísla a test, zda proběhla konverze celého 
             * čísla (návrat metody konverze je boolean) */
            bool konverze = int.TryParse(Console.ReadLine(), out a);
            // Pokud neproběhla konverze
            if (konverze == false)
            {
                // Výpis chyby při konverzi
                Console.WriteLine("Chyba při konverzi na celé číslo");
                // Čekání na stisk klávesy
                Console.ReadKey();
                // Ukončení programu
                return;
            }
 
            // Výzva k zadání druhého celého čísla
            Console.Write("Zadejte b: ");
            // Test, zda neproběhla konverze celého čísla (návrat metody konverze je boolean)
            if (int.TryParse(Console.ReadLine(), out b) == false)
            {
                // Výpis chyby při konverzi
                Console.WriteLine("Chyba při konverzi na celé číslo");
                // Čekání na stisk klávesy
                Console.ReadKey();
                // Ukončení programu
                return;
            }
 
            // Výpis textu pro oddělení porovnání v hlavním programu
            Console.WriteLine("Porovnání dvou čísel v hlavním programu:");
            // Test, zda první číslo je větší než druhé
            if (a > b)
            {
                // První číslo je větší než druhé
                Console.WriteLine("Největší je a = {0}", a);
            }
            else
            {
                // Test, zda zadaná čísla jsou si rovny
                if (a == b)
                {
                    // Rovnost obou zadaných čísel
                    Console.WriteLine("Největší je a = b = {0}", b);
                }
                else
                {
                    /* První zadané číslo 'a' není rovné druhému číslu 'b' 
                     * a zároveň druhé číslo 'b' je větší než první 'a' */
                    Console.WriteLine("Největší je b = {0}", b);
                }
            }
 
            // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody s návratem
            Console.WriteLine("Porovnání dvou čísel pomocí metody s návratem:");
 
            // Vypsání textu spolu s návratem funkce (výsledek porovnání)
            Console.WriteLine("Největší je {0}", VetsiRovno(a, b, "a", "b"));
 
            // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody se dvěma návraty
            Console.WriteLine("Porovnání dvou čísel pomocí metody s dvěma návraty:");
 
            // Volání metody se 2 návraty a přiřazení do proměnných
            (nazevMax, max) = VetsiRovno2Vystupy(a, b, "a", "b");
 
            // Vypsání textu spolu s návratem názvu proměnné a její hodnoty (výsledek porovnání)
            Console.WriteLine("Největší je {0}{1}", nazevMax, max);
 
            // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody s výstupními parametry
            Console.WriteLine("Porovnání dvou čísel pomocí metody s výstupními parametry:");
 
            // Volání metody se 2 návraty a přiřazení do proměnných
            VetsiRovno(a, b, "a", "b", out nazevMax, out max);
 
            // Vypsání textu spolu s návratem názvu proměnné a její hodnoty (výsledek porovnání)
            Console.WriteLine("Největší je {0}{1}", nazevMax, max);
 
            // Čekání na stisk klávesy -> ukončení programu
            Console.ReadKey();
        }
 
        // Metoda s celočíselným návratem
        /* 'x' ... hodnota prvního celého čísla; 'y' ... hodnota druhého celého čísla;
         * 'identifikatorPrvniCislo' ... identifikátor prvního celého čísla uloženého 
         * do formálního parametru metody; 'y' ... identifikátor druhého celého čísla; */
 
        static string VetsiRovno(int x, int y, string identifikatorPrvniCislo, 
            string identifikatorDruheCislo)
        {
            string identifikatorHodnotaVetsiho;
 
            // Test, zda první číslo je větší než druhé
            if (x > y)
            {
                // První číslo je větší než druhé číslo
                identifikatorHodnotaVetsiho = identifikatorPrvniCislo + " = " + x;
            }
            else
            {
                // Test, zda zadaná čísla jsou si rovny
                if (x == y)
                {
                    // Rovnost obou zadaných čísel
                    identifikatorHodnotaVetsiho = identifikatorPrvniCislo + " = " + identifikatorDruheCislo + " = " + y;
                }
                else
                {
                    // První zadané číslo není rovné druhému číslu (a zároveň druhé číslo je větší než první)
                    identifikatorHodnotaVetsiho = identifikatorDruheCislo + " = " + y;
                }
            }
 
            // Návrat názvu a hodnoty většího čísla
            return identifikatorHodnotaVetsiho;
        }
 
        // Přetížená metoda s výstupními parametry
        static void VetsiRovno(int x, int y, string identifikatorPrvniCislo,
            string identifikatorDruheCislo, out string identifikatorMax, out int max)
        {
            // Test, zda první číslo je větší než druhé
            if (x > y)
            {
                // Přiřazení názvu ve formálnímu parametru výstupnímu parametru 
                identifikatorMax = identifikatorPrvniCislo + " = ";
                // Přiřazení hodnoty většího čísla výstupnímu parametru (první číslo je větší)
                max = x;
            }
            else
            {
                // Test, zda zadaná čísla jsou si rovnym
                if (x == y)
                {
                    // Přiřazení názvu ve formálnímu parametru výstupnímu parametru 
                    identifikatorMax = identifikatorPrvniCislo + " = " + identifikatorDruheCislo + " = ";
                    // Přiřazení hodnoty většího čísla výstupnímu parametru (obě čísla jsou si rovna)
                    max = y;
                }
                else
                {
                    // Přiřazení názvu ve formálnímu parametru výstupnímu parametru 
                    identifikatorMax = identifikatorDruheCislo + " = ";
                    // Přiřazení hodnoty většího čísla výstupnímu parametru (první číslo je větší)
                    max = y;
                }
            }
        }
 
        //Metoda se dvěma návraty
        static (string, int) VetsiRovno2Vystupy(int x, int y, string identifikatorPrvniCislo,
            string identifikatorDruheCislo)
        {
            // Test, zda první číslo je větší než druhé
            if (x > y)
            {
                // Návrat názvu a hodnoty většího čísla(první číslo je větší)
                return (identifikatorPrvniCislo + " = ", x);
            }
            else
            {
                // Test, zda zadaná čísla jsou si rovny
                if (x == y)
                {
                    // Návrat názvu a hodnoty většího čísla (rovnost obou zadaných čísel)
                    return (identifikatorPrvniCislo + " = " + identifikatorDruheCislo + " = ", y);
                }
                else
                {
                    // Návrat názvu a hodnoty většího čísla (druhé číslo je větší)
                    return (identifikatorDruheCislo + " = ", y);
                }
            }
        }
    }
}

Kód 1: Program NejvetsiZe2CiselVcetneRovnosti - deklarace hlavní statické metody Main včetně deklarací dalších metod

Výstup programu

Na následujícím výstupu programu vidíme výpis největší hodnoty z obou porovnaných hodnot - viz Výstup programu 1 - Kód 1. Jednotlivá porovnání jsou rozdělena do různých sekcí, abychom věděli, zda porovnání bylo provedeno v hlavní metodě, pomocí metody s návratem, metody se dvěma návraty, nebo pomocí metody s výstupními parametry. Po provedení výpisu konzolová aplikace čeká na stisk klávesy, aby po stisku klávesy byla následně ukončena. Na prvním výstupu v konzole vidíme, že největší číslo je druhé zadané číslo. 

Výstup programu 1 - Kód 1: Ukázka výpisu větší hodnoty v hlavní statické metodě programu NejvetsiZe2CiselVcetneRovnosti

Pokud bylo zadáno stejné číslo, je vypsána rovnost obou čísel - viz Výstup programu 2 - Kód 1.

Výstup programu 2 - Kód 1: Ukázka výpisu stejných hodnot v hlavní statické metodě programu NejvetsiZe2CiselVcetneRovnosti

Pokud uživatel zadal špatný číselný vstup (např. text "bflm") návrat metody TryParse nabývá hodnoty false a je spuštěn příkaz výpisu chybové hlášky. Abychom si mohli přečíst chybovou hlášku, je za příkaz výpisu v kódu umístěn příkaz pro načtení znaku. Po stisku klávesy následuje ukončení programu pomocí příkazu return - viz Výstup programu 3 - Kód 1.

Výstup programu 3 - Kód 1: Ukázka výpisu chyby při konverzi v hlavní statické metodě programu NejvetsiZe2CiselVcetneRovnosti

3. NejvetsiZe3Cisel

Vytvořte aplikaci pro porovnání tří zadaných celých čísel, včetně porovnání jejich možné rovnosti, provedeného pomocí podprogramů. V programu se bude testovat, zda je možné provést konverzi u zadaných číslic. Pomocí prvních tří podprogramů se v jejich tělech vypíší identifikátory (názvy) proměnných, ve kterých se nachází největší hodnota i včetně výpisu této hodnoty, zbývající dva podprogramy vypíší největší hodnotu ze zadaných čísel.

Účel příkladu

• Podmínka
• Test konverze textu na celé číslo
• Volání funkce ve funkci

Typ aplikace

• Konzolová aplikace

Popis úkolu 

• Porovnání tří zadaných čísel včetně porovnání jejich možné rovnosti

Funkčnosti

• Po zadání hodnot v hlavním programu proběhne test konverze (zadaných číslic) na celé číslo
• V konzolové aplikaci se v hlavním programu provede porovnání pomocí pěti zavolaných podprogramů, které přijímají tři celočíselné parametry (porovnávané celočíselné hodnoty) načtených v hlavním programu:
• 1. podprogram - využije vnořeného rozhodování při porovnání parametrů
• 2. podprogram - využije principu kaskádování pomocí spojování podmínek při porovnání parametrů
• 3. podprogram - využije dvojitého volání podprogramu VetsiRovno (ve funkci znovu zavolá stejnou funkci), který navrátí největší hodnotu - maximum. Toto maximum bude porovnáno se všemi třemi formálními parametry a ve výpisu bude uveden identifikátor proměnné (z hlavního programu), ve kterém je největší hodnota uložena včetně hodnoty tohoto maxima
• 4. podprogram - využije volání dalšího podprogramu VetsiRovno, který porovná první dvě předané hodnoty a navrátí hodnotu většího z nich. Tato hodnota je dále porovnána se třetím formálním parametrem pomocí podmínky. Ve výpisu je uvedena hodnota největšího ze tří čísel včetně všech tří zadaných hodnot
  
• 5. podprogram - využije přímo ve výpisu dvojitého volání podprogramu VetsiRovno, který porovná první dvě předané hodnoty a navrácenou hodnotu většího z nich porovná se třetím formálním parametrem. Ve výpisu je uvedena hodnota největšího ze tří čísel včetně všech tří zadaných hodnot
  
• Oddělte ve výpisu výstupy jednotlivých podprogramů
  

Výstup programu

3.1. Analýza a návrh řešení

Podle zadání příkladu máme načíst tři celá čísla, která budeme porovnávat pomocí pěti různých podprogramů, které budou vypisovat hodnotu maxima a jednotlivé výpisy podprogramů mají být od sebe odděleny - viz Obrázek 1. 

Obrázek 1: Hlavní program NejvetsiZe3Cisel pro porovnání tří zadaných čísel včetně rovnosti

Pokud bychom analyticky řešili problém porovnání tří celých čísel, nejprve si porovnáme první dva členy mezi sebou a vítěze tohoto porovnání porovnáme se zbývajícím číslem:

pokud a > b potom 
     pokud a > c potom
          "a je největší";
     jinak
          "c je největší"; 
jinak
     pokud b > c potom
          "b je největší";
     jinak
          "c je největší";  

Tabulka 1: Největší ze tří

Tuto tabulku lze implementovat různými způsoby např.:

• Vnořený rozhodováním - viz Obrázek 2
• Kaskádováním - viz Obrázek 3

Obrázek 2: Podprogram VetsiRovnoVerze1 - vnořené rozhodování

Další možností implementace porovnání tří celých čísel podle předchozí tabulky je využití kaskády podmínek, kde jsou jednotlivé části podmínky v rozhodovacím bloku spojeny pomocí logického operátoru a zároveň (logický součin) - viz Obrázek 3.

Obrázek 3: Podprogram VetsiRovnoVerze2 - kaskádování

Při  4 proměnných je už 27 možností porovnání z čehož plyne, že v tomto případě již předchozí způsoby nejsou efektivní. Vhodnější cesta je deklarace podprogramu VetsiRovno (funkce) pro porovnání dvou čísel, který bude navracet větší z nich. Této funkci předáme dva celočíselné parametry, které představují porovnávané hodnoty - viz Obrázek 4.  Pokud si budou hodnoty rovny, vybereme jako větší první parametr. 

Obrázek 4: Podprogram (funkce) VetsiRovno

Tento podprogram bude volán v následující verzi podprogramu VetsiRovnoVerze3 - viz Obrázek 5. Podprogram VetsiRovnoVerze3 přijímá 3 parametry, ze kterých pomocí dvojitého volání funkce VetsiRovno získá největší - maximum - ze všech tří předaných čísel.  

Obrázek 5: Podprogram VetsiRovnoVerze3 - porovnání s maximem

Principem aplikovaného přístupu je, že prvním voláním funkce VetsiRovno(a, b) získáme návrat v podobě většího čísla z těchto dvou čísel - viz Obrázek 6. 

Obrázek 6: Princip dvojitého volání metody VetsiRovno - 3 parametry

Dalším voláním této funkce, tj. VetsiRovno(VetsiRovno(a, b), c) je této funkci předán jako první vstup právě ono větší číslo získané z předchozího volání (tj. větší z a a b). Toto číslo je pak porovnáno v metodě se třetím číslem c. Toto maximum je pak v metodě VetsiRovnoVerze3 porovnáno na rovnost pomocí tří podmínek s jednotlivým čísly. Výhodou tohoto přístupu je, že řeší i případ, že jsou si všechna tři čísla rovna. 

Pokud se podíváme na další obrázek zjistíme, že tento princip lze využít i u většího počtu porovnávaných proměnných např. u 4 proměnných a, b, c, d - viz Obrázek 7.

Obrázek 7: Princip volání metody VetsiRovno - 4 parametry

Další podprogram je modifikací předchozí verze podprogramu. Zde však porovnáme, pomocí podmínky, návrat funkce VetsiRovno, které byly předány  první dvě čísla. Tento výstup ve formě většího čísla porovnáme se zbývajícím třetím číslem - viz Obrázek 8. V tomto a dalším podprogramu již nevypisujeme název proměnné, ve které je maximum uloženo. Vypíšeme pouze seznam zadaných čísel. 

Obrázek 8: Podprogram VetsiRovnoVerze4 - porovnání návratu funkce VetsiRovno se třetím číslem

Posledním podprogram je VetsiRovnoVerze5 - viz Obrázek 9. Tento podprogram obsahuje pouze jeden výpis, ve kterém je využito dvojité volání podprogramu VetsiRovno, které do výpisu navrátí maximum ze tří čísel - stejná podstata jako u VetsiRovnoVerze3. Vidíme, že program lze velice zkrátit v závislosti na specifikaci požadovaného výsledku. Ve výpisu použijeme vypsání hodnot všech tří předaných čísel.

Obrázek 9: Podprogram VetsiRovnoVerze5 - použití dvojitého volání funkce VetsiRovno přímo ve výpisu 

3.2. C# kód

Následující zdrojový kód hlavní statické metody v C# pro konzolovou aplikaci je transformací algoritmu NejvetsiZe3Cisel - viz Kód 1.  V těle hlavní metody je po deklaraci a výzvě k zadání prvního celého čísla proveden test konverze zadaných číslic uživatelem a následný převod na celé číslo uložené do první proměnné a, která je zároveň parametrem jednotlivých volaných metod. Pokud nastala chyba při konverzi, je vypsána chybová hláška a hlavní metoda je ukončena pomocí příkazu return. Po provedení testu konverze u všech tří načtených čísel je v hlavní metodě provedeno volání jednotlivých podprogramů pro porovnání zadaných celých čísel. Výsledky porovnání jsou vypsány uvnitř jednotlivých volaných metod. Jednotlivé sekce porovnání zadaných čísel jsou od sebe odděleny výpisy, abychom věděli, která část zdrojového kódu byla pro porovnání použita.

static void Main(string[] args)
{
    /* Deklarace: 'a' ... první zadané celé číslo; 'b' ... druhé zadané celé číslo 
     * 'c' ... třetí zadané celé číslo */
    int a, b, c;
 
    // Výzva k zadání prvního celého čísla
    Console.Write("Zadejte a: ");
    /* Načtení prvního celého čísla a test, zda proběhla konverze celého 
     * čísla (návrat metody konverze je boolean) */
    bool konverze = int.TryParse(Console.ReadLine(), out a);
    // Pokud neproběhla konverze
    if (konverze == false)
    {
        // Výpis chyby při konverzi
        Console.WriteLine("Chyba při konverzi na celé číslo");
        // Čekání na stisk klávesy
        Console.ReadKey();
        // Ukončení programu
        return;
    }
 
    // Výzva k zadání druhého celého čísla
    Console.Write("Zadejte b: ");
    // Test, zda neproběhla konverze celého čísla (návrat metody konverze je boolean)
    if (int.TryParse(Console.ReadLine(), out b) == false)
    {
        // Výpis chyby při konverzi
        Console.WriteLine("Chyba při konverzi na celé číslo");
        // Čekání na stisk klávesy
        Console.ReadKey();
        // Ukončení programu
        return;
    }
 
    // Výzva k zadání třetího celého čísla
    Console.Write("Zadejte c: ");
    // Test, zda neproběhla konverze celého čísla (návrat metody konverze je boolean)
    if (int.TryParse(Console.ReadLine(), out c) == false)
    {
        // Výpis chyby při konverzi
        Console.WriteLine("Chyba při konverzi na celé číslo");
        // Čekání na stisk klávesy
        Console.ReadKey();
        // Ukončení programu
        return;
    }
 
    // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody bez návratu 'VetsiRovnoVerze1'
    Console.WriteLine("Porovnání tří čísel pomocí metody 'VetsiRovnoVerze1':");
 
    /* Volání metody 'VetsiRovnoVerze1' - výpis názvu proměnné obsahující maximum a hodnotu maxima  
     * je proveden uvnitř metody - vnořené rozhodování */
    VetsiRovnoVerze1(a, b, c);
 
    // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody 'VetsiRovnoVerze2'
    Console.WriteLine("Porovnání tří čísel pomocí metody 'VetsiRovnoVerze2':");
 
    /* Volání metody 'VetsiRovnoVerze2' bez návratu - výpis názvu proměnné obsahující maximum a hodnotu 
     * maxima je proveden uvnitř metody - princip kaskádování rozhodování */
    VetsiRovnoVerze2(a, b, c);
 
    // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody 'VetsiRovnoVerze3'
    Console.WriteLine("Porovnání tří čísel pomocí metody 'VetsiRovnoVerze3':");
 
    /* Volání metody 'VetsiRovnoVerze3' bez návratu (porovnání s maximem obdrženého z dvojitého 
     * volání metody 'VetsiRovno') - výpis maxima a zadaných hodnot je proveden uvnitř metody */
    VetsiRovnoVerze3(a, b, c);
 
    // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody 'VetsiRovnoVerze4'
    Console.WriteLine("Porovnání tří čísel pomocí metody 'VetsiRovnoVerze4':");
 
    /* Volání metody 'VetsiRovnoVerze4' bez návratu (využití volání metody 'VetsiRovno') - výpis 
     * maxima a zadaných hodnot je proveden uvnitř metody */
    VetsiRovnoVerze4(a, b, c);
 
    // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody 'VetsiVerze5'
    Console.WriteLine("Porovnání tří čísel pomocí metody 'VetsiRovnoVerze5':");
 
    /* Volání metody 'VetsiRovnoVerze5' bez návratu (využití dvojitého volání metody 'VetsiRovno') - 
     * výpis maxima a zadaných hodnot je proveden uvnitř metody */
    VetsiRovnoVerze5(a, b, c);
 
    // Čekání na stisk klávesy -> ukončení programu
    Console.ReadKey();
}

Kód 1: Program NejvetsiZe3Cisel - deklarace hlavní statické metody Main 

První volanou metodou bez návratu je metoda VetsiRovnoVerze1. Tato metoda (jako všechny ostatní metody) přijímá tři celočíselné parametry a využívá vnořeného rozhodování pro porovnání jednotlivých hodnot mezi sebou. Toto rozhodování odpovídá tabulce různých variant probírané v předchozí kapitole. V jednotlivých výpisech (9 variant) je uveden identifikátor/y nalezeného maxima a hodnota tohoto maxima - viz Kód 2.

/* Metoda bez návratu - výpis názvu parametru obsahující maximum a hodnota 
 * maxima - vnořené rozhodování */
static void VetsiRovnoVerze1(int a, int b, int c)
{
    // Porovnání prvního a druhé předaného čísla
    if (a > b)
        // Vnořené rozhodování
        if (a > c)
            // Výpis názvu maxima a hodnoty maxima
            Console.WriteLine("Největší je a = " + a);
        else
            if (a == c)
            Console.WriteLine("Největší je a = c = " + a);
        else
            Console.WriteLine("Největší je c = " + c);
    else
        if (a == b)
            if (a > c)
                Console.WriteLine("Největší je a = b = " + a);
            else
                if (a == c)
                    Console.WriteLine("Největší je a = b = c = " + a);
                else
                    Console.WriteLine("Největší je c = " + c);
        else
            if (b > c)
                Console.WriteLine("Největší je b = " + b);
            else
                if (b == c)
                    Console.WriteLine("Největší je b = c = " + b);
                else
                    Console.WriteLine("Největší je c = " + c);
}

Kód 2: Deklarace statické metody bez návratu s názvem VetsiRovnoVerze1

Druhou deklarovanou metodou bez návratu je VetsiRovnoVerze2. V této metodě je využit princip kaskádování jednotlivých podmínek. Každá z devíti podmínek se skládá z jednotlivých částí, které jsou spojeny logických operátorem a zároveň (v C# se operátor značí &&) - viz Kód 3.  

/* Metoda bez návratu - výpis názvu parametru obsahující maximum a hodnoty maxima - 
 * kaskádování (pomocí spojování podmínek) */
static void VetsiRovnoVerze2(int a, int b, int c)
{
    // Spojení dvou podmínek pomocí 'a zároveň'
    if (a > b && a > c)
        // Výpis názvu maxima a hodnoty maxima
        Console.WriteLine("Největší je a = " + a);
    else if (a > b && a == c)
        Console.WriteLine("Největší je a = c = " + a);
    else if (a > b && a < c)
        Console.WriteLine("Největší je c = " + c);
    else if (a == b && a > c)
        Console.WriteLine("Největší je a = b = " + a);
    else if (a == b && a == c)
        Console.WriteLine("Největší je a = b = c = " + a);
    else if (a == b && a < c)
        Console.WriteLine("Největší je c = " + c);
    else if (a < b && b > c)
        Console.WriteLine("Největší je b = " + b);
    else if (a < b && b == c)
        Console.WriteLine("Největší je b = c = " + b);
    else if (a < b && b < c)
        Console.WriteLine("Největší je c = " + c);
    else
        Console.WriteLine("Někde je chyba!");
}

Kód 3: Deklarace statické metody bez návratu s názvem VetsiRovnoVerze2

Než se dostaneme k deklaraci další verze metody bez návratu, musíme se nejprve nadeklarovat metodu, která bude v rámci této metody volána. Tato jednoduchá metoda s celočíselným návratem VetsiRovno přijímá dva celočíselné parametry a ve svém těle porovnává jejich hodnoty - viz Kód 4. Návratem metody je větší z těchto hodnot (oproti vývojovému diagramu jsme vypustili zbytečnou lokální proměnnou z, která měla sloužit pouze pro uložení větší hodnoty a měla být přiřazena jako návrat funkce).

/* Metoda s celočíselným návratem většího čísla ze dvou přijímaných čísel
 * Parametry: 'x' ... první předané celé číslo; 'y' ... druhé předané celé číslo */
static int VetsiRovno(int x, int y)
{
    // Test, zda první předané číslo je větší, nebo rovno druhému
    if (x >= y)
    
        // První číslo je větší, nebo rovno druhému, výsledek metody je první nalezené číslo
        return x;
    else
        // Druhé číslo je větší než první, výsledek metody je druhé číslo
        return y;
}

Kód 3: Deklarace statické metody s návratem s názvem VetsiRovno

Metoda s návratem s názvem VetsiRovnoVerze3 využívá dvojité volání metody VetsiRovno čímž získá největší ze všech tří předaných čísel - maximum (prvním voláním získává větší ze dvou čísel uložených v a a b). Tuto hodnotu většího čísla, použijeme jako vstup pro vnější volání metody VetsiRovno, čímž se provede porovnání se třetím zbývajícím číslem uloženým v parametru c - viz Kód 4. 

// Metoda bez návratu - výpis názvu názvu parametru obsahující maximum a hodnoty maxima 
static void VetsiRovnoVerze3(int a, int b, int c)
{
    /* Deklarace: 'max' ... hodnota největšího předaného čísla (maxima); 
     * 's' ... text výsledného výpisu */
    int max;
    string s = "Největší je ";
 
    // Získání hodnoty maxima
    max = VetsiRovno(VetsiRovno(a, b), c);
 
    // Test rovnosti prvního předaného čísla s maximem
    if (a == max)
        // První číslo je maximem
        s += ("a = ");
    // Test rovnosti druhého předaného čísla s maximem
    if (b == max)
        // Druhé číslo je maximem
        s += ("b = ");
    // Test rovnosti třetího předaného čísla s maximem
    if (c == max)
        // Třetí číslo je maximem
        s += ("c = ");
    // Výpis názvu maxima a hodnoty maxima
    Console.WriteLine(s + max);
}

Kód 4: Deklarace statické metody bez návratu s názvem VetsiRovnoVerze3

Předposlední statickou metodou bez návratu je metoda VetsiRovnoVerze4. Metoda ve svém prvním příkazu if také využívá volání metody VetsiRovno s návratem, pomocí něhož získá větší číslo z prvních dvou předaných čísel této metodě. Toto číslo porovná se třetím číslem a vypíše výslednou hodnotu - viz Kód 5.

// Metoda bez návratu s výpisem maxima a zadaných hodnot - využití metody 'VetsiRovno'
static void VetsiRovnoVerze4(int a, int b, int c)
{
    /* Volání metody 'VetsiRovno' - návrat metody obsahuje vyšší (nebo stejné) číslo z prvních 
     * dvou předaných čísel -> návrat metody (větší číslo) je porovnán se 3. předaným číslem */
    if (VetsiRovno(a, b) >= c) 
        // Výpis největší hodnoty
        Console.WriteLine("Největší je {0} z čisel {1}, {2}, {3}", VetsiRovno(a, b), a, b, c);
    // Největší je 3. předané číslo
    else
        // Výpis největší hodnoty, tj. 3. předaného čísla
        Console.WriteLine("Největší je {0} z čísel {1}, {2}, {3}", c, a, b, c);
}

Kód 5: Deklarace statické metody bez návratu s názvem VetsiRovnoVerze4

Poslední volanou metodou je VetsiRovnoVerze5, která obsahuje pouze jeden příkaz výpisu, v němž je umístěno dvojité volání metody s návratem VetsiRovno. Tímto způsobem nám metoda přímo do výpisu navrátí hodnotu maxima ze všech tří čísel - viz Kód 6.

// Metoda bez návratu s výpisem maxima a zadaných hodnot - dvojité volání metody 'VetsiRovno'
static void VetsiRovnoVerze5(int a, int b, int c)
{
    /* Výpis největší hodnoty - využití dvojitého volání metody 'VetsiRovno' - první návrat metody 
     * obsahuje vyšší číslo z prvních dvou předaných čísel -> porovnání návratu metody se třetím 
     * předaným číslem -> získání maxima */
    Console.WriteLine("Největší je {0} z čísel {1}, {2}, {3}", VetsiRovno(VetsiRovno(a, b), c), a, b, c);
}

Kód 6: Deklarace statické metody bez návratu s názvem VetsiRovnoVerze5

3.3. Výsledný kód

Následující zdrojový kód je kompletací předešlých kódů programu NejvetsiZe3Cisel, který je umístěn v souboru Program.cs - viz Kód 1.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace NejvetsiZe3Cisel
{
    class Program
    {
        static void Main(string[] args)
        {
            /* Deklarace: 'a' ... první zadané celé číslo; 'b' ... druhé zadané celé číslo 
             * 'c' ... třetí zadané celé číslo */
            int a, b, c;
 
            // Výzva k zadání prvního celého čísla
            Console.Write("Zadejte a: ");
            /* Načtení prvního celého čísla a test, zda proběhla konverze celého 
             * čísla (návrat metody konverze je boolean) */
            bool konverze = int.TryParse(Console.ReadLine(), out a);
            // Pokud neproběhla konverze
            if (konverze == false)
            {
                // Výpis chyby při konverzi
                Console.WriteLine("Chyba při konverzi na celé číslo");
                // Čekání na stisk klávesy
                Console.ReadKey();
                // Ukončení programu
                return;
            }
 
            // Výzva k zadání druhého celého čísla
            Console.Write("Zadejte b: ");
            // Test, zda neproběhla konverze celého čísla (návrat metody konverze je boolean)
            if (int.TryParse(Console.ReadLine(), out b) == false)
            {
                // Výpis chyby při konverzi
                Console.WriteLine("Chyba při konverzi na celé číslo");
                // Čekání na stisk klávesy
                Console.ReadKey();
                // Ukončení programu
                return;
            }
 
            // Výzva k zadání třetího celého čísla
            Console.Write("Zadejte c: ");
            // Test, zda neproběhla konverze celého čísla (návrat metody konverze je boolean)
            if (int.TryParse(Console.ReadLine(), out c) == false)
            {
                // Výpis chyby při konverzi
                Console.WriteLine("Chyba při konverzi na celé číslo");
                // Čekání na stisk klávesy
                Console.ReadKey();
                // Ukončení programu
                return;
            }
 
            // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody bez návratu 'VetsiRovnoVerze1'
            Console.WriteLine("Porovnání tří čísel pomocí metody 'VetsiRovnoVerze1':");
 
            /* Volání metody 'VetsiRovnoVerze1' - výpis názvu proměnné obsahující maximum a hodnotu maxima  
             * je proveden uvnitř metody - vnořené rozhodování */
            VetsiRovnoVerze1(a, b, c);
 
            // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody 'VetsiRovnoVerze2'
            Console.WriteLine("Porovnání tří čísel pomocí metody 'VetsiRovnoVerze2':");
 
            /* Volání metody 'VetsiRovnoVerze2' bez návratu - výpis názvu proměnné obsahující maximum a hodnotu 
             * maxima je proveden uvnitř metody - princip kaskádování rozhodování */
            VetsiRovnoVerze2(a, b, c);
 
            // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody 'VetsiRovnoVerze3'
            Console.WriteLine("Porovnání tří čísel pomocí metody 'VetsiRovnoVerze3':");
 
            /* Volání metody 'VetsiRovnoVerze3' bez návratu (porovnání s maximem obdrženého z dvojitého 
             * volání metody 'VetsiRovno') - výpis maxima a zadaných hodnot je proveden uvnitř metody */
            VetsiRovnoVerze3(a, b, c);
 
            // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody 'VetsiRovnoVerze4'
            Console.WriteLine("Porovnání tří čísel pomocí metody 'VetsiRovnoVerze4':");
 
            /* Volání metody 'VetsiRovnoVerze4' bez návratu (využití volání metody 'VetsiRovno') - výpis 
             * maxima a zadaných hodnot je proveden uvnitř metody */
            VetsiRovnoVerze4(a, b, c);
 
            // Výpis textu pro oddělení porovnání provedeného pomocí zavolání metody 'VetsiVerze5'
            Console.WriteLine("Porovnání tří čísel pomocí metody 'VetsiRovnoVerze5':");
 
            /* Volání metody 'VetsiRovnoVerze5' bez návratu (využití dvojitého volání metody 'VetsiRovno') - 
             * výpis maxima a zadaných hodnot je proveden uvnitř metody */
            VetsiRovnoVerze5(a, b, c);
 
            // Čekání na stisk klávesy -> ukončení programu
            Console.ReadKey();
        }
 
        /* Metoda bez návratu - výpis názvu parametru obsahující maximum a hodnota 
         * maxima - vnořené rozhodování */
        static void VetsiRovnoVerze1(int a, int b, int c)
        {
            // Porovnání prvního a druhé předaného čísla
            if (a > b)
                // Vnořené rozhodování
                if (a > c)
                    // Výpis názvu maxima a hodnoty maxima
                    Console.WriteLine("Největší je a = " + a);
                else
                    if (a == c)
                    Console.WriteLine("Největší je a = c = " + a);
                else
                    Console.WriteLine("Největší je c = " + c);
            else
                if (a == b)
                    if (a > c)
                        Console.WriteLine("Největší je a = b = " + a);
                    else
                        if (a == c)
                            Console.WriteLine("Největší je a = b = c = " + a);
                        else
                            Console.WriteLine("Největší je c = " + c);
                else
                    if (b > c)
                        Console.WriteLine("Největší je b = " + b);
                    else
                        if (b == c)
                            Console.WriteLine("Největší je b = c = " + b);
                        else
                            Console.WriteLine("Největší je c = " + c);
        }
 
        /* Metoda bez návratu - výpis názvu parametru obsahující maximum a hodnoty maxima - 
         * kaskádování (pomocí spojování podmínek) */
        static void VetsiRovnoVerze2(int a, int b, int c)
        {
            // Spojení dvou podmínek pomocí 'a zároveň'
            if (a > b && a > c)
                // Výpis názvu maxima a hodnoty maxima
                Console.WriteLine("Největší je a = " + a);
            else if (a > b && a == c)
                Console.WriteLine("Největší je a = c = " + a);
            else if (a > b && a < c)
                Console.WriteLine("Největší je c = " + c);
            else if (a == b && a > c)
                Console.WriteLine("Největší je a = b = " + a);
            else if (a == b && a == c)
                Console.WriteLine("Největší je a = b = c = " + a);
            else if (a == b && a < c)
                Console.WriteLine("Největší je c = " + c);
            else if (a < b && b > c)
                Console.WriteLine("Největší je b = " + b);
            else if (a < b && b == c)
                Console.WriteLine("Největší je b = c = " + b);
            else if (a < b && b < c)
                Console.WriteLine("Největší je c = " + c);
            else
                Console.WriteLine("Někde je chyba!");
        }
 
        /* Metoda s celočíselným návratem většího čísla ze dvou přijímaných čísel
         * Parametry: 'x' ... první předané celé číslo; 'y' ... druhé předané celé číslo */
        static int VetsiRovno(int x, int y)
        {
            // Test, zda první předané číslo je větší, nebo rovno druhému
            if (x >= y)
            
                // První číslo je větší, nebo rovno druhému, výsledek metody je první nalezené číslo
                return x;
            else
                // Druhé číslo je větší než první, výsledek metody je druhé číslo
                return y;
        }
 
        // Metoda bez návratu - výpis názvu názvu parametru obsahující maximum a hodnoty maxima 
        static void VetsiRovnoVerze3(int a, int b, int c)
        {
            /* Deklarace: 'max' ... hodnota největšího předaného čísla (maxima); 
             * 's' ... text výsledného výpisu */
            int max;
            string s = "Největší je ";
 
            // Získání hodnoty maxima
            max = VetsiRovno(VetsiRovno(a, b), c);
 
            // Test rovnosti prvního předaného čísla s maximem
            if (a == max)
                // První číslo je maximem
                s += ("a = ");
            // Test rovnosti druhého předaného čísla s maximem
            if (b == max)
                // Druhé číslo je maximem
                s += ("b = ");
            // Test rovnosti třetího předaného čísla s maximem
            if (c == max)
                // Třetí číslo je maximem
                s += ("c = ");
            // Výpis názvu maxima a hodnoty maxima
            Console.WriteLine(s + max);
        }
 
        // Metoda bez návratu s výpisem maxima a zadaných hodnot - využití metody 'VetsiRovno'
        static void VetsiRovnoVerze4(int a, int b, int c)
        {
            /* Volání metody 'VetsiRovno' - návrat metody obsahuje vyšší (nebo stejné) číslo z prvních 
             * dvou předaných čísel -> návrat metody (větší číslo) je porovnán se 3. předaným číslem */
            if (VetsiRovno(a, b) >= c) 
                // Výpis největší hodnoty
                Console.WriteLine("Největší je {0} z čisel {1}, {2}, {3}", VetsiRovno(a, b), a, b, c);
            // Největší je 3. předané číslo
            else
                // Výpis největší hodnoty, tj. 3. předaného čísla
                Console.WriteLine("Největší je {0} z čísel {1}, {2}, {3}", c, a, b, c);
        }
 
        // Metoda bez návratu s výpisem maxima a zadaných hodnot - dvojité volání metody 'VetsiRovno'
        static void VetsiRovnoVerze5(int a, int b, int c)
        {
            /* Výpis největší hodnoty - využití dvojitého volání metody 'VetsiRovno' - první návrat metody 
             * obsahuje vyšší číslo z prvních dvou předaných čísel -> porovnání návratu metody se třetím 
             * předaným číslem -> získání maxima */
            Console.WriteLine("Největší je {0} z čísel {1}, {2}, {3}", VetsiRovno(VetsiRovno(a, b), c), a, b, c);
        }
    }
}

Kód 1: Program NejvetsiZe3Cisel - deklarace hlavní statické metody Main včetně deklarací dalších metod

Výstup programu

Na následujícím výstupu programu vidíme výpis největší hodnoty ze tří porovnaných hodnot - viz Výstup programu 1 - Kód 1. Jednotlivá porovnání jsou rozdělena do různých sekcí, abychom věděli, pomocí které metody s návratem byla získána největší hodnota a v prvních třech volaných metodách je také uveden název parametru, ve kterém je uloženo maximum. Po provedení výpisu konzolová aplikace čeká na stisk klávesy, aby po stisku klávesy byla následně ukončena. Na prvním výstupu v konzole vidíme, že největší číslo je třetí zadané číslo. 

Výstup programu 1 - Kód 1: Ukázka výpisu největší hodnoty v hlavní statické metodě programu NejvetsiZe3Cisel

Pokud byla zadána např. dvě stejná čísla, je pomocí prvních tří metod vypsána rovnost obou čísel (u čtvrté a páté je vypsán pouze seznam zadaných čísel) - viz Výstup programu 2 - Kód 1.

Výstup programu 2 - Kód 1: Ukázka výpisu dvou stejných hodnot v hlavní statické metodě programu NejvetsiZe3Cisel

Pokud uživatel zadal špatný číselný vstup (např. text "bflm") návrat metody TryParse nabývá hodnoty false a je spuštěn příkaz výpisu chybové hlášky. Abychom si mohli přečíst chybovou hlášku, je za příkaz výpisu v kódu umístěn příkaz pro načtení znaku. Po stisku klávesy následuje ukončení programu pomocí příkazu return - viz Výstup programu 3 - Kód 1.

Výstup programu 3 - Kód 1: Ukázka výpisu chyby při konverzi v hlavní statické metodě programu NejvetsiZe3Cisel

4. NejvetsiZe3CiselWPF

Výstup programu: Ukázka nalezení největšího čísla ze 3 čísel v programu NejvetsiZe3CiselWPF

4.1. Analýza a návrh řešení

V příkladu je využit stejný princip jako v případě příkladu NejvetsiZe3Cisel, proto již není zapotřebí provádět detailní analýzu principu porovnání čísel. 

Pro rozložení jednotlivých prvků použijeme Grid, který rozdělíme na 6 řádků a 2 sloupce. Do posledního řádku Grid umístíme StackPanel, do něhož umístíme další dva WrapPanel. První WrapPanel bude obsahovat jednotlivá tlačítka pro porovnání. V pravé dolní části v druhém objektu WrapPanel bude vloženo tlačítko pro ukončení aplikace - viz Obrázek 1.  

Obrázek 1: Návrh GUI - rozložení prvků v mřížce formuláře (NejvetsiZe3CiselWPF)

Na formulář bude vloženo 5 tlačítek pro různé varianty porovnání, které budou spouštět provádění kódu v CodeBehind- viz Obrázek 2.

Obrázek 2: Návrh GUI a účel jednotlivých objektů (NejvetsiZe3CiselWPF)

Pro 1. až 3. variantu bude po stisku tlačítka proveden výpis hodnoty maxima přímo v dialogovém okně včetně názvu proměnné, ve které se hodnota nachází - viz Obrázek 3.

Obrázek 3: Příklad výpisu výsledku v dialogovém oknu - 1. až 3. varianta

V metodách pro obsluhu stisknutí tlačítek u 1. a 3. varianty je ve výpisu také implementována možnost rovnosti čísel - viz Obrázek 4.

Obrázek 4: Příklad výpisu shodné hodnoty výsledku v dialogovém oknu - 1. až 3. varianta

Pokud uživatel stiskne tlačítko pro 4. nebo 5. variantu, již neobdrží název proměnné, ve které je hodnota maxima uložena - viz Obrázek 5.

Obrázek 5: Příklad výpisu výsledku v dialogovém oknu - 4. a 5. varianta

Pokud byl do prvku pro zadání čísla zadán text, který nelze konvertovat na celé číslo, při opuštění tohoto prvku bude do prvku umístěn text "Zadejte číslo". 

4.2. XAML

Formulář bude rozdělen do šesti řádků, jejichž výšky jsou nastaveny následujícím způsobem - viz Kód 1. První řádek je nastaven na fixní výšku 50 pixelů a výška druhého, třetího, čtvrtého a šestého řádku se bude přizpůsobovat obsahu vložených prvků.

<Grid.RowDefinitions>
    <RowDefinition Height="50"/>
    <RowDefinition Height="Auto"/>
    <RowDefinition Height="Auto"/>
    <RowDefinition Height="Auto"/>
    <RowDefinition Height="*"/>
    <RowDefinition Height="Auto"/>
</Grid.RowDefinitions>

Kód 1: Rozdělení Grid na řádky

Grid bude rozdělen do dvou sloupců, které budou sloužit k oddělení popisků od prvků pro vložení celočíselných hodnot, které bude porovnány. Šířka prvního sloupce bude přizpůsobena obsahu popisků a šířka druhého sloupce vyplní zbytek formuláře - viz Kód 2.

<Grid.ColumnDefinitions>
    <ColumnDefinition Width="Auto"/>
    <ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>

Kód 2: Rozdělení Grid na sloupce

Druhý, třetí a čtvrtý řádek bude každý obsahovat popisek (prvek typu Label) a vedle něj vpravo bude umístěn prvek pro vložení celočíselné hodnoty (prvek typu TextBox). U těchto prvků bude definována obsluha události přepnutí se na tento prvek (zaměření objektu - událost GotFocus) a opuštění tohoto prvku (LostFocus). Jednotlivé vlastnosti prvků jsou nastaveny následujícím způsobem - viz Kód 3.

<Label Content="A (první celé číslo):" Grid.Row="1" Margin="25,5,5,5"/>
<TextBox Name="TxtA" Grid.Row="1" Grid.Column="1" Margin="5" Text="0" VerticalContentAlignment="Center" GotFocus="TxtA_GotFocus" LostFocus="TxtA_LostFocus"/>
 
<Label Content="B (druhé celé číslo):" Grid.Row="2" Margin="25,5,5,5" />
<TextBox Name="TxtB" Grid.Row="2" Grid.Column="1" Margin="5" Text="0" VerticalContentAlignment="Center" GotFocus="TxtB_GotFocus" LostFocus="TxtB_LostFocus"/>
 
<Label Content="C (třetí celé číslo):" Grid.Row="3" Margin="25,5,5,5"/>
<TextBox Name="TxtC" Grid.Row="3" Grid.Column="1" Margin="5" Text="0" VerticalContentAlignment="Center" GotFocus="TxtC_GotFocus" LostFocus="TxtC_LostFocus"/>

Kód 3: Prvky typu Label a TextBox umístěné v jednotlivých řádcích 

Pro vložení dvou řad pro tlačítka použijeme prvek typu StackPanel, který umístíme do poslední řádky. Tento prvek bude obsahovat prvek typu WrapPanel, do něhož bude vložena jednotlivá tlačítka, která budou spouštět různé metody pro porovnání zadaných čísel. Vlastnost horizontálního zarovnání (HorizontalAlignment) nastavíme na střed, tzn. tlačítka budou zarovnána do řady, jejíž střed bude vycentrován vůči formuláři. 

Pro tlačítka vygenerujeme obsluhu události stisknutí tlačítka (událost Click) pomocí nastavení vlastnosti Click a zvolení položky <New Event Handler>. 

Do druhého WrapPanel vložíme tlačítko Konec, které zavře formulář. Toto tlačítko umístíme k pravému okraji formuláře, tj. nastavíme vlastnost horizontálního zarovnání vpravo - viz Kód 4.

<StackPanel Grid.Row="5" Grid.ColumnSpan="2">
    <WrapPanel HorizontalAlignment="Center">
        <Button Name="BtnPorovnej1"  Content="Porovnej varianta 1" Margin="5" Padding="5" Click="BtnPorovnej1_Click"/>
        <Button Name="BtnPorovnej2" Content="Porovnej varianta 2" Margin="5" Padding="5" Click="BtnPorovnej2_Click"/>
        <Button Name="BtnPorovnej3" Content="Porovnej varianta 3" Margin="5" Padding="5" Click="BtnPorovnej3_Click"/>
        <Button Name="BtnPorovnej4" Content="Porovnej varianta 4" Margin="5" Padding="5" Click="BtnPorovnej4_Click"/>
        <Button Name="BtnPorovnej5" Content="Porovnej varianta 5" Margin="5" Padding="5" Click="BtnPorovnej5_Click"/> 
    </WrapPanel>
    <WrapPanel HorizontalAlignment="Right">
        <Button Name="BtnKonec" Content="Konec" Margin="5" Width="80" Padding="5" Click="BtnKonec_Click"/>
    </WrapPanel>
</StackPanel>

Kód 4: Vložení tlačítek do prvků typu WrapPanel

Výsledný formulář

Navržené rozložení prvků na formuláři, včetně formuláře samotného, je vidět na následujícím obrázku - viz Obrázek 1.

Obrázek 1: Výsledný formulář WPF aplikace

Objekty na formuláři

Formulář obsahuje následující objekty (kontrolky):

• Grid
• StackPanel
• WrapPanel
• Label
• TextBox
• TxtA
• TxtB
• TxtC
• Button
• BtnPorovnej1
• BtnPorovnej2
• BtnPorovnej3
• BtnPorovnej4
• BtnPorovnej5
• BtnKonec

Obrázek 2: VS - okno Document Outline - seznam objektů

4.3. XAML - prvky formuláře

Nastavení formuláře

Následující XAML kód obsahuje nastavení formuláře - viz Kód 1. Pokud je zapotřebí zkopírujte XAML kód a vložte jej namísto řádky s nastavením vlastností okna (řádek začíná Title=....).

Title="Porovnej" Height="350" Width="800">

Kód 1: Nastavení vlastností formuláře

Grid

        <Grid.RowDefinitions>
            <RowDefinition Height="50"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto"/>
            <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>
        <Label Content="A (první celé číslo):" Grid.Row="1" Margin="25,5,5,5"/>
        <TextBox Name="TxtA" Grid.Row="1" Grid.Column="1" Margin="5" Text="0" VerticalContentAlignment="Center" />
 
        <Label Content="B (druhé celé číslo):" Grid.Row="2" Margin="25,5,5,5" />
        <TextBox Name="TxtB" Grid.Row="2" Grid.Column="1" Margin="5" Text="0" VerticalContentAlignment="Center" />
 
        <Label Content="C (třetí celé číslo):" Grid.Row="3" Margin="25,5,5,5"/>
        <TextBox Name="TxtC" Grid.Row="3" Grid.Column="1" Margin="5" Text="0" VerticalContentAlignment="Center" />
 
        <StackPanel Grid.Row="5" Grid.ColumnSpan="2">
            <WrapPanel HorizontalAlignment="Center">
                <Button Name="BtnPorovnej"  Content="Porovnej varianta 1" Margin="5" Padding="5" />
                <Button Name="BtnPorovnej2" Content="Porovnej varianta 2" Margin="5" Padding="5" />
                <Button Name="BtnPorovnej3" Content="Porovnej varianta 3" Margin="5" Padding="5" />
                <Button Name="BtnPorovnej4" Content="Porovnej varianta 4" Margin="5" Padding="5" />
                <Button Name="BtnPorovnej5" Content="Porovnej varianta 5" Margin="5" Padding="5" />
 
            </WrapPanel>
            <WrapPanel HorizontalAlignment="Right">
                <Button Name="BtnKonec" Content="Konec" Margin="5" Width="80" Padding="5" />
            </WrapPanel>
        </StackPanel>

Kód 2: Prvky v Grid

4.4. C#

V souboru MainWindow.xaml.cs obsahující kód na pozadí (Code Behind) byla vygenerována základní struktura našeho programu v C# s konstruktorem MainWindow stejnojmenné částečné třídy MainWindow. Tělo konstruktoru obsahuje pouze metodu InitializeComponent(). Dále byly vygenerovány soukromé (private) metody bez návratu:

• TxtA_GotFocus
• TxtB_GotFocus
• TxtC_GotFocus
• TxtA_LostFocus
• TxtB_LostFocus
• TxtC_LostFocus
• BtnPorovnej1_Click
• BtnPorovnej2_Click
• BtnPorovnej3_Click
• BtnPorovnej4_Click
• BtnPorovnej5_Click
• BtnKonec_Click

Všechny tyto události začleníme do regionu Události - viz Kód 1. Počáteční značku (#region Události) umístíme před první metodu obsluhy tlačítka a koncovou značku (#endregion) za poslední metodu obsluhy tlačítka.

#region Události
 
#endregion

Kód 1: Deklarace regionu s názvem Události

V následujícím kódu vidíme popisek statické třídy Constants, včetně její datové složky, jenž představuje konstantní textový řetězec s názvem ZadCislo, ve kterém je uložena hodnota (text) "Zadejte číslo" - viz Kód 2.

/// <summary>
/// Statická třída obsahující deklaraci textové konstanty
/// </summary>
static class Constants
{
    // Deklarace a inicializace datové složky třídy
    public const string ZadCislo = "Zadejte číslo";
}

Kód 2: Deklarace statické třídy Constants s veřejně přístupnou datovou konstantní textovou složkou 

Takto deklarovanou statickou třídu využijeme v konstruktoru (metoda pro tvorbu formuláře) k vypsání textu "Zadejte číslo" v prvcích pro zadání celých čísel - viz Kód 3. Znamená to, že v prvcích na formuláři bude po spuštění aplikace vypsán stejný text. K datové složce statické třídy (v našem případě textové konstantě) přistoupíme pomocí tečkové notace uvedené za statickou třídou.

// Konstruktor třídy
public MainWindow()
{
    InitializeComponent();
    // Při spuštění aplikace je vypsán text v prvcích pro čísla
    TxtA.Text = Constants.ZadCislo;
    TxtB.Text = Constants.ZadCislo;
    TxtC.Text = Constants.ZadCislo;
}

Kód 3: Deklarace konstruktoru třídy

V první metodě pro obsluhu události zacílení (GotFocus) objektu TxtA typu TextBox, sloužící pro zadání prvního porovnávaného čísla, vytvoříme kód, který bude pomocí podmínky if detekovat, zda při přepnutí na objekt obsahuje počáteční text "Zadejte číslo". Pokud ano, vymažeme tento text, aby uživatel mohl jednoduše zadat číslo (jedná se o číslice) - viz Kód 4. Stejným způsobem budeme definovat těla metod TxtB_GotFocus, TxtC_GotFocus. 

// Vymazání počátečního textu v objektu pro první číslo
private void TxtA_GotFocus(object sender, RoutedEventArgs e)
{
    // Pokud je umístěn počáteční text "Zadejte číslo" v objektu pro první číslo 
    if (this.TxtA.Text == Constants.ZadCislo)
    {
        // Vymazání textu v objektu pro první číslo
        this.TxtA.Text = string.Empty;
    }
}

Kód 4: Deklarace metody pro zacílení objektu prvního čísla (TxtA_GotFocus)

Další metodou, kterou budeme specifikovat, je obsluha opuštění objektu porovnávaného čísla na formuláři (událost LostFocus). Pokud objekt neobsahuje číslo (text ve formě číslic), nebo pokud nelze konvertovat (metoda TryParse) zadané číslice na celé číslo, které uložíme do lokální celočíselné proměnné a, vyplníme objekt textem "Zadejte číslo". V podmínce příkazu if použijeme logický součet - disjunkce mezi dvěma částmi podmínky (operátor ||) , který znamená nebo - viz Kód 5. Obdobným způsobem budeme definovat těla metod TxtB_LostFocus a TxtC_LostFocus.

// Vyplnění počátečního textu v objektu pro první číslo při opuštění prázdného objektu
private void TxtA_LostFocus(object sender, RoutedEventArgs e)
{
    // Pokud objekt prvního čísla neobsahuje text, nebo nelze konvertovat text na číslo
    if ((this.TxtA.Text == string.Empty) || (int.TryParse(this.TxtA.Text, out int a) == false))
    {
        // Vyplnění objektu textem "Zadejte číslo"
        this.TxtA.Text = Constants.ZadCislo;
    }
}

Kód 5: Deklarace metody pro opuštění objektu prvního čísla (TxtA_LostFocus)

Asi jste si všimli, že výstupní celočíselný parametr a, není předán do další metody, která by s ním pracovala. Mělo by být naší snahou redukovat počet proměnných, protože každá proměnná představuje kousek paměti počítače, který je pro ní rezervován, abychom do něj mohli ukládat hodnoty. V případě metody TryParse nepotřebujeme s proměnnou a dále pracovat, nebo ji někam dále předávat. To zajistíme v jiné metodě. Proto je možné nahradit deklaraci proměnné int a za klíčovým out podtržítkem _ - viz Kód 6. Tento operátor představuje zástupnou proměnnou, do níž není zapotřebí ukládat hodnotu (v angličtině naleznete vysvětlení pod pojmem Discards). Toto nahrazení zástupnou proměnnou lze v jazyce C# používat od verze 7.0.

int.TryParse(this.TxtA.Text, out _) == false

 Kód 6 - Konverze se zástupnou proměnnou (hodnota není uložena do výstupní proměnné)

Následující kód obsahuje tělo první metody pro obsluhu události Click tlačítka BtnPorovnej1 - viz Kód 7. V začátku metody jsou deklarovány 3 celočíselné proměnné, jejichž hodnoty jsou načteny z prvků na formuláři. Tyto hodnoty jsou načteny pomocí vlastnosti Text vyvolané pomocí tečkové notace u prvku. Načtená hodnota představuje textový řetězec (datový typ string), proto je zapotřebí hodnotu konvertovat na celé číslo pomocí metody TryParse vyvolané pomocí tečkové notace u datového typu int. Výstupním parametrem této metody je příslušná proměnná, tzn. konvertovaná hodnota je uložena do proměnné. Pro porovnání čísel je použito vnořené rozhodování umístěné přímo v metodě. 

// Metoda bez návratu pro porovnání 3 čísel - vnořené rozhodování
private void BtnPorovnej1_Click(object sender, RoutedEventArgs e)
{
    /* Deklarace lokálních proměnných: 'a' ... první celé číslo; 'b' ... druhé celé číslo;
     * 'c' ... třetí celé číslo */
    int a, b, c;
 
    // Konverze textu na číslo a uložení do proměnné 'a'
    int.TryParse(TxtA.Text, out a);
    int.TryParse(TxtB.Text, out b);
    int.TryParse(TxtC.Text, out c);
 
    // Porovnání prvního a druhé čísla
    if (a > b)
        // Vnořené rozhodování
        if (a > c)
            // Výpis názvu maxima a hodnoty maxima do dialogového okna
            MessageBox.Show("Největší je a = " + a);
        else
            if (a == c)
                MessageBox.Show("Největší je a = c = " + a);
            else
                MessageBox.Show("Největší je c = " + c);
    else
        if (a == b)
            if (b > c)
                MessageBox.Show("Největší je a = b = " + a);
            else
                if (b == c)
                    MessageBox.Show("Největší je a = b = c = " + a);
                else
                    MessageBox.Show("Největší je c = " + c);
        else
            if (b > c)
                MessageBox.Show("Největší je b = " + b);
            else
                if (b == c)
                    MessageBox.Show("Největší je b = c = " + b);
                else
                    MessageBox.Show("Největší je c = " + c);
}

Kód 7: Deklarace metody pro porovnání 3 celočíselných hodnot - vnořené rozhodování (BtnPorovnej1_Click)

Dalším přístupem při hledání maxima ze 3 zadaných čísel je využití kaskádování rozhodovacích podmínek s využitím logického součinu - konjunkce (a zároveň, tj. operátor &&) uvedeného v podmínce - viz Kód 8. Výpis je zajištěn v dialogovém oknu.

// Metoda bez návratu pro porovnání 3 čísel - kaskádování (pomocí spojování podmínek)
private void BtnPorovnej2_Click(object sender, RoutedEventArgs e)
{
    // Deklarace lokálních proměnných: 'a', 'b', 'c' ... tři celá čísla
    int a, b, c;
 
    // Konverze textu na číslo a uložení do proměnné 'a'
    int.TryParse(TxtA.Text, out a);
    int.TryParse(TxtB.Text, out b);
    int.TryParse(TxtC.Text, out c);
 
    // Spojení dvou podmínek pomocí 'a zároveň'
    if (a > b && a > c)
        // Výpis názvu maxima a hodnoty maxima do dialogového okna
        MessageBox.Show("Největší je a = " + a);
    else 
        if (a > b && a == c)
            MessageBox.Show("Největší je a = c = " + a);
        else 
            if (a > b && a < c)
                MessageBox.Show("Největší je c = " + c);
            else 
                if (a == b && a > c)
                    MessageBox.Show("Největší je a = b = " + a);
                else 
                    if (a == b && a == c)
                        MessageBox.Show("Největší je a = b = c = " + a);
                    else 
                        if (a == b && a < c)
                            MessageBox.Show("Největší je c = " + c);
                        else 
                            if (a < b && b > c)
                                MessageBox.Show("Největší je b = " + b);
                            else 
                                if (a < b && b == c)
                                    MessageBox.Show("Největší je b = c = " + b);
                                else 
                                    if (a < b && b < c)
                                        MessageBox.Show("Největší je c = " + c);
                                    else
                                        MessageBox.Show("Někde je chyba!");
}

Kód 8: Deklarace metody pro porovnání 3 celočíselných hodnot - kaskádování s využitím logické spojky (BtnPorovnej2_Click)

Před region Výpočty deklarujeme metodu s celočíselným návratem VetsiRovno, která bude provádět návrat většího čísla z předaných čísel (nebo rovné druhému) - viz Kód 9. Oba parametry jsou předány hodnotou. Další možností zápisu těla metody je využít ternární operátor, kde jak vidíte, zápis se vejde na jednu řádku (tento kód je zakomentován, tzn. nebude vykonán).

/// <summary>
/// Metoda s celočíselným návratem většího čísla ze dvou přijímaných čísel
/// </summary>
/// <param name="x"> první celé číslo předané hodnotou </param>
/// <param name="y"> druhé celé číslo předané hodnotou </param>
/// <returns> maximum ze dvou čísel </returns>
private int VetsiRovno(int x, int y)
{
    // Pokud je první předané číslo větší, nebo rovno druhému...
    if (x >= y)
 
        // Metoda navrací první číslo
        return x;
    // Jinak...
    else
        // Metoda navrací druhé číslo
        return y;
 
    // Jiný způsob řešení pomocí ternárního operátoru
    //return (a >= b ? a : b); 
}

Kód 9: Deklarace soukromé metody s návratem s názvem VetsiRovno

Deklarovanou metodu s návratem budeme následně dvakrát volat v metodě bez návratu pro obsluhu události kliknutí na tlačítko BtnPorovnej3 - viz Kód 10. V metodě jsou deklarovány kromě lokálních proměnných a, b a c další lokální proměnné max, které reprezentuje maximum získané dvojitým voláním metody s návratem VetsiRovno. V prvním volání této metody je použit jako první parametr výsledek z dalšího volání této metody, který představuje vetší číslo z čísel uložených v a a b. Další lokální proměnnou je textový řetězec s (datový typ string), do kterého vložíme počáteční text "Největší je ". Pak k tomuto textu připojíme název maxima včetně jeho hodnoty na základě výsledku testu rovnosti z jednotlivých podmínek.

// Metoda bez návratu pro porovnání 3 čísel - volání metody s návratem
private void BtnPorovnej3_Click(object sender, RoutedEventArgs e)
{
    // Deklarace lokálních proměnných: 'a', 'b', 'c' ... tři celá čísla
    int a, b, c;
    /* Deklarace: 'max' ... hodnota největšího čísla (maxima); 
     * 's' ... text výsledného výpisu */
    int max;
    string s = "Největší je ";
 
    // Konverze textu na číslo a uložení do proměnné 'a'
    int.TryParse(TxtA.Text, out a);
    int.TryParse(TxtB.Text, out b);
    int.TryParse(TxtC.Text, out c);
 
    // Získání hodnoty maxima - první parametr je maximum z čísel 'a' a 'b'
    max = VetsiRovno(VetsiRovno(a, b), c);
 
    // Pokud je první číslo rovno maximum...
    if (a == max)
        // První číslo je maximem
        s += ("a = ");
    // Pokud je druhé číslo rovno maximum...
    if (b == max)
        // Druhé číslo je maximem
        s += ("b = ");
    // Pokud je třetí číslo rovno maximum...
    if (c == max)
        // Třetí číslo je maximem
        s += ("c = ");
    // Výpis názvu maxima a hodnoty maxima
    MessageBox.Show(s + max);
}

Kód 10: Deklarace metody pro porovnání 3 celočíselných hodnot - volání metody s návratem VetsiRovno (BtnPorovnej3_Click)

Ve čtvrté verzi metody pro porovnání tří zadaných čísel využijeme volání metody VetsiRovno. Této metodě předáme dvě první čísla (a a b), a návrat ve formě většího čísla porovnáme se třetím číslem c. Pokud je některé ze dvou čísel větší (nebo rovno) než třetí číslo, vypíšeme pouze hodnotu většího čísla z prvních dvou čísel a hodnoty všech zadaných čísel. Pokud neplatí uvedená podmínka, největší číslo je c (třetí zadané číslo) a vypíšeme v dialogovém oknu jeho hodnotu a hodnoty všech zadaných čísel - viz Kód 11. 

// Metoda bez návratu s výpisem maxima a zadaných hodnot - využití metody 'VetsiRovno'
private void BtnPorovnej4_Click(object sender, RoutedEventArgs e)
{
    // Deklarace lokálních proměnných: 'a', 'b', 'c' ... tři celá čísla
    int a, b, c;
 
    // Konverze textu na číslo a uložení do proměnné 'a'
    int.TryParse(TxtA.Text, out a);
    int.TryParse(TxtB.Text, out b);
    int.TryParse(TxtC.Text, out c);
 
    /* Pokud je návrat metody 'VetsiRovno' z prvních dvou porovnávaných čísel větší 
     * (nebo stejné) číslo než 3. číslo potom ... */
    if (VetsiRovno(a, b) >= c)
        // Výpis největší hodnoty z prvních dvou porovnávaných čísel
        MessageBox.Show("Největší (nebo rovné) je " + VetsiRovno(a, b) + " z čisel " + a + ", " + b + ", " + c);
    // Jinak... 
    else
        // Výpis největší hodnoty, tj. 3. čísla
        MessageBox.Show("Největší (nebo rovné) je " + c + " z čísel " + a + ", " + b + ", " + c);
}

Kód 11: Deklarace metody pro porovnání 3 celočíselných hodnot - volání metody s návratem VetsiRovno (BtnPorovnej4_Click)

Poslední volanou metodou, která obsahuje pouze jeden příkaz výpisu v dialogovém oknu je metoda bez návratu BtnPorovnej5_Click. V příkazu je umístěno dvojité volání metody s návratem VetsiRovno. Tímto způsobem nám metoda přímo do výpisu navrátí hodnotu maxima ze všech tří čísel. Pro výpis v dialogovém oknu musíme toto maximum konvertovat na číslice pomocí metody Format, která je vyvolána pomocí tečkové notace datového typu string (tato metoda má různé verze, kterými určíme, v jakém formát má být hodnota vypsána) - viz Kód 12. Jak si můžete všimnout, výpis má stejnou formu, kterou jsme použili při výpisu v konzolové aplikaci.

// Metoda bez návratu s výpisem maxima a zadaných hodnot - dvojité volání metody 'VetsiRovno'
private void BtnPorovnej5_Click(object sender, RoutedEventArgs e)
{
    // Deklarace lokálních proměnných: 'a', 'b', 'c' ... tři celá čísla
    int a, b, c;
 
    // Konverze textu na číslo a uložení do proměnné 'a'
    int.TryParse(TxtA.Text, out a);
    int.TryParse(TxtB.Text, out b);
    int.TryParse(TxtC.Text, out c);
 
    /* Výpis největší hodnoty - využití dvojitého volání metody 'VetsiRovno' - první návrat metody 
     * obsahuje vyšší číslo z prvních dvou předaných čísel -> porovnání návratu metody se třetím 
     * předaným číslem -> získání maxima -> konverze hodnoty na číslice */
    MessageBox.Show(string.Format("Největší (nebo rovné) je {0} z čísel {1}, {2}, {3}", VetsiRovno(VetsiRovno(a, b), c), a, b, c));
}

Kód 12: Deklarace metody pro porovnání 3 celočíselných hodnot - dvojité volání metody VetsiRovno pro návrat maxima (BtnPorovnej5_Click)

Metoda, která zajistí zavření formuláře, je metoda pro obsluhu události Click tlačítka Konec - viz Kód 13.

//Metoda bez návratu pro zavření formuláře
private void BtnKonec_Click(object sender, RoutedEventArgs e)
{
    // Zavření formuláře
    this.Close();
}

Kód 13: Deklarace metody bez návratu pro zavření formuláře (BtnKonec_Click)

4.5. Výsledný kód

XAML kód

Výsledný XAML kód formuláře (MainWindow.xaml) - viz Kód 1.

<Window x:Class="NejvetsiZe3CiselWPF.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:NejvetsiZe3CiselWPF"
        mc:Ignorable="d"
        Title="Porovnej" Height="350" Width="800">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="50"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto"/>
            <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>
        <Label Content="A (první celé číslo):" Grid.Row="1" Margin="25,5,5,5"/>
        <TextBox Name="TxtA" Grid.Row="1" Grid.Column="1" Margin="5" Text="0" VerticalContentAlignment="Center" GotFocus="TxtA_GotFocus" LostFocus="TxtA_LostFocus"/>
 
        <Label Content="B (druhé celé číslo):" Grid.Row="2" Margin="25,5,5,5" />
        <TextBox Name="TxtB" Grid.Row="2" Grid.Column="1" Margin="5" Text="0" VerticalContentAlignment="Center" GotFocus="TxtB_GotFocus" LostFocus="TxtB_LostFocus"/>
 
        <Label Content="C (třetí celé číslo):" Grid.Row="3" Margin="25,5,5,5"/>
        <TextBox Name="TxtC" Grid.Row="3" Grid.Column="1" Margin="5" Text="0" VerticalContentAlignment="Center" GotFocus="TxtC_GotFocus" LostFocus="TxtC_LostFocus"/>
 
        <StackPanel Grid.Row="5" Grid.ColumnSpan="2">
            <WrapPanel HorizontalAlignment="Center">
                <Button Name="BtnPorovnej1"  Content="Porovnej varianta 1" Margin="5" Padding="5" Click="BtnPorovnej1_Click"/>
                <Button Name="BtnPorovnej2" Content="Porovnej varianta 2" Margin="5" Padding="5" Click="BtnPorovnej2_Click"/>
                <Button Name="BtnPorovnej3" Content="Porovnej varianta 3" Margin="5" Padding="5" Click="BtnPorovnej3_Click"/>
                <Button Name="BtnPorovnej4" Content="Porovnej varianta 4" Margin="5" Padding="5" Click="BtnPorovnej4_Click"/>
                <Button Name="BtnPorovnej5" Content="Porovnej varianta 5" Margin="5" Padding="5" Click="BtnPorovnej5_Click"/>
            </WrapPanel>
            <WrapPanel HorizontalAlignment="Right">
                <Button Name="BtnKonec" Content="Konec" Margin="5" Width="80" Padding="5" Click="BtnKonec_Click"/>
            </WrapPanel>
        </StackPanel>
    </Grid>
</Window>

Kód 1: Výsledný XAML kód vytvořeného formuláře

C# kód

Code Behind - C# kód pro veškeré události vyvolané uživatelem při manipulaci s aplikací (MainWindow.xaml.cs) - viz Kód 2.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
 
namespace NejvetsiZe3CiselWPF
{
    /// <summary>
    /// Statická třída obsahující deklaraci textové konstanty
    /// </summary>
    static class Constants
    {
        // Deklarace a inicializace datové složky třídy
        public const string ZadCislo = "Zadejte číslo";
    }
 
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        // Konstruktor třídy
        public MainWindow()
        {
            InitializeComponent();
            // Při spuštění aplikace je vypsán text v prvcích pro čísla
            TxtA.Text = Constants.ZadCislo;
            TxtB.Text = Constants.ZadCislo;
            TxtC.Text = Constants.ZadCislo;
        }
 
        /// <summary>
        /// Metoda s celočíselným návratem většího čísla ze dvou přijímaných čísel
        /// </summary>
        /// <param name="x"> první celé číslo předané hodnotou </param>
        /// <param name="y"> druhé celé číslo předané hodnotou </param>
        /// <returns> maximum ze dvou čísel </returns>
        private int VetsiRovno(int x, int y)
        {
            // Pokud je první předané číslo větší, nebo rovno druhému...
            if (x >= y)
 
                // Metoda navrací první číslo
                return x;
            // Jinak...
            else
                // Metoda navrací druhé číslo
                return y;
 
            // Jiný způsob řešení pomocí ternárního operátoru
            //return (a >= b ? a : b); 
        }
 
        #region Události
 
        // Vymazání počátečního textu v objektu pro první číslo
        private void TxtA_GotFocus(object sender, RoutedEventArgs e)
        {
            // Pokud je umístěn počáteční text "Zadejte číslo" v objektu pro první číslo 
            if (this.TxtA.Text == Constants.ZadCislo)
            {
                // Vymazání textu v objektu pro první číslo
                this.TxtA.Text = string.Empty;
            }
        }
 
        // Vymazání počátečního textu v objektu pro druhé číslo
        private void TxtB_GotFocus(object sender, RoutedEventArgs e)
        {
            if (this.TxtB.Text == Constants.ZadCislo)
            {
                this.TxtB.Text = string.Empty;
            }
        }
 
        // Vymazání počátečního textu v objektu pro třetí číslo
        private void TxtC_GotFocus(object sender, RoutedEventArgs e)
        {
            if (this.TxtC.Text == Constants.ZadCislo)
            {
                this.TxtC.Text = string.Empty;
            }
        }
 
        // Vyplnění počátečního textu v objektu pro první číslo při opuštění prázdného objektu
        private void TxtA_LostFocus(object sender, RoutedEventArgs e)
        {
            // Pokud objekt prvního čísla neobsahuje text, nebo nelze konvertovat text na číslo
            if ((this.TxtA.Text == string.Empty) || (int.TryParse(this.TxtA.Text, out int a) == false))
            {
                // Vyplnění objektu textem "Zadejte číslo"
                this.TxtA.Text = Constants.ZadCislo;
            }
        }
 
        // Vyplnění počátečního textu v objektu pro druhé číslo při opuštění prázdného objektu
        private void TxtB_LostFocus(object sender, RoutedEventArgs e)
        {
            // Pokud objekt prvního čísla neobsahuje text, nebo nelze konvertovat text na číslo
            if ((this.TxtB.Text == string.Empty) || (int.TryParse(this.TxtB.Text, out _) == false))
            {
                // Vyplnění objektu textem "Zadejte číslo"
                this.TxtB.Text = Constants.ZadCislo;
            }
        }
 
        // Vyplnění počátečního textu v objektu pro třetí číslo při opuštění prázdného objektu
        private void TxtC_LostFocus(object sender, RoutedEventArgs e)
        {
            // Pokud objekt prvního čísla neobsahuje text, nebo nelze konvertovat text na číslo
            if ((this.TxtC.Text == string.Empty) || (int.TryParse(this.TxtC.Text, out _) == false))
            {
                // Vyplnění objektu textem "Zadejte číslo"
                this.TxtC.Text = Constants.ZadCislo;
            }
        }
 
 
        // Metoda bez návratu pro porovnání 3 čísel - vnořené rozhodování
        private void BtnPorovnej1_Click(object sender, RoutedEventArgs e)
        {
            /* Deklarace lokálních proměnných: 'a' ... první celé číslo; 'b' ... druhé celé číslo;
             * 'c' ... třetí celé číslo */
            int a, b, c;
 
            // Konverze textu na číslo a uložení do proměnné 'a'
            int.TryParse(TxtA.Text, out a);
            int.TryParse(TxtB.Text, out b);
            int.TryParse(TxtC.Text, out c);
 
            // Porovnání prvního a druhé čísla
            if (a > b)
                // Vnořené rozhodování
                if (a > c)
                    // Výpis názvu maxima a hodnoty maxima do dialogového okna
                    MessageBox.Show("Největší je a = " + a);
                else
                    if (a == c)
                        MessageBox.Show("Největší je a = c = " + a);
                    else
                        MessageBox.Show("Největší je c = " + c);
            else
                if (a == b)
                    if (b > c)
                        MessageBox.Show("Největší je a = b = " + a);
                    else
                        if (b == c)
                            MessageBox.Show("Největší je a = b = c = " + a);
                        else
                            MessageBox.Show("Největší je c = " + c);
                else
                    if (b > c)
                        MessageBox.Show("Největší je b = " + b);
                    else
                        if (b == c)
                            MessageBox.Show("Největší je b = c = " + b);
                        else
                            MessageBox.Show("Největší je c = " + c);
        }
 
        // Metoda bez návratu pro porovnání 3 čísel - kaskádování (pomocí spojování podmínek)
        private void BtnPorovnej2_Click(object sender, RoutedEventArgs e)
        {
            // Deklarace lokálních proměnných: 'a', 'b', 'c' ... tři celá čísla
            int a, b, c;
 
            // Konverze textu na číslo a uložení do proměnné 'a'
            int.TryParse(TxtA.Text, out a);
            int.TryParse(TxtB.Text, out b);
            int.TryParse(TxtC.Text, out c);
 
            // Spojení dvou podmínek pomocí 'a zároveň'
            if (a > b && a > c)
                // Výpis názvu maxima a hodnoty maxima do dialogového okna
                MessageBox.Show("Největší je a = " + a);
            else 
                if (a > b && a == c)
                    MessageBox.Show("Největší je a = c = " + a);
                else 
                    if (a > b && a < c)
                        MessageBox.Show("Největší je c = " + c);
                    else 
                        if (a == b && a > c)
                            MessageBox.Show("Největší je a = b = " + a);
                        else 
                            if (a == b && a == c)
                                MessageBox.Show("Největší je a = b = c = " + a);
                            else 
                                if (a == b && a < c)
                                    MessageBox.Show("Největší je c = " + c);
                                else 
                                    if (a < b && b > c)
                                        MessageBox.Show("Největší je b = " + b);
                                    else 
                                        if (a < b && b == c)
                                            MessageBox.Show("Největší je b = c = " + b);
                                        else 
                                            if (a < b && b < c)
                                                MessageBox.Show("Největší je c = " + c);
                                            else
                                                MessageBox.Show("Někde je chyba!");
        }
 
        // Metoda bez návratu pro porovnání 3 čísel - volání metody s návratem
        private void BtnPorovnej3_Click(object sender, RoutedEventArgs e)
        {
            // Deklarace lokálních proměnných: 'a', 'b', 'c' ... tři celá čísla
            int a, b, c;
            /* Deklarace: 'max' ... hodnota největšího čísla (maxima); 
             * 's' ... text výsledného výpisu */
            int max;
            string s = "Největší je ";
 
            // Konverze textu na číslo a uložení do proměnné 'a'
            int.TryParse(TxtA.Text, out a);
            int.TryParse(TxtB.Text, out b);
            int.TryParse(TxtC.Text, out c);
 
            // Získání hodnoty maxima - první parametr je maximum z čísel 'a' a 'b'
            max = VetsiRovno(VetsiRovno(a, b), c);
 
            // Pokud je první číslo rovno maximum...
            if (a == max)
                // První číslo je maximem
                s += ("a = ");
            // Pokud je druhé číslo rovno maximum...
            if (b == max)
                // Druhé číslo je maximem
                s += ("b = ");
            // Pokud je třetí číslo rovno maximum...
            if (c == max)
                // Třetí číslo je maximem
                s += ("c = ");
            // Výpis názvu maxima a hodnoty maxima
            MessageBox.Show(s + max);
        }
 
        // Metoda bez návratu s výpisem maxima a zadaných hodnot - využití metody 'VetsiRovno'
        private void BtnPorovnej4_Click(object sender, RoutedEventArgs e)
        {
            // Deklarace lokálních proměnných: 'a', 'b', 'c' ... tři celá čísla
            int a, b, c;
 
            // Konverze textu na číslo a uložení do proměnné 'a'
            int.TryParse(TxtA.Text, out a);
            int.TryParse(TxtB.Text, out b);
            int.TryParse(TxtC.Text, out c);
 
            /* Pokud je návrat metody 'VetsiRovno' z prvních dvou porovnávaných čísel větší 
             * (nebo stejné) číslo než 3. číslo ... */
            if (VetsiRovno(a, b) >= c)
                // Výpis největší hodnoty z prvních dvou porovnávaných čísel
                MessageBox.Show("Největší (nebo rovné) je " + VetsiRovno(a, b) + " z čísel " + a + ", " + b + ", " + c);
            // Jinak... 
            else
                // Výpis největší hodnoty, tj. 3. čísla
                MessageBox.Show("Největší (nebo rovné) je " + c + " z čísel " + a + ", " + b + ", " + c);
        }
 
        // Metoda bez návratu s výpisem maxima a zadaných hodnot - dvojité volání metody 'VetsiRovno'
        private void BtnPorovnej5_Click(object sender, RoutedEventArgs e)
        {
            // Deklarace lokálních proměnných: 'a', 'b', 'c' ... tři celá čísla
            int a, b, c;
 
            // Konverze textu na číslo a uložení do proměnné 'a'
            int.TryParse(TxtA.Text, out a);
            int.TryParse(TxtB.Text, out b);
            int.TryParse(TxtC.Text, out c);
 
            /* Výpis největší hodnoty - využití dvojitého volání metody 'VetsiRovno' - první návrat metody 
             * obsahuje vyšší číslo z prvních dvou předaných čísel -> porovnání návratu metody se třetím 
             * předaným číslem -> získání maxima -> konverze hodnoty na číslice */
            MessageBox.Show(string.Format("Největší (nebo rovné) je {0} z čísel {1}, {2}, {3}", VetsiRovno(VetsiRovno(a, b), c), a, b, c));
        }
 
        //Metoda bez návratu pro zavření formuláře
        private void BtnKonec_Click(object sender, RoutedEventArgs e)
        {
            // Zavření formuláře
            this.Close();
        }
 
        #endregion
    }
}

Kód 2: Výsledný C# kód vytvořeného formuláře a metod jeho prvků

Výstup programu

Na následujícím obrázku vidíme výstup vytvořené aplikace pro porovnání tří zadaných čísel A, B a C na formuláři. Porovnání zadaných celých čísel je prováděno pomocí různých typů metod, které jsou spouštěny pomocí příslušných tlačítek. U metod jsou také použity různé typy formátování výpisu výsledku. Při stisku tlačítek 1. až 3. varianty je určeno maximum, včetně názvu proměnné, ve které největší hodnota uložena - viz Výstup programu 1 - Kód 1 a 2. 

Výstup programu 1 - Kód 1 a 2: Dialogové okno - výpis hodnota maxima včetně názvu proměnné, ve které je uloženo

V metodách pro obsluhu stisknutí tlačítek u 1. a 3. varianty je ve výpisu také implementována možnost rovnosti čísel - viz Výstup programu 2 - Kód 1 a 2.

Výstup programu 2 - Kód 1 a 2: Dialogové okno - výpis stejných nejvyšších hodnot včetně názvu proměnných, ve kterých jsou uloženy

Pokud byl do prvku pro zadání čísla zadán text, který nelze konvertovat na celé číslo, při opuštění tohoto prvku bude do prvku umístěn text "Zadejte číslo" - viz Výstup programu 3 - Kód 1 a 2.

Výstup programu 3 - Kód 1 a 2: Zadání nevalidní celočíselné hodnoty na formuláři

Pokud uživatel stiskne tlačítko pro 4. nebo 5. variantu, již neobdrží název proměnné, ve které je hodnota maxima uložena - viz Výstup programu 4 - Kód 1 a 2. 

Výstup programu 4 - Kód 1 a 2: Dialogové okno - výpis hodnota maxima 

Aplikaci lze ukončit pomocí tlačítka Konec, nebo pomocí zavíracího tlačítka umístěného v pravém rohu aplikace.