Kurz: Prozkoumání nápadů pomocí příkazů nejvyšší úrovně k vytváření kódu při učení

Článek
11/14/2023

V tomto kurzu se naučíte:

Seznamte se s pravidly, která řídí vaše používání příkazů nejvyšší úrovně.
K prozkoumání algoritmů použijte příkazy nejvyšší úrovně.
Refaktoring prozkoumávání opakovaně použitelných komponent.

Předpoklady

Budete muset nastavit počítač tak, aby běžel .NET 6, který zahrnuje kompilátor C# 10. Kompilátor C# 10 je k dispozici od sady Visual Studio 2022 nebo .NET 6 SDK.

V tomto kurzu se předpokládá, že znáte C# a .NET, včetně sady Visual Studio nebo rozhraní příkazového řádku .NET.

Začít s prozkoumáváním

Příkazy nejvyšší úrovně umožňují vyhnout se dodatečnému obřadu vyžadovanému umístěním vstupního bodu programu do statické metody do třídy. Typický výchozí bod nové konzolové aplikace vypadá jako následující kód:

using System;

namespace Application
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Předchozí kód je výsledkem spuštění dotnet new console příkazu a vytvoření nové konzolové aplikace. Tyto 11 řádků obsahují pouze jeden řádek spustitelného kódu. Tento program můžete zjednodušit pomocí nové funkce příkazů nejvyšší úrovně. To vám umožní odebrat všechny řádky, ale dva řádky v tomto programu:

// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");

Důležité

Šablony jazyka C# pro .NET 6 používají příkazy nejvyšší úrovně. Pokud jste už upgradovali na .NET 6, vaše aplikace nemusí odpovídat kódu v tomto článku. Další informace najdete v článku o generování příkazů nejvyšší úrovně v nových šablonách jazyka C#.

Sada .NET 6 SDK také přidá sadu implicitních global using direktiv pro projekty, které používají následující sady SDK:

Microsoft.NET.Sdk
Microsoft.NET.Sdk.Web
Microsoft.NET.Sdk.Worker

Tyto implicitní global using direktivy zahrnují nejběžnější obory názvů pro typ projektu.

Další informace najdete v článku o direktivách Implicit using

Tato funkce zjednodušuje, co je potřeba k tomu, abyste mohli začít zkoumat nové nápady. Příkazy nejvyšší úrovně můžete použít pro skriptovací scénáře nebo prozkoumat. Jakmile budete mít základní informace, můžete začít refaktoring kódu a vytvářet metody, třídy nebo jiná sestavení pro opakovaně použitelné komponenty, které jste vytvořili. Příkazy nejvyšší úrovně umožňují rychlé experimentování a kurzy pro začátečníky. Poskytují také bezproblémovou cestu od experimentování po úplné programy.

Příkazy nejvyšší úrovně se spouští v pořadí, v jakém se v souboru zobrazují. Příkazy nejvyšší úrovně je možné použít pouze v jednom zdrojovém souboru ve vaší aplikaci. Kompilátor vygeneruje chybu, pokud je použijete ve více souborech.

Vytvoření kouzelného počítače odpovědí .NET

V tomto kurzu vytvoříme konzolovou aplikaci, která odpoví na otázku "ano" nebo "ne" náhodnou odpovědí. Funkce budete vytvářet krok za krokem. Můžete se soustředit na svůj úkol, nikoli na obřad potřebný pro strukturu typického programu. Jakmile budete s funkcí spokojeni, můžete aplikaci refaktorovat podle potřeby.

Dobrým výchozím bodem je napsat otázku zpět do konzoly. Můžete začít napsáním následujícího kódu:

Console.WriteLine(args);

Neeklarujete proměnnou args . U jednoho zdrojového souboru, který obsahuje příkazy nejvyšší úrovně, kompilátor rozpozná args , že znamená argumenty příkazového řádku. Typ args je , string[]stejně jako ve všech programech jazyka C#.

Kód můžete otestovat spuštěním následujícího dotnet run příkazu:

dotnet run -- Should I use top level statements in all my programs?

Argumenty za příkazovým -- řádkem se předají programu. Můžete vidět typ args proměnné, protože se to vytiskne do konzoly:

System.String[]

Pokud chcete napsat otázku do konzoly, budete muset zobrazit výčet argumentů a oddělit je mezerou. WriteLine Volání nahraďte následujícím kódem:

Console.WriteLine();
foreach(var s in args)
{
    Console.Write(s);
    Console.Write(' ');
}
Console.WriteLine();

Když teď program spustíte, zobrazí se správně otázka jako řetězec argumentů.

Odpověď pomocí náhodné odpovědi

Po odpovědi na otázku můžete přidat kód, který vygeneruje náhodnou odpověď. Začněte přidáním pole možných odpovědí:

string[] answers =
[
    "It is certain.",       "Reply hazy, try again.",     "Don’t count on it.",
    "It is decidedly so.",  "Ask again later.",           "My reply is no.",
    "Without a doubt.",     "Better not tell you now.",   "My sources say no.",
    "Yes – definitely.",    "Cannot predict now.",        "Outlook not so good.",
    "You may rely on it.",  "Concentrate and ask again.", "Very doubtful.",
    "As I see it, yes.",
    "Most likely.",
    "Outlook good.",
    "Yes.",
    "Signs point to yes.",
];

Toto pole obsahuje deset odpovědí, které jsou pozitivní, pět, které nejsou potvrzené, a pět negativních. Dále přidejte následující kód, který vygeneruje a zobrazí náhodnou odpověď z pole:

var index = new Random().Next(answers.Length - 1);
Console.WriteLine(answers[index]);

Pokud chcete zobrazit výsledky, můžete aplikaci spustit znovu. Mělo by se zobrazit něco jako v následujícím výstupu:

dotnet run -- Should I use top level statements in all my programs?

Should I use top level statements in all my programs?
Better not tell you now.

Tento kód odpovídá na otázky, ale pojďme přidat další funkci. Chcete, aby vaše aplikace pro otázky simuluje myšlení na odpověď. Můžete to udělat přidáním trochu animace ASCII a pozastavením při práci. Za řádek, který odpovídá otázce, přidejte následující kód:

for (int i = 0; i < 20; i++)
{
    Console.Write("| -");
    await Task.Delay(50);
    Console.Write("\b\b\b");
    Console.Write("/ \\");
    await Task.Delay(50);
    Console.Write("\b\b\b");
    Console.Write("- |");
    await Task.Delay(50);
    Console.Write("\b\b\b");
    Console.Write("\\ /");
    await Task.Delay(50);
    Console.Write("\b\b\b");
}
Console.WriteLine();

Budete také muset přidat using příkaz na začátek zdrojového souboru:

using System.Threading.Tasks;

Příkazy using musí být před všemi jinými příkazy v souboru. Jinak se jedná o chybu kompilátoru. Program můžete spustit znovu a zobrazit animaci. Díky tomu je lepší zážitek. Experimentujte s délkou zpoždění tak, aby odpovídala vašemu vkusu.

Předchozí kód vytvoří sadu rotujících řádků oddělených mezerou. Přidání klíčového await slova dává kompilátoru pokyn, aby vygeneroval vstupní bod programu jako metodu async , která má modifikátor, a vrátí hodnotu System.Threading.Tasks.Task. Tento program nevrací hodnotu, takže vstupní bod programu vrátí Taskhodnotu . Pokud program vrátí celočíselnou hodnotu, přidáte na konec příkazů nejvyšší úrovně návratový příkaz. Tento návratový příkaz určuje celočíselnou hodnotu, která se má vrátit. Pokud příkazy nejvyšší úrovně obsahují await výraz, vrátí se System.Threading.Tasks.Task<TResult>návratový typ .

Refaktoring pro budoucnost

Program by měl vypadat jako následující kód:

Console.WriteLine();
foreach(var s in args)
{
    Console.Write(s);
    Console.Write(' ');
}
Console.WriteLine();

for (int i = 0; i < 20; i++)
{
    Console.Write("| -");
    await Task.Delay(50);
    Console.Write("\b\b\b");
    Console.Write("/ \\");
    await Task.Delay(50);
    Console.Write("\b\b\b");
    Console.Write("- |");
    await Task.Delay(50);
    Console.Write("\b\b\b");
    Console.Write("\\ /");
    await Task.Delay(50);
    Console.Write("\b\b\b");
}
Console.WriteLine();

string[] answers =
[
    "It is certain.",       "Reply hazy, try again.",     "Don't count on it.",
    "It is decidedly so.",  "Ask again later.",           "My reply is no.",
    "Without a doubt.",     "Better not tell you now.",   "My sources say no.",
    "Yes – definitely.",    "Cannot predict now.",        "Outlook not so good.",
    "You may rely on it.",  "Concentrate and ask again.", "Very doubtful.",
    "As I see it, yes.",
    "Most likely.",
    "Outlook good.",
    "Yes.",
    "Signs point to yes.",
];

var index = new Random().Next(answers.Length - 1);
Console.WriteLine(answers[index]);

Předchozí kód je rozumný. Funguje to. Ale není možné ho opakovaně použít. Když teď máte aplikaci funkční, je čas vytáhnout opakovaně použitelné části.

Jedním kandidátem je kód, který zobrazuje čekající animaci. Tento fragment kódu se může stát metodou:

Můžete začít vytvořením místní funkce v souboru. Nahraďte aktuální animaci následujícím kódem:

await ShowConsoleAnimation();

static async Task ShowConsoleAnimation()
{
    for (int i = 0; i < 20; i++)
    {
        Console.Write("| -");
        await Task.Delay(50);
        Console.Write("\b\b\b");
        Console.Write("/ \\");
        await Task.Delay(50);
        Console.Write("\b\b\b");
        Console.Write("- |");
        await Task.Delay(50);
        Console.Write("\b\b\b");
        Console.Write("\\ /");
        await Task.Delay(50);
        Console.Write("\b\b\b");
    }
    Console.WriteLine();
}

Předchozí kód vytvoří místní funkci uvnitř hlavní metody. To ještě není opakovaně použitelné. Proto tento kód extrahujte do třídy. Vytvořte nový soubor s názvem utilities.cs a přidejte následující kód:

namespace MyNamespace
{
    public static class Utilities
    {
        public static async Task ShowConsoleAnimation()
        {
            for (int i = 0; i < 20; i++)
            {
                Console.Write("| -");
                await Task.Delay(50);
                Console.Write("\b\b\b");
                Console.Write("/ \\");
                await Task.Delay(50);
                Console.Write("\b\b\b");
                Console.Write("- |");
                await Task.Delay(50);
                Console.Write("\b\b\b");
                Console.Write("\\ /");
                await Task.Delay(50);
                Console.Write("\b\b\b");
            }
            Console.WriteLine();
        }
    }
}

Soubor, který obsahuje příkazy nejvyšší úrovně, může také obsahovat obory názvů a typy na konci souboru za příkazy nejvyšší úrovně. V tomto kurzu ale vložíte animační metodu do samostatného souboru, aby byla snadněji použitelná.

Nakonec můžete vyčistit animační kód, aby se odstranily nějaké duplicity:

foreach (string s in animations)
{
    Console.Write(s);
    await Task.Delay(50);
    Console.Write("\b\b\b");
}

Teď máte úplnou aplikaci a refaktorovali jste opakovaně použitelné části pro pozdější použití. Novou metodu nástroje můžete volat z příkazů nejvyšší úrovně, jak je znázorněno níže v dokončené verzi hlavního programu:

using MyNamespace;

Console.WriteLine();
foreach(var s in args)
{
    Console.Write(s);
    Console.Write(' ');
}
Console.WriteLine();

await Utilities.ShowConsoleAnimation();

string[] answers =
[
    "It is certain.",       "Reply hazy, try again.",     "Don’t count on it.",
    "It is decidedly so.",  "Ask again later.",           "My reply is no.",
    "Without a doubt.",     "Better not tell you now.",   "My sources say no.",
    "Yes – definitely.",    "Cannot predict now.",        "Outlook not so good.",
    "You may rely on it.",  "Concentrate and ask again.", "Very doubtful.",
    "As I see it, yes.",
    "Most likely.",
    "Outlook good.",
    "Yes.",
    "Signs point to yes.",
];

var index = new Random().Next(answers.Length - 1);
Console.WriteLine(answers[index]);

Předchozí příklad přidá volání do Utilities.ShowConsoleAnimationa přidá další using příkaz.

Shrnutí

Příkazy nejvyšší úrovně usnadňují vytváření jednoduchých programů pro zkoumání nových algoritmů. Můžete experimentovat s algoritmy tím, že vyzkoušíte různé fragmenty kódu. Jakmile se dozvíte, co funguje, můžete refaktorovat kód tak, aby byl lépe udržovatelný.

Příkazy nejvyšší úrovně zjednodušují programy založené na konzolových aplikacích. Patří mezi ně funkce Azure, Akce GitHubu a další malé nástroje. Další informace najdete v tématu Příkazy nejvyšší úrovně (Průvodce programováním v C#).