Zelfstudie: Ideeën verkennen met behulp van instructies op het hoogste niveau om code te bouwen terwijl u leert
In deze zelfstudie leert u het volgende:
- Meer informatie over de regels voor uw gebruik van instructies op het hoogste niveau.
- Gebruik instructies op het hoogste niveau om algoritmen te verkennen.
- Herstructureer verkenningen in herbruikbare onderdelen.
Vereisten
U moet uw computer instellen om .NET 6 uit te voeren, waaronder de C# 10-compiler. De C# 10-compiler is beschikbaar vanaf Visual Studio 2022 of .NET 6 SDK.
In deze zelfstudie wordt ervan uitgegaan dat u bekend bent met C# en .NET, met inbegrip van Visual Studio of de .NET CLI.
Begin met verkennen
Met instructies op het hoogste niveau kunt u de extra ceremonie vermijden die vereist is door het ingangspunt van uw programma in een statische methode in een klas te plaatsen. Het typische beginpunt voor een nieuwe consoletoepassing ziet eruit als de volgende code:
using System;
namespace Application
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
}
De voorgaande code is het resultaat van het uitvoeren van de dotnet new console opdracht en het maken van een nieuwe consoletoepassing. Deze 11 regels bevatten slechts één regel uitvoerbare code. U kunt dat programma vereenvoudigen met de nieuwe functie voor instructies op het hoogste niveau. Hiermee kunt u alle maar twee regels in dit programma verwijderen:
// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");
Belangrijk
De C#-sjablonen voor .NET 6 gebruiken instructies op het hoogste niveau. Uw toepassing komt mogelijk niet overeen met de code in dit artikel als u al een upgrade naar .NET 6 hebt uitgevoerd. Zie het artikel over nieuwe C#-sjablonen voor het genereren van instructies op het hoogste niveau
De .NET 6 SDK voegt ook een reeks implicieteglobal using instructies toe voor projecten die gebruikmaken van de volgende SDK's:
- Microsoft.NET.Sdk
- Microsoft.NET.Sdk.Web
- Microsoft.NET.Sdk.Worker
Deze impliciete global using instructies bevatten de meest voorkomende naamruimten voor het projecttype.
Zie het artikel over impliciete gebruiksrichtlijnen voor meer informatie
Deze functie vereenvoudigt wat nodig is om nieuwe ideeën te verkennen. U kunt instructies op het hoogste niveau gebruiken voor scriptscenario's of verkennen. Zodra u de basisbeginselen hebt, kunt u beginnen met het herstructureren van de code en methoden, klassen of andere assembly's maken voor herbruikbare onderdelen die u hebt gemaakt. Instructies op het hoogste niveau maken snelle experimenten en zelfstudies voor beginners mogelijk. Ze bieden ook een soepel pad van experimenten tot volledige programma's.
Instructies op het hoogste niveau worden uitgevoerd in de volgorde waarin ze in het bestand worden weergegeven. Instructies op het hoogste niveau kunnen slechts in één bronbestand in uw toepassing worden gebruikt. De compiler genereert een fout als u deze in meer dan één bestand gebruikt.
Een magische .NET-antwoordmachine bouwen
Voor deze zelfstudie gaan we een consoletoepassing bouwen die een 'ja' of 'nee'-vraag beantwoordt met een willekeurig antwoord. U bouwt de functionaliteit stap voor stap uit. U kunt zich richten op uw taak in plaats van de ceremonie die nodig is voor de structuur van een typisch programma. Zodra u tevreden bent met de functionaliteit, kunt u de toepassing naar wens herstructureren.
Een goed uitgangspunt is om de vraag terug te schrijven naar de console. U kunt beginnen met het schrijven van de volgende code:
Console.WriteLine(args);
U declareert args geen variabele. Voor het bestand met één bron dat uw instructies op het hoogste niveau bevat, herkent de compiler de opdrachtregelargumenten args . Het type args is een string[], zoals in alle C#-programma's.
U kunt uw code testen door de volgende dotnet run opdracht uit te voeren:
dotnet run -- Should I use top level statements in all my programs?
De argumenten na de -- opdrachtregel worden doorgegeven aan het programma. U kunt het type variabele args zien, omdat dat wordt afgedrukt naar de console:
System.String[]
Als u de vraag naar de console wilt schrijven, moet u de argumenten opsommen en scheiden met een spatie. Vervang de WriteLine aanroep door de volgende code:
Console.WriteLine();
foreach(var s in args)
{
Console.Write(s);
Console.Write(' ');
}
Console.WriteLine();
Wanneer u het programma uitvoert, wordt de vraag nu correct weergegeven als een tekenreeks met argumenten.
Reageren met een willekeurig antwoord
Nadat u de vraag hebt herhaald, kunt u de code toevoegen om het willekeurige antwoord te genereren. Begin met het toevoegen van een matrix met mogelijke antwoorden:
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.",
];
Deze matrix heeft tien antwoorden die bevestigend zijn, vijf antwoorden die niet-committaal zijn en vijf die negatief zijn. Voeg vervolgens de volgende code toe om een willekeurig antwoord uit de matrix te genereren en weer te geven:
var index = new Random().Next(answers.Length - 1);
Console.WriteLine(answers[index]);
U kunt de toepassing opnieuw uitvoeren om de resultaten te bekijken. Als het goed is, ziet u ongeveer de volgende uitvoer:
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.
Deze code beantwoordt de vragen, maar we gaan nog een functie toevoegen. U wilt dat uw vraag-app nadenkt over het antwoord. U kunt dit doen door een beetje ASCII-animatie toe te voegen en tijdens het werken te onderbreken. Voeg de volgende code toe na de regel die de vraag weergeeft:
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();
U moet ook een using instructie toevoegen aan het begin van het bronbestand:
using System.Threading.Tasks;
De using instructies moeten vóór andere instructies in het bestand staan. Anders is het een compilerfout. U kunt het programma opnieuw uitvoeren en de animatie bekijken. Dat maakt een betere ervaring. Experimenteer met de lengte van de vertraging die overeenkomt met uw smaak.
Met de voorgaande code wordt een set draaiende lijnen gemaakt, gescheiden door een spatie. Door het await trefwoord toe te voegen, wordt de compiler geïnstrueerd om het programmainvoerpunt te genereren als een methode die de async modifier heeft en een System.Threading.Tasks.Task. Dit programma retourneert geen waarde, dus het ingangspunt van het programma retourneert een Task. Als uw programma een geheel getal retourneert, voegt u een retourinstructie toe aan het einde van uw instructies op het hoogste niveau. Met deze retourinstructie wordt de geheel getalwaarde opgegeven die moet worden geretourneerd. Als uw instructies op het hoogste niveau een await expressie bevatten, wordt System.Threading.Tasks.Task<TResult>het retourtype .
Herstructureren voor de toekomst
Uw programma moet eruitzien als de volgende code:
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]);
De voorgaande code is redelijk. Het werkt. Maar het is niet herbruikbaar. Nu de toepassing werkt, is het tijd om herbruikbare onderdelen op te halen.
Een kandidaat is de code die de wachtanimatie weergeeft. Dat fragment kan een methode worden:
U kunt beginnen met het maken van een lokale functie in uw bestand. Vervang de huidige animatie door de volgende code:
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();
}
Met de voorgaande code maakt u een lokale functie in uw hoofdmethode. Dat is nog steeds niet herbruikbaar. Pak die code dus uit in een klasse. Maak een nieuw bestand met de naam utilities.cs en voeg de volgende code toe:
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();
}
}
}
Een bestand met instructies op het hoogste niveau kan ook naamruimten en typen aan het einde van het bestand bevatten, na de instructies op het hoogste niveau. Maar voor deze zelfstudie plaatst u de animatiemethode in een afzonderlijk bestand om deze beter herbruikbaar te maken.
Ten slotte kunt u de animatiecode opschonen om duplicatie te verwijderen:
foreach (string s in animations)
{
Console.Write(s);
await Task.Delay(50);
Console.Write("\b\b\b");
}
U hebt nu een volledige toepassing en u hebt de herbruikbare onderdelen geherstructureerd voor later gebruik. U kunt de nieuwe hulpprogrammamethode aanroepen vanuit uw instructies op het hoogste niveau, zoals hieronder wordt weergegeven in de voltooide versie van het hoofdprogramma:
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]);
In het voorgaande voorbeeld wordt de aanroep toegevoegd Utilities.ShowConsoleAnimationen wordt een extra using instructie toegevoegd.
Samenvatting
Met instructies op het hoogste niveau kunt u eenvoudiger eenvoudige programma's maken om nieuwe algoritmen te verkennen. U kunt experimenteren met algoritmen door verschillende codefragmenten uit te proberen. Zodra u hebt geleerd wat werkt, kunt u de code herstructureren zodat deze beter kan worden onderhouden.
Instructies op het hoogste niveau vereenvoudigen programma's die zijn gebaseerd op consoletoepassingen. Deze omvatten Azure-functies, GitHub-acties en andere kleine hulpprogramma's. Zie De instructies op het hoogste niveau (C#-programmeerhandleiding) voor meer informatie.
Feedback
Binnenkort: Gedurende 2024 worden GitHub Issues uitgefaseerd als het feedbackmechanisme voor inhoud. Dit wordt vervangen door een nieuw feedbacksysteem. Ga voor meer informatie naar: https://aka.ms/ContentUserFeedback.
Feedback verzenden en bekijken voor