5. Výsledný kód

XAML kód

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

<Window x:Class="JednorozmernePoleWPF.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:JednorozmernePoleWPF"
        mc:Ignorable="d"
        Title="Základní práce s vektorem" Height="600" Width="800" MinHeight="500" MinWidth="700">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <!-- Nastavení vektoru -->
        <GroupBox Header="Nastavení vektoru">
            <Grid>
                <Grid.RowDefinitions>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                </Grid.RowDefinitions>
                <Label Content="Vektor" FontSize="18" FontWeight="Bold" HorizontalAlignment="Center" />
                <Grid Grid.Row="1">
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="Auto"/>
                        <ColumnDefinition Width="Auto"/>
                        <ColumnDefinition Width="*"/>
                        <ColumnDefinition Width="Auto"/>
                    </Grid.ColumnDefinitions>
                    <!-- Rozměr vektoru -->
                    <GroupBox Header="Rozměr vektoru">
                        <WrapPanel>
                            <Label Content="Počet prvků:" VerticalAlignment="Center"/>
                            <TextBox Name="TxtPocetPrvku" Grid.Column="1" Width="100" Margin="5" Padding="5" 
                                     LostFocus="TxtPocetPrvku_LostFocus"/>
                        </WrapPanel>
                    </GroupBox>
                    <!-- Hodnoty - meze -->
                    <GroupBox Header="Hodnoty - meze" Grid.Column="1">
                        <Grid>
                            <Grid.RowDefinitions>
                                <RowDefinition Height="Auto"/>
                                <RowDefinition Height="Auto"/>
                            </Grid.RowDefinitions>
                            <Grid.ColumnDefinitions>
                                <ColumnDefinition Width="Auto"/>
                                <ColumnDefinition Width="Auto"/>
                            </Grid.ColumnDefinitions>
                            <Label Content="Minimum:" VerticalAlignment="Center"/>
                            <TextBox Name="TxtMinHodnota" Grid.Column="1" Width="100" Margin="5" Padding="5" 
                                     LostFocus="TxtMinHodnota_LostFocus"/>
                            <Label Content="Maximum:" Grid.Row="1" VerticalAlignment="Center"/>
                            <TextBox Name="TxtMaxHodnota" Grid.Row="1" Grid.Column="1" Width="100" Margin="5" Padding="5"
                                     LostFocus="TxtMaxHodnota_LostFocus"/>
                        </Grid>
                    </GroupBox>
                    <!-- Prvek ve vektoru -->
                    <GroupBox Header="Prvek ve vektoru" Grid.Column="3">
                        <Grid  Margin="5">
                            <Grid.RowDefinitions>
                                <RowDefinition Height="Auto"/>
                                <RowDefinition Height="Auto"/>
                            </Grid.RowDefinitions>
                            <Grid.ColumnDefinitions>
                                <ColumnDefinition Width="Auto"/>
                                <ColumnDefinition Width="Auto"/>
                            </Grid.ColumnDefinitions>
                            <Label Content="Index:" Grid.Column="0"/>
                            <TextBox Name="TxtPrvekIndex" Grid.Column="1" Width="100" LostFocus="TxtPrvekIndex_LostFocus"/>
                            <Label Content="Hodnota:" Grid.Row="1" Grid.Column="0"/>
                            <TextBox Name="TxtHodnota" Grid.Row="1" Grid.Column="1" Width="100" LostFocus="TxtHodnota_LostFocus"/>
                        </Grid>
                    </GroupBox>
                </Grid>
            </Grid>
        </GroupBox>
        <!-- Zobrazení vektoru -->
        <GroupBox Header="Zobrazení vektoru" Grid.Row="1">
            <Grid>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="*"/>
                </Grid.ColumnDefinitions>
                <!-- Vektor -->
                <GroupBox Header="Mřížka" Margin="5" MinHeight="100">
                    <ListView Name="LstVektor" ScrollViewer.VerticalScrollBarVisibility="Auto"/>
                </GroupBox>
                <!-- Výsledek -->
                <GroupBox Header="Jako text (nebo výpis výsledku)" Grid.Column="1" Margin="5">
                    <TextBox Name="TxtVysledek" Margin="5" ScrollViewer.HorizontalScrollBarVisibility="Visible" 
                             ScrollViewer.VerticalScrollBarVisibility="Visible" IsReadOnly="True" Background="AliceBlue"/>
                </GroupBox>
            </Grid>
        </GroupBox>
        <!-- Tlačítka - sekce: Plnit, Výstup, Výpočet -->
        <StackPanel Grid.Row="4">
            <Grid>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="*"/>
                </Grid.ColumnDefinitions>
                <!-- Plnit -->
                <StackPanel >
                    <Label Content="Plnit:" FontWeight="Bold" FontSize="16" HorizontalAlignment="Center"/>
                    <Button Name="BtnNahodne" Content="Náhodně" Margin="5" Padding="10,5" Click="BtnNahodne_Click"/>
                    <Button Name="BtnJednotlive" Content="Jednotlivě" Margin="5" Padding="10,5" Click="BtnJednotlive_Click"/>
                    <Button Name="BtnNulovat" Content="Nulovat" Margin="5" Padding="10,5" Click="BtnNulovat_Click"/>
                </StackPanel>
                <!-- Výstup -->
                <StackPanel Grid.Column="1">
                    <Label Content="Výstup:" FontWeight="Bold" FontSize="16" HorizontalAlignment="Center"/>
                    <Button Name="BtnVektorJakoText" Content="Vektor jako text"  Margin="5" Padding="10,5" 
                            Click="BtnVektorJakoText_Click"/>
                    <Button Name="BtnDoMrizky" Content="Do mřížky" Margin="5" Padding="10,5" Click="BtnDoMrizky_Click"/>
                </StackPanel>
                <!-- Výpočet -->
                <StackPanel Grid.Column="2">
                    <Label Content="Výpočet:" FontWeight="Bold" FontSize="16" HorizontalAlignment="Center"/>
                    <Button Name="BtnMinimum" Content="Minimum"  Margin="5" Padding="10,5" Click="BtnMinimum_Click"/>
                    <Button Name="BtnMaximum" Content="Maximum" Margin="5" Padding="10,5" Click="BtnMaximum_Click"/>
                    <Button Name="BtnPrumer" Content="Průměr" Margin="5" Padding="10,5" Click="BtnPrumer_Click"/>
                    <Button Name="BtnSeradit" Content="Seřadit" Margin="5" Padding="10,5" Click="BtnSeradit_Click"/>
                </StackPanel>
            </Grid>
            <!-- Konec -->
            <WrapPanel HorizontalAlignment="Right">
                <Button Name="BtnKonec" Content="Konec" Margin="5" Width="100" 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 JednorozmernePoleWPF
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        #region Datové složky třídy (globální proměnné)
        // Specifikace konstanty a inicializace
        const int Max = 10;
        // Aktuální rozměr pole - počet prvků
        private int pocetPrvku;
        // Přípustná minimální hodnota (dolní mez) prvku - inicializace
        private int minHodnota = 1;
        // Přípustná maximální hodnota (horní mez) prvku - inicializace
        private int maxHodnota = 100;
 
        // Deklarace pole
        private int[] pole;
        #endregion Datové složky třídy
 
 
        public MainWindow()
        {
            InitializeComponent();
 
            /* Přiřazení maximálního rozměru vektoru do datové složky určující
             * počet prvků vektoru */
            this.pocetPrvku = Max;
 
            // Vytvoření instance (objektu) pole s definovanou délkou
            this.pole = new int[this.pocetPrvku];
 
            /* Přiřazení počtu prvků vektoru do objektu na formuláři určujícího
             * velikost vektoru*/
            this.TxtPocetPrvku.Text = this.pocetPrvku.ToString();
 
            /* Přiřazení přípustné minimální hodnoty prvku ve vektoru do objektu 
             * na formuláři určujícího mezní hodnotu */
            this.TxtMinHodnota.Text = this.minHodnota.ToString();
 
            /* přiřazení přípustné maximální hodnoty prvku ve vektoru do objektu (pole) 
             * na formuláři určujícího mezní hodnotu */
            this.TxtMaxHodnota.Text = this.maxHodnota.ToString();
        }
 
        #region Pomocné metody       
        #region Plnění pole
        /// <summary>
        /// Metoda pro plnění prvků vektoru náhodnými čísly
        /// </summary>
        /// <param name="n"> počet prvků pole </param>
        /// <param name="minh"> minimální celočíselná hodnota prvku </param>
        /// <param name="maxh"> maximální celočíselná hodnota prvku </param>
        /// <param name="pole"> jednorozměrné pole </param>
        private void NahodnePole(int n, int minh, int maxh, int[] pole)
        {
            // Vytvoření instance generátoru náhodného čísla
            Random rnd = new Random();
 
            // Cyklus s pevným krokem - pro procházení prvků vektoru
            for (int i = 0; i < n; i++)
            {
                // Přiřazení náhodného čísla v rozmezí intervalu u prvku na pozici [i]
                pole[i] = rnd.Next(minh, maxh + 1);
            }
        }
 
        /// <summary>
        /// Metoda pro nulování hodnot ve vektoru
        /// </summary>
        /// <param name="n"> počet prvků vektoru (předání parametru hodnotou - pouze vstup) </param>
        /// <param name="pole"> jednorozměrné pole </param>
        private void NulovatPole(int n, int[] pole)
        {
            // Cyklus s pevným krokem - pro procházení prvků
            for (int i = 0; i < n; i++)
            {
                // Přiřazení nuly prvku na pozici [i]
                pole[i] = 0;
            }
        }
        #endregion Plnění pole
 
        #region Zobrazení pole
        /// <summary>
        /// Prvky vektoru jsou převedeny na text a odděleny čárkou
        /// </summary>
        /// <param name="n"> počet prvků vektoru </param>
        /// <param name="pole"> vektor (předání parametru hodnotou - vstup) </param>
        /// <returns></returns>     
        private string PoleJakoText(int n, int[] pole)
        {
            /* Lokální proměnná: výstup - výsledek převodu na text - inicializace 
             * hodnotou počátečního prvku v požadovaném formátu */
            string vystup = "Vektor:" + string.Format(" {0:D3}", pole[0]);
 
            // Procházení prvků vektoru - od 2. do posledního prvku 
            for (int i = 1; i < n; i++)
            {
                // Převod hodnoty prvku na text včetně připojení čárky
                vystup += string.Format(", {0:D3}", pole[i]);
            }
            // Návrat výsledného řetězce
            return vystup;
        }
 
        /// <summary>
        /// Zobrazení vektoru na formuláři jako text v objektu TextBox
        /// </summary>
        /// <param name="n"></param>
        /// <param name="pole"></param>
        private void ZobrazitPoleJakoText(int n, int[] pole)
        {
            // Výpis vektoru v objektu typu TextBox na formuláři
            this.TxtVysledek.Text = this.PoleJakoText(n, pole);
        }
 
        /// <summary>
        /// Zobrazení prvků vektoru na formuláři v objektu ListView
        /// </summary>
        private void ZobrazitPoleVListView(int[] pole)
        {
            // Vymazání předchozí textu - přiřazení prázdné hodnoty zdroji objektu
            this.LstVektor.ItemsSource = null;
            // Zobrazení vektoru v objektu na formuláři
            this.LstVektor.ItemsSource = pole;
        }
        #endregion Zobrazení pole
 
        #region Operace s polem
        /// <summary>
        /// Metoda pro hledání nejmenšího prvku ve vektoru
        /// </summary>
        /// <param name="n">  počet prvků vektoru </param>
        /// <param name="pole"> vektor </param>
        /// <param name="indPrvku"> index prvku minima </param>
        /// <returns> celočíselná hodnota minima </returns>
        private int MinimumVPoli(int n, int[] pole, out int indPrvku)
        {
            // Lokální proměnné: i - index prvku; minimum - hodnota minima
            int minimum;
            // Přiřazení hodnoty počátečního prvku vektoru do minima
            minimum = pole[0];
            // Přiřazení hodnoty 0 do indexu prvku minima (kdyby byl počáteční prvek minimem)
            indPrvku = 0;
            // Cyklus s pevným krokem - pro procházení prvků
            for (int i = 1; i < n; i++)
            {
                /* Pokud je nalezen prvek ve vektoru, jehož hodnota je menší 
                 * než minimum... */
                if (pole[i] < minimum)
                {
                    // Uložení hodnoty nalezeného prvku do minima
                    minimum = pole[i];
                    // Přiřazení indexu aktuálního prvku do indexu minima
                    indPrvku = i;
                }
            }
            // Přiřazení hodnoty nalezeného minima do výstupu metody
            return minimum;
        }
 
        /// <summary>
        /// Metoda pro hledání největšího prvku vektoru
        /// </summary>
        /// <param name="n">  počet prvků vektoru </param>
        /// <param name="pole"> vektor </param>
        /// <param name="indPrvku"> index prvku maxima </param>
        /// <returns> celočíselná hodnota maxima </returns>
        private int MaximumVPoli(int n, int[] pole, out int indPrvku)
        {
            // Lokální proměnné: i - index prvku; maximum - hodnota maxima
            int maximum;
            // Přiřazení minimální možné hodnoty prvku vektoru do maxima
            maximum = int.MinValue;
            /* Přiřazení hodnoty 0 do indexu prvku maxima (nutné provést, jinak
             * kompilátor ohlásí chybu, že není přiřazena hodnota výstupnímu
             * prvku 'indPrvku' */
            indPrvku = 0;
            // Cyklus s pevným krokem - pro procházení prvků
            for (int i = 0; i < n; i++)
            {
                /* Pokud je nalezen prvek ve vektoru, jehož hodnota je větší 
                 * než maximum, pak... */
                if (pole[i] > maximum)
                {
                    // Uložení hodnoty nalezeného prvku do maxima
                    maximum = pole[i];
                    // Přiřazení indexu aktuálního prvku do indexu maxima
                    indPrvku = i;
                }
            }
            // Přiřazení hodnoty nalezeného maxima do výstupu metody
            return maximum;
        }
 
        /// <summary>
        /// Metoda pro výpočet aritmetického průměru prvků ve vektoru
        /// </summary>
        /// <param name="n"> počet prvků vektoru </param>
        /// <param name="pole"> vektor </param>
        /// <returns> hodnota aritmetického průměru (reálné číslo) </returns>
        private double PrumerPole(int n, int[] pole)
        {
            // Lokální proměnné: i - index; suma - suma prvků vektoru 
            int suma;
            // Nastavení počáteční hodnoty u sumy
            suma = 0;
            // Cyklus s pevným krokem - pro procházení prvků
            for (int i = 0; i < n; i++)
            {
                // Přičtení dalšího prvku vektoru do sumy
                suma += pole[i];
            }
            /* Výpočet průměru (suma/počet prvků) a přiřazení hodnoty do výstupu metody
             * nutné přetypovat sumu na double, aby nedošlo k celočíselnému dělení */
            return (double)suma / (n);
        }
 
        /// <summary>
        /// Metoda pro vzestupné třídění prvků ve vektoru
        /// </summary>
        /// <param name="n"> počet prvků vektoru </param>
        /// <param name="pole"> výstupní seřazený vektor </param>
        private void SeraditPole(int n, int[] pole)
        {
            /* Lokální proměnné: i - index ;  pom - pomocná proměnná pro prohození 
             * dvou prvků vektoru; b - booleanovská proměnná - informace, zda
             * došlo k prohození dvou sousedních prvků */
            int pom;
            bool b;
 
            // Opakuj tak dlouho, dokud bude docházet k prohození prvků vektoru
            do
            {
                // Nedošlo k prohození prvků vektoru
                b = false;
                // Cyklus s pevným krokem - pro procházení od počátečního do předposledního prvku
                for (int i = 0; i < n - 1; i++)
                {
                    /* Pokud je hodnota sousedícího prvku větší než hodnota aktuálně
                     * testovaného prvku, pak... */
                    if (pole[i] > pole[i + 1])
                    {
                        // Ulož hodnotu aktuálního prvku do pomocné proměnné
                        pom = pole[i];
                        // Ulož hodnotu sousedícího prvku do aktuálního prvku
                        pole[i] = pole[i + 1];
                        // Ulož hodnotu z pomocné proměnné do sousedícího prvku
                        pole[i + 1] = pom;
                        // Došlo k prohození prvků
                        b = true;
                    }
                }
            }
            // Podmínka cyklu
            while (b); 
        }
        #endregion Operace s polem
        #endregion Pomocné metody
 
 
        #region Události
        #region Nastavení atributů pole
        /// <summary>
        /// Validace rozměru vektoru
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void TxtPocetPrvku_LostFocus(object sender, RoutedEventArgs e)
        {
            // Lokální proměnná pro uložení nového počtu prvků vektoru
            int novaHodnota;
            /* Přiřazení počtu prvků z objektu na formuláři do lokální proměnné
             * určující počet prvků vektoru */
            int.TryParse(this.TxtPocetPrvku.Text, out novaHodnota);
            /* Pokud počet prvků je větší než maximální rozměr vektoru, nebo počet
             * prvků vektoru je menší než 1, pak... */
            if ((novaHodnota > Max) || (novaHodnota < 1))
            {
                /* Zobrazení dialogového okna s textem "Chyba velikosti vektoru" a hodnoty 
                 * max. rozměru vektoru */
                MessageBox.Show(String.Format("Chyba velikosti vektoru, nastavení na max. rozměr: {0}", Max));
                /* Přiřazení maximálního rozměru vektoru do lokální proměnné určující
                 * počet prvků vektoru */
                novaHodnota = Max;
                /* Přiřazení maximálního rozměru vektoru do objektu na formuláři
                 * určující počet prvků vektoru */
                this.TxtPocetPrvku.Text = Max.ToString();
            }
 
            // Pokud nový rozměr vektoru není stejný jako stávající počet prvků vektoru, pak...
            if (novaHodnota != this.pocetPrvku)
            {
                // Uložení nového rozměru pole do datové složky třídy
                this.pocetPrvku = novaHodnota;
                // Vytvoření nové instance pole s novým rozměrem
                this.pole = new int[this.pocetPrvku];
                // Zavolání metody pro zobrazení vektoru do objektu ListView na formuláři
                this.ZobrazitPoleVListView(this.pole);
                // Zavolání metody pro zobrazení vektoru do objektu TextBox na formuláři
                this.ZobrazitPoleJakoText(novaHodnota, this.pole);
            }
        }
 
        /// <summary>
        /// Validace dolní meze intervalu přípustných hodnot prvků vektoru 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void TxtMinHodnota_LostFocus(object sender, RoutedEventArgs e)
        {
            /* Přiřazení dolní meze z objektu na formuláři do datové složky třídy určující 
             * dolní mez intervalu přípustných hodnot */
            int.TryParse(this.TxtMinHodnota.Text, out this.minHodnota);
            // Pokud nová dolní mez je větší než stávající horní mez, pak...
            if (this.minHodnota > this.maxHodnota)
            {
                // Zobrazení dialogového okna s chybou a nastavení dolní meze na horní mez
                MessageBox.Show(String.Format("Chyba hodnoty dolní meze - dolní mez nastavena na horní mez: {0}", this.maxHodnota));
                // Dolní mez je nastavena na hodnotu horní meze
                this.minHodnota = this.maxHodnota;
                // Zobrazení hodnoty dolní meze na formuláři 
                this.TxtMinHodnota.Text = minHodnota.ToString();
            }
        }
 
        /// <summary>
        /// Validace horní meze intervalu přípustných hodnot prvků vektoru 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void TxtMaxHodnota_LostFocus(object sender, RoutedEventArgs e)
        {
            /* Přiřazení horní meze z objektu na formuláři do datové složky třídy určující 
             * horní mez intervalu hodnot, kterých mohou nabývat prvky ve vektoru */
            int.TryParse(this.TxtMaxHodnota.Text, out this.maxHodnota);
            // Pokud nová horní mez je menší než stávající dolní mez, pak...
            if (this.maxHodnota < this.minHodnota)
            {
                // Zobrazení dialogového okna s chybou a nastavení horní meze na dolní mez
                MessageBox.Show(String.Format("Chyba hodnoty horní meze - horní mez nastavena na dolní mez: {0}", this.minHodnota));
                // Horní mez je nastavena na hodnotu dolní meze
                this.maxHodnota = this.minHodnota;
                // Zobrazení hodnoty horní meze na formuláři
                this.TxtMaxHodnota.Text = maxHodnota.ToString();
            }
        }
 
        /// <summary>
        /// Validace indexu prvku vektoru při ručním plnění
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void TxtPrvekIndex_LostFocus(object sender, RoutedEventArgs e)
        {
            // Lokální proměnná: index - index prvku
            int index;
            // Uložení indexu prvku do lokální proměnné (konverze textu na celé číslo)
            int.TryParse(this.TxtPrvekIndex.Text, out index);
            /* Pokud index prvku je větší než počet prvků vektoru - 1, nebo index prvku je
             * menší než 0, pak... */
            if ((index > this.pocetPrvku-1) || (index < 0))
            {
                // Zobrazení dialogového okna s chybou a nastavení indexu na rozměr vektoru - 1
                MessageBox.Show(String.Format("Chybný index prvku. Index nastaven na horní mez: {0}", this.pocetPrvku-1));
                /* Přiřazení horní meze indexu do objektu na formuláři určujícího index prvku vektoru */
                this.TxtPrvekIndex.Text = String.Format("{0}", this.pocetPrvku-1);
            }
        }
 
        /// <summary>
        /// Validace hodnoty prvku vektoru při ručním plnění
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void TxtHodnota_LostFocus(object sender, RoutedEventArgs e)
        {
            // Lokální proměnná: t - hodnota prvku
            int t;
            // Uložení hodnoty prvku do lokální proměnné (konverze textu na celé číslo)
            int.TryParse(this.TxtHodnota.Text, out t);
            /* Pokud hodnota prvku je větší než horní mez, nebo hodnota prvku je
             * menší než dolní mez intervalu hodnot ve vektoru, pak... */
            if ((t > this.maxHodnota) || (t < this.minHodnota))
            {
                // Zobrazení dialogového okna s textem chyby a hodnotami mezí
                MessageBox.Show(String.Format("Hodnota prvku není v intervalu: {0} až {1}", 
                    this.minHodnota, this.maxHodnota));                
                // Vymázání obsahu objektu na formuláři s hodnotou prvku 
                this.TxtHodnota.Clear();
            }
        }
        #endregion Nastavení atributů pole
 
        #region Plnění pole
        /// <summary>
        /// Volání metody pro plnění vektoru náhodnými čísly
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnNahodne_Click(object sender, RoutedEventArgs e)
        {
            // Zavolání metody bez návratu pro plnění vektoru náhodnými čísly
            this.NahodnePole(this.pocetPrvku, this.minHodnota, this.maxHodnota, this.pole);
        }
 
        /// <summary>
        /// Metoda pro ruční plnění jednotlivých prvků vektoru
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnJednotlive_Click(object sender, RoutedEventArgs e)
        {
            /* Přiřazení indexu prvku z objektu na formuláři (konverze textu na celé 
             * číslo) do lokální proměnné */
            int.TryParse(this.TxtPrvekIndex.Text, out int index);
 
            // Přiřazení hodnoty prvku z objektu na formuláři do lokální proměnné
            int.TryParse(this.TxtHodnota.Text, out int hodnota);
 
            /* Přiřazení dolní meze intervalu hodnoty prvku z objektu na formuláři
             * do lokální proměnné */
            int.TryParse(this.TxtMinHodnota.Text, out int minh);
            
            /* Přiřazení horní meze intervalu hodnoty prvku z objektu na formuláři
             * do lokální proměnné */
            int.TryParse(this.TxtMaxHodnota.Text, out int maxh);
 
            /* Pokud index prvku je mimo interval hodnot, tj. je menší než 0, 
             * nebo je větší než rozměr vektoru - 1, pak... */
            if ((index < 0) || (index > this.pocetPrvku - 1))
            {
                // Zobrazení varovného dialogového okna
                MessageBox.Show("Zadaná hodnota indexu prvku je mimo meze", "Chyba v zadání",
                    MessageBoxButton.OK, MessageBoxImage.Error);
            }
            /* Pokud hodnota prvku je větší než horní mez intervalu povolené hodnoty prvku, nebo
             * je menší než dolní mez intervalu hodnot prvku, pak... */
            else if ((hodnota > maxh) || (hodnota < minh))
            {
                // Zobrazení varovného dialogového okna
                MessageBox.Show("Zadaná hodnota prvku je mimo meze", "Chyba v zadání",
                    MessageBoxButton.OK, MessageBoxImage.Error);
            }
            // Jinak...
            else
            {
                /* Přiřazení hodnoty z lokální proměnné do prvku vektoru 
                 * na pozici [index] */
                this.pole[index] = hodnota;
                // Zavolání metody pro zobrazení vektoru v objektu (typu TextBox) na formuláři
                this.ZobrazitPoleJakoText(this.pocetPrvku, this.pole);
                // Zavolání metody pro zobrazení vektoru do objektu (typu ListView) na formuláři
                this.ZobrazitPoleVListView(this.pole);
                // Pokud index prvku je menší než celkový počet prvků - 1, pak...
                if (index < this.pocetPrvku - 1)
                {
                    // Zvýšení indexu prvku o 1
                    index++;
                    // Přiřazení indexu prvku do objektu na formuláři
                    this.TxtPrvekIndex.Text = index.ToString();
                }
            }
        }
 
        /// <summary>
        /// Metoda pro zavolání metody pro nulování vektoru
        /// </summary>
        private void BtnNulovat_Click(object sender, RoutedEventArgs e)
        {
            //Zavolání metody pro nulování vektoru
            this.NulovatPole(this.pocetPrvku, this.pole);
        }
        #endregion Plnění pole
 
        #region Zobrazení pole
        /// <summary>
        /// Volání metody pro zobrazení vektoru jako text v objektu typu TextBox na formuláři
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnVektorJakoText_Click(object sender, RoutedEventArgs e)
        {
            // Zavolání metody pro zobrazení vektoru jako text v objektu na formuláři
            this.ZobrazitPoleJakoText(this.pocetPrvku, this.pole);
        }
 
        /// <summary>
        /// Volání metody pro zobrazení prvků vektoru v objektu typu ListView na formuláři
        /// ListView na formuláři
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnDoMrizky_Click(object sender, RoutedEventArgs e)
        {
            // Zavolání metody pro zobrazení prvků vektoru do mřížky na formuláři
            this.ZobrazitPoleVListView(this.pole);
        }
        #endregion Zobrazení pole
 
        #region Operace s polem
        /// <summary>
        /// Volání metody pro určení minima ve vektoru
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnMinimum_Click(object sender, RoutedEventArgs e)
        {
            /* Lokální proměnné: indexMinima - index prvku minima ve vektoru;
             * minimum - hodnota minima ve vektoru */
            int minimum;
            /* Přiřazení výstupu metody pro určení minima do lokální proměnné a výstupní 
             * parametr určující index minima */
            minimum = this.MinimumVPoli(this.pocetPrvku, this.pole, out int indexMinima);
            /* Zobrazení textu spolu s hodnotou nejmenšího prvku a indexu prvku minima 
             * do objektu (TextBox) na formuláři */
            this.TxtVysledek.Text = string.Format("Minimum = {0} (index prvku = {1})", minimum, indexMinima);
        }
 
        /// <summary>
        /// Volání metody pro určení maxima ve vektoru
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnMaximum_Click(object sender, RoutedEventArgs e)
        {
            /* Lokální proměnné: indexMaxima - index prvku maxima ve vektoru;
             * maximum - hodnota maxima ve vektoru */
            int maximum;
            /* Přiřazení výstupu metody pro určení maxima do lokální proměnné a výstupní 
             * parametr určující pořadí maxima */
            maximum = this.MaximumVPoli(this.pocetPrvku, this.pole, out int indexMaxima);
            /* Zobrazení textu spolu s hodnotou nejmenšího prvku a indexem prvku maxima 
             * do objektu (TextBox) na formuláři */
            this.TxtVysledek.Text = string.Format("Maximum = {0} (index prvku = {1})", maximum, indexMaxima);
        }
 
        /// <summary>
        /// Volání metody pro výpočet aritmetického průměru z prvků pole
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnPrumer_Click(object sender, RoutedEventArgs e)
        {
            // Lokální proměnná: prumer - průměr prvků v poli
            double prumer;
            // Přiřazení výstupu metody pro výpočet průměru z prvků pole do lokální proměnné
            prumer = this.PrumerPole(this.pocetPrvku, this.pole);
            /* Zobrazení textu 'Průměr = ' spolu s vypočteným průměrem (konverze reálného čísla 
             * na text, zobrazného na 2 desetinná místa) do objektu (TextBox) na formuláři */
            this.TxtVysledek.Text = string.Format("Průměr = {0:N2}", prumer);
        }
 
        /// <summary>
        /// Volání metody pro vzestupné třídění prvků vektoru
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnSeradit_Click(object sender, RoutedEventArgs e)
        {
            // Zavolání metody pro vzestupné třídění prvků v poli
            this.SeraditPole(this.pocetPrvku, this.pole);
            // Zavolání metody pro zobrazení vektoru do objektu (TextBox) na formuláři
            this.ZobrazitPoleJakoText(this.pocetPrvku, this.pole);
            // Zavolání metody pro zobrazení vektoru v objektu (ListView) na formuláři
            this.ZobrazitPoleVListView(this.pole);
        }
        #endregion Operace s polem
 
        /// <summary>
        /// Metoda pro zavření formuláře
        /// </summary>
        private void BtnKonec_Click(object sender, RoutedEventArgs e)
        {
            // Zavření formuláře
            this.Close();
        }
        #endregion Události
    }
}

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