Black Friday Black Friday
Black Friday výprodej! Až 80 % extra bodů zdarma! Více informací zde

Lekce 2 - První objektová aplikace v C# - Hello object world

C# .NET Objektově orientované programování První objektová aplikace v C# - Hello object world American English version English version

Unicorn College ONEbit hosting Tento obsah je dostupný zdarma v rámci projektu IT lidem. Vydávání, hosting a aktualizace umožňují jeho sponzoři.

Minulá lekce, Úvod do objektově orientovaného programování v C#, nás uvedla do objektově orientovaného programování. Již víme, že objekty mají atributy a metody. Také víme, že k vytvoření objektu vytvoříme nejprve třídu. Ta je vzorem, podle kterého následně tvoříme její instance.

Na začátku kurzu se základními konstrukcemi jazyka C# jsme si vytvořili program Hello world. Udělejme si nyní podobný program jako úvod do objektově orientovaného programování. Naprogramujme si Hello object world!

Založme si ve Visual Studiu novou konzolovou aplikaci tak, jak jsme to dělali doposud. V Solution Exploreru napravo klikneme pravým tlačítkem myši na náš projekt a vybereme Add -> Class. Jde to i klávesouvou zkratkou Shift + Alt + C.

Přidání nové třídy class k C# projektu ve Visual Studio

Class pojmenujeme Zdravic.cs a potvrdíme. Název třídy píšeme vždy velbloudí notací bez mezer a na rozdíl od proměnných má každé slovo velké první písmeno, tedy i první. Název je samozřejmě také bez diakritiky, tu v programu používáme max. uvnitř textových řetězců, nikoli v identifikátorech.

Vytvoření nové třídy v C# ve Visual Studio

Podle této třídy později vytvoříme objekt zdravic, který nás bude umět pozdravit. Vidíme, že se na program již díváme úplně jinak, za každou akci je zodpovědný nějaký objekt, nestačí pouze něco "nabušit" do Main(). V našem případě vám to může přijít zbytečné, u složitějších aplikací si to budete pochvalovat :)

V našem Solution Exploreru přibude další soubor .cs a VS nám ho otevře. K původnímu Program.cs s metodou Main() se můžeme vrátit pomocí záložky nebo přes Solution Explorer.

Podívejme se, co nám VS vygenerovalo a kód si popišme. Následně si do třídy přidáme vlastní metodu pro pozdravení.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace HelloObjects
{
    class Zdravic
    {

    }
}

Klíčové slovo namespace nám označuje tzv. jmenný prostor. Stejně jako se metody sdružují do tříd, tak se třídy sdružují do jmenných prostorů. Pokud chceme, aby byla naše třída viditelná i v Program.cs, kde máme metodu Main(), musíme ji mít ve stejném jmenném prostoru. To zde platí, VS samo novou třídu obalí tím samým jmenným prostorem, vy místo HelloObjects budete mít název své aplikace, pokud jste ji nepojmenovali, bude tam ConsoleApplication1.

Příkaz using nám umožňuje zviditelnit třídy jiných jmenných prostorů, abychom s nimi mohli pracovat. V základu nám VS připraví System, poté generické kolekce, Linq a Text. Pro nás bude nejdůležitější namespace System, protože právě ten obsahuje třídu Console. Další využijeme až později a poté budeme dokonce potřebovat nějaké dodat, zejména pro práci s textovými soubory.

V namespace je tedy umístěná samotná třída, která se deklaruje klíčovým slovem class. Třída se jmenuje Zdravic a je prázdná.

Všimněte si, že kód je téměř stejný, jako ten v Program.cs, již tedy rozumíme tomu, co jsme předtím ignorovali. Náš konzolový program byla vlastně třída umístěná ve jmenném prostoru, která obsahovala jednu metodu Main(). Vidíme, že v C# se v podstatě neobjektově programovat ani nedá, což je jen dobře :)

Nyní si do třídy Zdravic přidáme metodu Pozdrav(), bude veřejně viditelná a nebude mít žádnou návratovou hodnotu ani parametry.

Deklarace metody v C# je tedy následující:

[modifikátor přístupu] [návratový typ] [JmenoMetody]([parametry])

Před metodou bude tzv. modifikátor přístupu, v našem případě public (veřejná). Kdybychom modifikátor vynechali, C# by ji chápal jako private (neveřejná). Metoda nebude vracet žádnou hodnotu, toho docílíme klíčovým slovem void. Dále bude následovat samotný název metody, metody píšeme stejně jako třídy velbloudí notací s velkým poč. písmenem. První písmeno názvu je však na rozdíl od proměnných velké! Závorka s parametry je povinná, my ji necháme prázdnou, protože metoda žádné parametry mít nebude. Do těla metody zapíšeme kód pro výpis na konzoli.

Naše třída bude nyní vypadat takto:

class Zdravic
{

    public void Pozdrav()
    {
        Console.WriteLine("Hello object world!");
    }

}

Zde jsme prozatím skončili, přejdeme do Program.cs.

Nyní si v těle metody Main() vytvoříme instanci třídy Zdravic. Bude to tedy ten objekt zdravic, se kterým budeme pracovat. Objekty se ukládají do proměnných, název třídy slouží jako datový typ. Instance má zpravidla název třídy, jen má první písmeno malé. Deklarujme si proměnnou a následně v ní založme novou instanci třídy Zdravic:

Zdravic zdravic;
zdravic = new Zdravic();

První řádek říká: "Chci proměnnou zdravic, ve které bude instance třídy Zdravic". S proměnnými jsme vlastně již takto pracovali.

Na druhém řádku je klíčové slovo new, které nám založí novou instanci třídy Zdravic. Tuto instanci přiřadíme do naší proměnné.

Při vytvoření nové instance se zavolá tzv. konstruktor. To je speciální metoda na třídě, proto při vytvoření instance píšeme ty prázdné závorky, jelikož voláme tuto "vytvářecí" metodu. Konstruktor zpravidla obsahuje nějakou inicializaci vnitřního stavu instance (např. dosadí výchozí hodnoty do proměnných). My jsme v kódu žádný konstruktor nedeklarovali, C# si proto vytvořil tzv. implicitní bezparametrický konstruktor. Vytvoření instance objektu je tedy podobné volání metody. Celý zápis můžeme samozřejmě zkrátit na:

Zdravic zdravic = new Zdravic();

Jelikož v proměnné nyní máme opravdu instanci třídy Zdravic, můžeme instanci nechat pozdravit. Zavoláme na ni metodu Pozdrav() a to jako zdravic.Pozdrav(). K aplikaci přidáme ještě Console.ReadKey(). Kód metody Main() bude tedy nyní vypadat následovně:

            Zdravic zdravic = new Zdravic();
            zdravic.Pozdrav();
            Console.ReadKey();
    class Zdravic
    {

        public void Pozdrav()
        {
            Console.WriteLine("Hello object world!");
        }

    }

Program spustíme.

Vaše první objektová aplikace
Hello object world!

Máme tedy svou první objektovou aplikaci!

Dejme nyní naší metodě Pozdrav() parametr jmeno, aby dokázala pozdravit konkrétního uživatele:

public void Pozdrav(string jmeno)
{
    Console.WriteLine("Ahoj uživateli {0}", jmeno);
}

Vidíme, že syntaxe parametru metody je stejná, jako syntaxe proměnné. Kdybychom chtěli parametrů více, oddělujeme je čárkou. Upravíme nyní naši metodu Main():

            Zdravic zdravic = new Zdravic();
            zdravic.Pozdrav("Karel");
            zdravic.Pozdrav("Petr");
            Console.ReadKey();
    class Zdravic
    {

        public void Pozdrav(string jmeno)
        {
            Console.WriteLine("Ahoj uživateli {0}", jmeno);
        }

    }

Náš kód je nyní v metodě a my ho můžeme jednoduše pomocí parametrů volat znovu s různými parametry. Nemusíme 2x opisovat "Ahoj uživateli...". Kód budeme odteď dělit logicky do metod.

Konzolová aplikace
Ahoj uživateli Karel
Ahoj uživateli Petr

Třídě přidáme nějaký atribut, nabízí se text, kde bude uložen text pozdravu. Atributy se definují stejně, jako proměnné. Jako u metod platí, že před ně píšeme modifikátor přístupu, bez něj je C# bere jako private. Upravme naši třídu:

class Zdravic
{
    public string text;

    public void Pozdrav(string jmeno)
    {
        Console.WriteLine("{0} {1}", text, jmeno);
    }

}

Text nyní musíme pochopitelně nastavit vytvořené instanci v Program.cs:

            Zdravic zdravic = new Zdravic();
            zdravic.text = "Ahoj uživateli";
            zdravic.Pozdrav("Karel");
            zdravic.Pozdrav("Petr");
            zdravic.text = "Vítám tě tu programátore";
            zdravic.Pozdrav("Richard");
            Console.ReadKey();
    class Zdravic
    {
        public string text;

        public void Pozdrav(string jmeno)
        {
            Console.WriteLine("{0} {1}", text, jmeno);
        }

    }

Konzolová aplikace
Ahoj uživateli Karel
Ahoj uživateli Petr
Vítám tě tu programátore Richard

Vzhledem k objektovému návrhu není nejvhodnější, aby si každý objekt ovlivňoval vstup a výstup, jak se mu zachce. Pochopitelně narážím na naše vypisování do konzole. Každý objekt by měl mít určitou kompetenci a tu by neměl překračovat. Pověřme náš objekt pouze sestavením pozdravu a jeho výpis si zpracujeme již mimo, v našem případě v metodě Main(). Výhodou takto navrženého objektu je vysoká univerzálnost a znovupoužitelnost. Objekt doposud umí jen psát do konzole, my ho však přizpůsobíme tak, aby daná metoda text pouze vracela a bylo na jeho příjemci, jak s ním naloží. Takto můžeme pozdravy ukládat do souborů, psát na webové stránky nebo dále zpracovávat.

Jelikož chceme, aby metoda vracela hodnotu a to string, změníme její dosavadní typ void na string. K návratu hodnoty použijeme příkaz return. Return metodu ukončí a navrátí hodnotu, jakýkoli kód v těle metody po return se již neprovede! Upravme obě třídy:

Metoda Pozdrav() v Zdravic.cs:

public string Pozdrav(string jmeno)
{
    return String.Format("{0} {1}", text, jmeno);
}

Tělo metody Main() v Program.cs:

            Zdravic zdravic = new Zdravic();
            zdravic.text = "Ahoj uživateli";
            Console.WriteLine(zdravic.Pozdrav("Karel"));
            Console.WriteLine(zdravic.Pozdrav("Petr"));
            zdravic.text = "Vítám tě tu programátore";
            Console.WriteLine(zdravic.Pozdrav("Richard"));
            Console.ReadKey();
    class Zdravic
    {
        public string text;

        public string Pozdrav(string jmeno)
        {
            return String.Format("{0} {1}", text, jmeno);
        }
    }

Nyní je náš kód dle dobrých praktik. Ještě naši třídu okomentujme, jak se sluší a patří. Komentáře budeme psát nad název třídy a nad název každého atributu a metody. K jejich zápisu použijeme trojlomítko ///, VS nám poté vygeneruje XML, do kterého vše popíšeme. Vyplatí se nám to ve chvíli, když na třídě používáme nějakou metodu, její popis se nám zobrazí v našeptávači. Pokud by nám komentáře v kódu vadily (zabírají přeci jen několik řádek), můžeme je sklapnout pomocí malých tlačítek "-". Zdokumentovaná třída může vypadat např. takto:

/// <summary>
/// Třída reprezentuje zdravič, který slouží ke zdravení uživatelů
/// </summary>
class Zdravic
{
    /// <summary>
    /// Text pozdravu
    /// </summary>
    public string text;

    /// <summary>
    /// Pozdraví uživatele textem pozdravu a jeho jménem
    /// </summary>
    /// <param name="jmeno">Jméno uživatele</param>
    /// <returns>Text s pozdravem</returns>
    public string Pozdrav(string jmeno)
    {
        return String.Format("{0} {1}", text, jmeno);
    }

}

Podíváme se, že nám VS opravdu popisky zobrazí:

Metody objektu zdravic ve Visual Studio

A jsme u konce. Námi napsaný program má již nějakou úroveň, i když vlastně nic nedělá. Za úkol máte předělat si naši konzolovou kalkulačku do objektů. V příští lekci, Hrací kostka v C# - Konstruktory a náhodná čísla, si uděláme takovou jednoduchou hříčku, necháme dva objekty (bojovníky) soupeřit v aréně (také objektu). Máte se na co těšit ;-)


 

Stáhnout

Staženo 1660x (24.81 kB)
Aplikace je včetně zdrojových kódů v jazyce C#

 

 

Článek pro vás napsal David Čápka
Avatar
Jak se ti líbí článek?
60 hlasů
Autor pracuje jako softwarový architekt a pedagog na projektu ITnetwork.cz (a jeho zahraničních verzích). Velmi si váží svobody podnikání v naší zemi a věří, že když se člověk neštítí práce, tak dokáže úplně cokoli.
Unicorn College Autor sítě se informační technologie naučil na Unicorn College - prestižní soukromé vysoké škole IT a ekonomie.
Aktivity (15)

 

 

Komentáře
Zobrazit starší komentáře (143)

Avatar
Jakub Ondrák:1. dubna 18:36

Díky, Martin Petrovaj, přes druhý link jsem se dopracoval ke správnému nastavení. Je to zde:
Tools -> Option -> Text editor -> General -> a checkbox "Open definition in peek view"

 
Odpovědět  +1 1. dubna 18:36
Avatar
Odpovídá na Jakub Ondrák
Jakub Ondrák:1. dubna 18:40

No tak možná to není ono, protože po restartu VS se mi to začalo zobrazovat i bez zaškrtnutého toho checkboxu. Možná teda stačilo jen restartnout VS... :-?

 
Odpovědět 1. dubna 18:40
Avatar
EweN
Člen
Avatar
EweN:10. května 22:22

Zde přidávám svojí snahu. Dalo mi to dost práce, ale proste me to bavi =)

static void Main(string[] args)
       {
           //Vytvoření propojovací instace
           PocetniOperace pocetniOperace = new PocetniOperace();

           //Úvodní text programu
           Console.WriteLine("Vitejte v jednoduché konzolové kalkulačce.");
           Console.WriteLine();
           Console.WriteLine("Na vstup zadejte dvě čísla: ");

           // Načtení proměnných (dvou čísel od uživatele)
           double cislo1 = double.Parse(Console.ReadLine());
           double cislo2 = double.Parse(Console.ReadLine());

           //Navigační text programu
           Console.WriteLine("Nyní vyberte stisknutím klávesy 1-4 početní operaci. ");

           // Přehled voleb
           Console.WriteLine("  1 - součet   2 - rozdíl  3 - součin  4 - podíl");

           //Načtení proměnné (Výběr metody)
           int volbaMetody = int.Parse(Console.ReadLine());

           // Načtení volbymetody pomocí casové metody
           switch (volbaMetody)
           {
               case 1: pocetniOperace.text = "Tady máš výsledek";
                       Console.WriteLine(pocetniOperace.Soucet(cislo1,cislo2));
                   break;
               case 2:Console.WriteLine(pocetniOperace.Rozdil(cislo1,cislo2));
                   break;
               case 3:Console.WriteLine(pocetniOperace.Soucin(cislo1,cislo2));
                   break;
               case 4:Console.WriteLine(pocetniOperace.Podil(cislo1,cislo2));
                   break;
               default:;
                   break;

           }



           Console.WriteLine("Děkuji za využití aplikace.");
           Console.ReadKey();
/// <summary>
/// Třída, která dělá 4 základní početní operace
/// </summary>
class PocetniOperace
{
    /// <summary>
    /// text k výsledku
    /// </summary>
    public string text;

    public double Soucet(double cislo1, double cislo2)
    {
        return cislo1 + cislo2;
    }

    public double Rozdil(double cislo1, double cislo2)
    {
        return cislo1 - cislo2;
    }

    public double Soucin(double cislo1, double cislo2)
    {
        return cislo1 * cislo2;
    }

    public double Podil(double cislo1, double cislo2)
    {
        return cislo1 / cislo2;
    }
 
Odpovědět  +1 10. května 22:22
Avatar
Dušan Kovářík:11. června 4:29

Moc pěkně napsaný tutoriál. Líbí se mi, jak čtenáře uvádí do principů OOP stylem postupných úprav ukázkového kódu krok za krokem, takže je to velice názorné a pochopitelné.
A tady je můj úkol:

class Program
{
    static void Main(string[] args)
    {
        UzivatelskyVstup uzivatelskyVstup = new UzivatelskyVstup();
        AritmetickeOperace aritmetickeOperace = new AritmetickeOperace();
        Console.WriteLine("Kalkulačka");
        Console.WriteLine("==========");

        double cislo1, cislo2;
        int cisloOperace;
        bool pokracovat = true;
        while (pokracovat)
        {
            Console.WriteLine();
            cislo1 = uzivatelskyVstup.NactiDouble("Zadejte 1. číslo:");
            cislo2 = uzivatelskyVstup.NactiDouble("Zadejte 2. číslo:");
            Console.WriteLine("Vyberte operaci stiskem klávesy:");
            Console.WriteLine("1 - sčítání");
            Console.WriteLine("2 - odčítání");
            Console.WriteLine("3 - násobení");
            Console.WriteLine("4 - dělení");
            cisloOperace = uzivatelskyVstup.ZvolPolozku(4);
            switch (cisloOperace)
            {
                case 1:
                    Console.WriteLine(aritmetickeOperace.Soucet(cislo1, cislo2));
                    break;
                case 2:
                    Console.WriteLine(aritmetickeOperace.Rozdil(cislo1, cislo2));
                    break;
                case 3:
                    Console.WriteLine(aritmetickeOperace.Soucin(cislo1, cislo2));
                    break;
                case 4:
                    Console.WriteLine(aritmetickeOperace.Podil(cislo1, cislo2));
                    break;
            }
            pokracovat = uzivatelskyVstup.DotazPokracovani("Přejete si zadat další příklad?");
        }
        Console.WriteLine("Aplikaci ukončíte stiskem libovolné klávesy...");
        Console.ReadKey();
    }
}
/// <summary>
/// Třída obsahuje metody pro provedení základních aritmetických operací
/// </summary>
class AritmetickeOperace
{
    /// <summary>
    /// Názvy jednotlivých operací, které metody třídy umí provést
    /// </summary>
    private string[] textOperace = new string[] { "Součet", "Rozdíl", "Součin", "Podíl" };

    /// <summary>
    /// Sečte dvě čísla typu double
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <returns>Text s popisem operace a výsledkem</returns>
    public string Soucet(double x, double y)
    {
        return VysledkovaVeta(0, x, y, x + y);
    }

    /// <summary>
    /// Odečte dvě čísla typu double
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <returns>Text s popisem operace a výsledkem</returns>
    public string Rozdil(double x, double y)
    {
        return VysledkovaVeta(1, x, y, x - y);
    }

    /// <summary>
    /// Vynásobí dvě čísla typu double
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <returns>Text s popisem operace a výsledkem</returns>
    public string Soucin(double x, double y)
    {
        return VysledkovaVeta(2, x, y, x * y);
    }

    /// <summary>
    /// Vydělí dvě čísla typu double
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <returns>Text s popisem operace a výsledkem; jestliže druhé číslo bude 0, pak upozornění na pokus o neplatnou operaci</returns>
    public string Podil(double x, double y)
    {
        if (y != 0)
            return VysledkovaVeta(3, x, y, x / y);
        else
            return "Dělení nulou! Operaci nelze provést.";
    }

    /// <summary>
    /// Sestaví větu s názvem aritmetické operace, operandy i výsledkem
    /// </summary>
    /// <param name="cisloOperace"></param>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <param name="vysledek"></param>
    /// <returns>Text kompletní věty</returns>
    private string VysledkovaVeta(int cisloOperace, double x, double y, double vysledek)
    {
        return String.Format("{0} čísel {1} a {2} je {3}", textOperace[cisloOperace], x, y, vysledek);
    }
}
/// <summary>
/// Třída obsahuje metody pro vstup hodnot či voleb od uživatele z klávesnice
/// </summary>
class UzivatelskyVstup
{
    /// <summary>
    /// Text, který se vypíše na konzoli v případě, že uživatel zadá neplatnou hodnotu
    /// </summary>
    private string neplatnaHodnota = "Zadali jste neplatnou hodnotu. Zkuste to prosím znovu.";

    /// <summary>
    /// Text, který se vypíše na konzoli, pokud uživatel vybere z nabídky položku
    /// s větším pořadovým číslem, než kolik jich nabídka obsahuje
    /// </summary>
    private string volbaMimoRozsah = "Zadaná volba je mimo rozsah. Zkuste to prosím znovu.";

    /// <summary>
    /// Načte číslo typu double zadané uživatel z klávesnice
    /// </summary>
    /// <param name="vyzva"></param>
    /// <returns>Číslo typu double</returns>
    public double NactiDouble(string vyzva)
    {
        double cislo = 0;
        bool platneZadani = false;
        while(!platneZadani)
        {
            Console.Write("{0} ", vyzva);
            platneZadani = double.TryParse(Console.ReadLine(), out cislo);
            if (!platneZadani)
                Console.WriteLine(neplatnaHodnota);
        }
        return cislo;
    }

    /// <summary>
    /// Zajistí volbu položky z nějaké nabídky stiskem numerické klávesy uživatelem
    /// </summary>
    /// <param name="horniMez"></param>
    /// <returns>Pořadové číslo položky</returns>
    public int ZvolPolozku(int horniMez)
    {
        int volba = 0;
        bool platneZadani = false;
        while (!platneZadani)
        {
            platneZadani = int.TryParse(Console.ReadKey().KeyChar.ToString(), out volba);
            Console.WriteLine();
            if (!platneZadani)
                Console.WriteLine(neplatnaHodnota);
            else if (volba < 1 || volba > horniMez)
            {
                platneZadani = false; // sice je úspěšně naparsována hodnota int, která je ale mimo rozsah
                Console.WriteLine(volbaMimoRozsah);
            }
        }
        return volba;
    }

    /// <summary>
    /// Vyzve uživatele k volbě stiskem klávesy tam, kde možnosti mohou být buď Ano nebo Ne
    /// </summary>
    /// <param name="vyzva"></param>
    /// <returns>true nebo false podle toho, zda se uživatel rozhodne pro Ano nebo Ne</returns>
    public bool DotazPokracovani(string vyzva)
    {
        string volba = "";
        bool platneZadani = false;
        while (!platneZadani)
        {
            Console.Write("{0} (A/N) ", vyzva);
            volba = Console.ReadKey().KeyChar.ToString().ToLower();
            Console.WriteLine();
            if (volba == "a")
                return true;
            else if (volba == "n")
                return false;
            else
                Console.WriteLine(neplatnaHodnota);
        }
        return false;
    }
}
Editováno 11. června 4:32
 
Odpovědět 11. června 4:29
Avatar
Longino
Člen
Avatar
Longino:23. července 13:30

Ahoj, díky moc za články, jsou dobře psány a srozumitelné. Chtěl bych se zeptat jestli se vstup uživatele (např. Zadej číslo:) má psát do nové samotné třídy nebo to můžu psát do Program.cs?

 
Odpovědět 23. července 13:30
Avatar
Miroslav Mazal:16. srpna 16:41

Ahoj. Jak mám rozumět datovému typu. Je tu napsáno: [modifikátor přístupu] [návratový typ] JmenoMetody, ale v dalším článku je třeba public Kostka() . Znamená to, že návratový typ není povinný? A pokud nebudu mít návrat žádné hodnoty, musím tam napsat void, anebo to je jen pojistka, aby se něco nějakou chybou nevrátilo?

 
Odpovědět 16. srpna 16:41
Avatar
Marek Uhlik
Člen
Avatar
Odpovídá na Miroslav Mazal
Marek Uhlik:16. srpna 17:07

Neznamená, protože public Kostka() není funkce, ale konstruktor.
Je povinný, a ano musíš.

 
Odpovědět 16. srpna 17:07
Avatar
Miroslav Mazal:16. srpna 17:23

Dík. A jö. Pořád dokola si to čtu, ať se mi to zapíše do hlavy. Co je parametr, metoda, konstruktor, proměnná...

 
Odpovědět 16. srpna 17:23
Avatar
Patrik Herman:21. srpna 0:18

Zdravím, já už prostě nevím v čem je problém. Chci zadat novou public void metodu

public void Hello();
{Console.WriteLine("Ahoj uživateli");
}

Ale stále mi to hází chybu: CS0501 Zdravic.Hello(strin­g) musí deklarovat tělo, protože je označené jako abstraktní, externí nebo částečné.
Už opravdu nechápu v čem je chyba. Vím, že je to hloupá otázka a i když zkopíruji kód z této stránky, který je totožný, tak to nenahlásí chybu. Prosím o odpověď.

 
Odpovědět 21. srpna 0:18
Avatar
Odpovídá na Patrik Herman
simon.steiner:21. srpna 1:12

Za Hello() nepatří středník.

 
Odpovědět 21. srpna 1:12
Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zobrazeno 10 zpráv z 153. Zobrazit vše