Aplikacja konsolowaConsole app

W tym samouczku przedstawiono szereg funkcji platformy .NET Core i języka C#.This tutorial teaches you a number of features in .NET Core and the C# language. Dowiesz się:You'll learn:

  • Podstawowe informacje dotyczące interfejs wiersza polecenia platformy .NET CoreThe basics of the .NET Core CLI
  • Struktura aplikacji konsolowej C#The structure of a C# Console Application
  • We/wy konsoliConsole I/O
  • Podstawy interfejsów API we/wy plików w programie .NETThe basics of File I/O APIs in .NET
  • Podstawowe informacje na temat programowania asynchronicznego opartego na zadaniach w programie .NETThe basics of the Task-based Asynchronous Programming in .NET

Utworzysz aplikację, która odczytuje plik tekstowy, i echo zawartość tego pliku tekstowego do konsoli programu.You'll build an application that reads a text file, and echoes the contents of that text file to the console. Dane wyjściowe do konsoli są w tempie zgodne z odczytem na głos.The output to the console is paced to match reading it aloud. Można przyspieszyć lub spowalniać tempo, naciskając klawisze "<" (mniejsze niż) lub ">" (większe niż).You can speed up or slow down the pace by pressing the '<' (less than) or '>' (greater than) keys.

Ten samouczek zawiera wiele funkcji.There are a lot of features in this tutorial. Kompilujmy je po jednej.Let's build them one by one.

Wymagania wstępnePrerequisites

  • Skonfiguruj maszynę do uruchamiania programu .NET Core.Set up your machine to run .NET Core. Instrukcje instalacji można znaleźć na stronie pliki do pobrania w programie .NET Core .You can find the installation instructions on the .NET Core downloads page. Tę aplikację można uruchomić w systemie Windows, Linux, macOS lub w kontenerze platformy Docker.You can run this application on Windows, Linux, macOS, or in a Docker container.

  • Zainstaluj swój ulubiony Edytor kodu.Install your favorite code editor.

Tworzenie aplikacjiCreate the app

Pierwszym krokiem jest utworzenie nowej aplikacji.The first step is to create a new application. Otwórz wiersz polecenia i Utwórz nowy katalog dla aplikacji.Open a command prompt and create a new directory for your application. Upewnij się, że bieżący katalog.Make that the current directory. Wpisz polecenie dotnet new console w wierszu polecenia.Type the command dotnet new console at the command prompt. Spowoduje to utworzenie plików początkowych dla podstawowej aplikacji "Hello world".This creates the starter files for a basic "Hello World" application.

Przed rozpoczęciem wprowadzania zmian przejdź do kroku, aby uruchomić prostą aplikację Hello world.Before you start making modifications, let's go through the steps to run the simple Hello World application. Po utworzeniu aplikacji wpisz dotnet restore w wierszu polecenia.After creating the application, type dotnet restore at the command prompt. To polecenie uruchamia proces przywracania pakietów NuGet.This command runs the NuGet package restore process. Pakiet NuGet jest menedżerem pakietów platformy .NET.NuGet is a .NET package manager. To polecenie pobiera wszystkie brakujące zależności dla projektu.This command downloads any of the missing dependencies for your project. Ponieważ jest to nowy projekt, nie są stosowane żadne zależności, więc pierwsze uruchomienie spowoduje pobranie środowiska .NET Core.As this is a new project, none of the dependencies are in place, so the first run will download the .NET Core framework. Po tym początkowym kroku będziesz mieć możliwość uruchamiania tylko wtedy, dotnet restore gdy dodasz nowe pakiety zależne lub zaktualizujesz wersje dowolnych zależności.After this initial step, you will only need to run dotnet restore when you add new dependent packages, or update the versions of any of your dependencies.

Nie trzeba uruchamiać programu dotnet restore , ponieważ jest on uruchamiany niejawnie przez wszystkie polecenia, które wymagają wykonania przywracania, takie jak,,,, dotnet new dotnet build dotnet run dotnet test dotnet publish i dotnet pack .You don't have to run dotnet restore because it's run implicitly by all commands that require a restore to occur, such as dotnet new, dotnet build, dotnet run, dotnet test, dotnet publish, and dotnet pack. Aby wyłączyć Przywracanie niejawne, użyj --no-restore opcji.To disable implicit restore, use the --no-restore option.

dotnet restorePolecenie jest nadal przydatne w niektórych scenariuszach, w których jawne jest przywracanie, takie jak kompilacje ciągłej integracji w Azure DevOps Services lub w systemach kompilacji, które muszą jawnie kontrolować po wystąpieniu przywracania.The dotnet restore command is still useful in certain scenarios where explicitly restoring makes sense, such as continuous integration builds in Azure DevOps Services or in build systems that need to explicitly control when the restore occurs.

Informacje o sposobach zarządzania źródłami danych NuGet znajdują się w dotnet restore dokumentacji.For information about how to manage NuGet feeds, see the dotnet restore documentation.

Po przywróceniu pakietów zostanie uruchomione polecenie dotnet build .After restoring packages, you run dotnet build. Spowoduje to uruchomienie aparatu kompilacji i utworzenie pliku wykonywalnego aplikacji.This executes the build engine and creates your application executable. dotnet runNa koniec uruchamiasz aplikację.Finally, you execute dotnet run to run your application.

Prosty kod aplikacji Hello world to wszystko w Program.cs.The simple Hello World application code is all in Program.cs. Otwórz ten plik za pomocą ulubionego edytora tekstu.Open that file with your favorite text editor. Zamierzamy wprowadzić Twoje pierwsze zmiany.We're about to make our first changes. W górnej części pliku Zobacz instrukcję using:At the top of the file, see a using statement:

using System;

Ta instrukcja informuje kompilator, że wszystkie typy z System przestrzeni nazw znajdują się w zakresie.This statement tells the compiler that any types from the System namespace are in scope. Podobnie jak w przypadku innych języków zorientowanych na obiekt, które mogą być używane, C# używa przestrzeni nazw do organizowania typów.Like other Object Oriented languages you may have used, C# uses namespaces to organize types. Ten program Hello world nie jest inny.This Hello World program is no different. Można zobaczyć, że program jest ujęty w przestrzeń nazw o nazwie na podstawie nazwy bieżącego katalogu.You can see that the program is enclosed in the namespace with the name based on the name of the current directory. Na potrzeby tego samouczka Zmieńmy nazwę przestrzeni nazw na TeleprompterConsole :For this tutorial, let's change the name of the namespace to TeleprompterConsole:

namespace TeleprompterConsole

Odczytywanie i echo plikuReading and Echoing the File

Pierwsza funkcja do dodania to możliwość odczytywania pliku tekstowego i wyświetlania całego tekstu w konsoli programu.The first feature to add is the ability to read a text file and display all that text to the console. Najpierw Dodajmy plik tekstowy.First, let's add a text file. Skopiuj plik sampleQuotes.txt z repozytorium GitHub dla tego przykładu do katalogu projektu.Copy the sampleQuotes.txt file from the GitHub repository for this sample into your project directory. Będzie to skrypt aplikacji.This will serve as the script for your application. Jeśli chcesz uzyskać informacje dotyczące sposobu pobierania przykładowej aplikacji dla tego tematu, zobacz instrukcje w temacie przykłady i samouczki .If you would like information on how to download the sample app for this topic, see the instructions in the Samples and Tutorials topic.

Następnie Dodaj następującą metodę do Program klasy (bezpośrednio poniżej Main metody):Next, add the following method in your Program class (right below the Main method):

static IEnumerable<string> ReadFrom(string file)
{
    string line;
    using (var reader = File.OpenText(file))
    {
        while ((line = reader.ReadLine()) != null)
        {
            yield return line;
        }
    }
}

Ta metoda używa typów z dwóch nowych przestrzeni nazw.This method uses types from two new namespaces. Aby można było skompilować kompilację, należy dodać dwa następujące wiersze na początku pliku:For this to compile you'll need to add the following two lines to the top of the file:

using System.Collections.Generic;
using System.IO;

IEnumerable<T>Interfejs jest zdefiniowany w System.Collections.Generic przestrzeni nazw.The IEnumerable<T> interface is defined in the System.Collections.Generic namespace. FileKlasa jest zdefiniowana w System.IO przestrzeni nazw.The File class is defined in the System.IO namespace.

Ta metoda jest specjalnym typem metody języka C# zwanej metodą iteratora.This method is a special type of C# method called an Iterator method. Metody modułu wyliczającego zwracają sekwencje zwracające opóźnieniem.Enumerator methods return sequences that are evaluated lazily. Oznacza to, że każdy element w sekwencji jest generowany w miarę żądania przez kod korzystający z sekwencji.That means each item in the sequence is generated as it is requested by the code consuming the sequence. Metody modułu wyliczającego to metody, które zawierają jedną lub więcej yield return instrukcji.Enumerator methods are methods that contain one or more yield return statements. Obiekt zwrócony przez ReadFrom metodę zawiera kod generujący każdy element w sekwencji.The object returned by the ReadFrom method contains the code to generate each item in the sequence. W tym przykładzie, który obejmuje odczytywanie następnego wiersza tekstu z pliku źródłowego i zwracanie tego ciągu.In this example, that involves reading the next line of text from the source file, and returning that string. Za każdym razem, gdy wywołujący kod żąda następnego elementu z sekwencji, kod odczytuje następny wiersz tekstu z pliku i zwraca go.Each time the calling code requests the next item from the sequence, the code reads the next line of text from the file and returns it. Gdy plik jest całkowicie odczytywany, sekwencja wskazuje, że nie ma więcej elementów.When the file is completely read, the sequence indicates that there are no more items.

Istnieją dwa inne elementy składni języka C#, które mogą być nowe dla Ciebie.There are two other C# syntax elements that may be new to you. usingInstrukcja w tej metodzie zarządza oczyszczaniem zasobów.The using statement in this method manages resource cleanup. Zmienna, która została zainicjowana w using instrukcji ( reader w tym przykładzie) musi implementować IDisposable interfejs.The variable that is initialized in the using statement (reader, in this example) must implement the IDisposable interface. Ten interfejs definiuje pojedynczą metodę, Dispose która powinna być wywoływana, gdy zasób powinien zostać wyznaczony.That interface defines a single method, Dispose, that should be called when the resource should be released. Kompilator generuje to wywołanie, gdy wykonanie osiągnie zamykający nawias klamrowy using instrukcji.The compiler generates that call when execution reaches the closing brace of the using statement. Kod wygenerowany przez kompilator zapewnia, że zasób jest wydawany nawet wtedy, gdy wyjątek jest zgłaszany z kodu w bloku zdefiniowanym przez instrukcję using.The compiler-generated code ensures that the resource is released even if an exception is thrown from the code in the block defined by the using statement.

readerZmienna jest definiowana przy użyciu var słowa kluczowego.The reader variable is defined using the var keyword. var definiuje niejawnie wpisaną zmienną lokalną.var defines an implicitly typed local variable. Oznacza to, że typ zmiennej jest określany przez typ czasu kompilacji obiektu przypisanego do zmiennej.That means the type of the variable is determined by the compile-time type of the object assigned to the variable. Tutaj jest to wartość zwracana z OpenText(String) metody, która jest StreamReader obiektem.Here, that is the return value from the OpenText(String) method, which is a StreamReader object.

Teraz uzupełnimy kod w celu odczytania pliku w Main metodzie:Now, let's fill in the code to read the file in the Main method:

var lines = ReadFrom("sampleQuotes.txt");
foreach (var line in lines)
{
    Console.WriteLine(line);
}

Uruchom program (za pomocą programu dotnet run ) i zobaczysz, że każdy wiersz został wydrukowany w konsoli programu.Run the program (using dotnet run) and you can see every line printed out to the console.

Dodawanie opóźnień i formatowanie danych wyjściowychAdding Delays and Formatting output

Zawartość jest zbyt szybka, aby można ją było odczytać.What you have is being displayed far too fast to read aloud. Teraz musisz dodać opóźnienia w danych wyjściowych.Now you need to add the delays in the output. Po rozpoczęciu będziesz kompilować część kodu podstawowego, który umożliwia przetwarzanie asynchroniczne.As you start, you'll be building some of the core code that enables asynchronous processing. Jednak te pierwsze kroki będą zgodne z kilkoma wzorcami.However, these first steps will follow a few anti-patterns. Wzorce są podkreślane w komentarzach podczas dodawania kodu, a kod zostanie zaktualizowany w dalszych krokach.The anti-patterns are pointed out in comments as you add the code, and the code will be updated in later steps.

Ta sekcja zawiera dwa kroki.There are two steps to this section. Najpierw należy zaktualizować metodę iteratora w celu zwrócenia pojedynczych słów zamiast całych wierszy.First, you'll update the iterator method to return single words instead of entire lines. Jest to wykonywane z tymi modyfikacjami.That's done with these modifications. Zastąp yield return line; instrukcję następującym kodem:Replace the yield return line; statement with the following code:

var words = line.Split(' ');
foreach (var word in words)
{
    yield return word + " ";
}
yield return Environment.NewLine;

Następnie należy zmodyfikować sposób korzystania z wierszy pliku i dodać opóźnienie po zapisaniu każdego wyrazu.Next, you need to modify how you consume the lines of the file, and add a delay after writing each word. Zamień Console.WriteLine(line) instrukcję w Main metodzie na następujący blok:Replace the Console.WriteLine(line) statement in the Main method with the following block:

Console.Write(line);
if (!string.IsNullOrWhiteSpace(line))
{
    var pause = Task.Delay(200);
    // Synchronously waiting on a task is an
    // anti-pattern. This will get fixed in later
    // steps.
    pause.Wait();
}

TaskKlasa znajduje się w System.Threading.Tasks przestrzeni nazw, dlatego należy dodać tę using instrukcję na początku pliku:The Task class is in the System.Threading.Tasks namespace, so you need to add that using statement at the top of file:

using System.Threading.Tasks;

Uruchom przykład i sprawdź dane wyjściowe.Run the sample, and check the output. Teraz każdy pojedynczy wyraz jest drukowany, po którym następuje opóźnienie 200 ms.Now, each single word is printed, followed by a 200 ms delay. Jednak wyświetlane dane wyjściowe pokazują pewne problemy, ponieważ źródłowy plik tekstowy ma kilka wierszy, które mają więcej niż 80 znaków bez przerwy w wierszu.However, the displayed output shows some issues because the source text file has several lines that have more than 80 characters without a line break. Może to być trudne do odczytania podczas przewijania przez program.That can be hard to read while it's scrolling by. Jest to łatwe do naprawienia.That's easy to fix. Będziesz śledzić długość każdego wiersza i generować nowy wiersz zawsze, gdy długość wiersza osiągnie określony próg.You'll just keep track of the length of each line, and generate a new line whenever the line length reaches a certain threshold. Zadeklaruj zmienną lokalną po deklaracji words ReadFrom metody, która posiada długość wiersza:Declare a local variable after the declaration of words in the ReadFrom method that holds the line length:

var lineLength = 0;

Następnie Dodaj następujący kod po yield return word + " "; instrukcji (przed zamykającym nawiasem klamrowym):Then, add the following code after the yield return word + " "; statement (before the closing brace):

lineLength += word.Length + 1;
if (lineLength > 70)
{
    yield return Environment.NewLine;
    lineLength = 0;
}

Uruchom próbkę i będzie można odczytywać na głos ze wstępnie skonfigurowanym tempem.Run the sample, and you'll be able to read aloud at its pre-configured pace.

Zadania asynchroniczneAsync Tasks

W tym ostatnim kroku dodasz kod, aby zapisać dane wyjściowe asynchronicznie w jednym zadaniu, a jednocześnie uruchomić inne zadanie odczytujące dane wejściowe od użytkownika, jeśli chcesz przyspieszyć lub spowolnić wyświetlanie tekstu lub zatrzymać wyświetlanie tekstu.In this final step, you'll add the code to write the output asynchronously in one task, while also running another task to read input from the user if they want to speed up or slow down the text display, or stop the text display altogether. Obejmuje to kilka kroków i zakończenie, które będą potrzebne do wszystkich niezbędnych aktualizacji.This has a few steps in it and by the end, you'll have all the updates that you need. Pierwszym krokiem jest utworzenie asynchronicznej Task metody zwracającej, która reprezentuje kod, który został utworzony do odczytu i wyświetlenia pliku.The first step is to create an asynchronous Task returning method that represents the code you've created so far to read and display the file.

Dodaj tę metodę do Program klasy (jest ona pobierana z treści Main metody):Add this method to your Program class (it's taken from the body of your Main method):

private static async Task ShowTeleprompter()
{
    var words = ReadFrom("sampleQuotes.txt");
    foreach (var word in words)
    {
        Console.Write(word);
        if (!string.IsNullOrWhiteSpace(word))
        {
            await Task.Delay(200);
        }
    }
}

Zauważysz dwie zmiany.You'll notice two changes. Po pierwsze, w treści metody, zamiast wywołania Wait() synchronicznie oczekiwanie na zakończenie zadania, ta wersja używa await słowa kluczowego.First, in the body of the method, instead of calling Wait() to synchronously wait for a task to finish, this version uses the await keyword. Aby to zrobić, należy dodać async modyfikator do sygnatury metody.In order to do that, you need to add the async modifier to the method signature. Ta metoda zwraca Task .This method returns a Task. Zwróć uwagę, że nie ma instrukcji return zwracających Task obiekt.Notice that there are no return statements that return a Task object. Zamiast tego ten Task obiekt jest tworzony przez kod, który kompilator generuje podczas korzystania z await operatora.Instead, that Task object is created by code the compiler generates when you use the await operator. Można Wyobraź sobie, że ta metoda zwraca, gdy osiągnie await .You can imagine that this method returns when it reaches an await. Zwracana wartość Task wskazuje, że pracę nie została ukończona.The returned Task indicates that the work has not completed. Metoda zostaje wznowiona po zakończeniu oczekiwania na zadanie.The method resumes when the awaited task completes. Po wykonaniu tej operacji zwrócona wartość Task wskazuje, że została zakończona.When it has executed to completion, the returned Task indicates that it is complete. Wywoływanie kodu może monitorować, który zwraca, Task Aby określić, kiedy został ukończony.Calling code can monitor that returned Task to determine when it has completed.

Tę nową metodę można wywołać w Main metodzie:You can call this new method in your Main method:

ShowTeleprompter().Wait();

W tym miejscu Main kod wykonuje synchronicznie oczekiwania.Here, in Main, the code does synchronously wait. awaitJeśli to możliwe, należy użyć operatora zamiast synchronicznego oczekiwania.You should use the await operator instead of synchronously waiting whenever possible. Ale w metodzie aplikacji konsolowej Main nie można używać await operatora.But, in a console application's Main method, you cannot use the await operator. Spowoduje to zakończenie działania aplikacji przed ukończeniem wszystkich zadań.That would result in the application exiting before all tasks have completed.

Uwaga

Jeśli używasz języka C# 7,1 lub nowszego, możesz tworzyć aplikacje konsolowe za pomocą async Main metody.If you use C# 7.1 or later, you can create console applications with async Main method.

Następnie należy napisać drugą metodę asynchroniczną w celu odczytania z konsoli i obserwowania dla "<" (mniejszej niż), ">" (większe niż) i "X" lub "x".Next, you need to write the second asynchronous method to read from the Console and watch for the '<' (less than), '>' (greater than) and 'X' or 'x' keys. Oto Metoda dodawana do tego zadania:Here's the method you add for that task:

private static async Task GetInput()
{
    var delay = 200;
    Action work = () =>
    {
        do {
            var key = Console.ReadKey(true);
            if (key.KeyChar == '>')
            {
                delay -= 10;
            }
            else if (key.KeyChar == '<')
            {
                delay += 10;
            }
            else if (key.KeyChar == 'X' || key.KeyChar == 'x')
            {
                break;
            }
        } while (true);
    };
    await Task.Run(work);
}

Spowoduje to utworzenie wyrażenia lambda do reprezentowania Action delegata, który odczytuje klucz z konsoli programu i modyfikuje zmienną lokalną reprezentującą opóźnienie, gdy użytkownik naciśnie klawisz "<" (mniej niż) lub ">" (większy niż).This creates a lambda expression to represent an Action delegate that reads a key from the Console and modifies a local variable representing the delay when the user presses the '<' (less than) or '>' (greater than) keys. Metoda Delegate kończy się, gdy użytkownik naciśnie klawisze "X" lub "x", które umożliwiają użytkownikowi zatrzymanie wyświetlania tekstu w dowolnym momencie.The delegate method finishes when user presses the 'X' or 'x' keys, which allow the user to stop the text display at any time. Ta metoda używa ReadKey() do blokowania i poczekania użytkownika o naciśnięcie klawisza.This method uses ReadKey() to block and wait for the user to press a key.

Aby zakończyć tę funkcję, należy utworzyć nową async Task metodę zwracającą, która uruchamia oba te zadania ( GetInput i ShowTeleprompter ), a także zarządza danymi udostępnionymi między tymi dwoma zadaniami.To finish this feature, you need to create a new async Task returning method that starts both of these tasks (GetInput and ShowTeleprompter), and also manages the shared data between these two tasks.

Czas na utworzenie klasy, która może obsługiwać udostępnione dane między tymi dwoma zadaniami.It's time to create a class that can handle the shared data between these two tasks. Ta klasa zawiera dwie właściwości publiczne: opóźnienie i flagę Done wskazującą, że plik został całkowicie odczytany:This class contains two public properties: the delay, and a flag Done to indicate that the file has been completely read:

namespace TeleprompterConsole
{
    internal class TelePrompterConfig
    {
        public int DelayInMilliseconds { get; private set; } = 200;

        public void UpdateDelay(int increment) // negative to speed up
        {
            var newDelay = Min(DelayInMilliseconds + increment, 1000);
            newDelay = Max(newDelay, 20);
            DelayInMilliseconds = newDelay;
        }

        public bool Done { get; private set; }

        public void SetDone()
        {
            Done = true;
        }
    }
}

Umieść tę klasę w nowym pliku i umieść ją w TeleprompterConsole przestrzeni nazw, jak pokazano powyżej.Put that class in a new file, and enclose that class in the TeleprompterConsole namespace as shown above. Należy również dodać using static instrukcję, aby można było odwoływać się do Min Max metod i bez nazwy klasy lub przestrzeni nazw.You'll also need to add a using static statement so that you can reference the Min and Max methods without the enclosing class or namespace names. using staticInstrukcja importuje metody z jednej klasy.A using static statement imports the methods from one class. Jest to w przeciwieństwie do using instrukcji używanych do tego punktu, który zaimportował wszystkie klasy z przestrzeni nazw.This is in contrast with the using statements used up to this point that have imported all classes from a namespace.

using static System.Math;

Następnie należy zaktualizować ShowTeleprompter metody i, GetInput Aby użyć nowego config obiektu.Next, you need to update the ShowTeleprompter and GetInput methods to use the new config object. Napisz jedną ostateczną Task metodę zwracającą async , aby uruchomić oba zadania i wyjść po zakończeniu pierwszego zadania:Write one final Task returning async method to start both tasks and exit when the first task finishes:

private static async Task RunTeleprompter()
{
    var config = new TelePrompterConfig();
    var displayTask = ShowTeleprompter(config);

    var speedTask = GetInput(config);
    await Task.WhenAny(displayTask, speedTask);
}

Ta nowa metoda to WhenAny(Task[]) wywołanie.The one new method here is the WhenAny(Task[]) call. Spowoduje to utworzenie Task , który zakończy się zaraz po zakończeniu wszystkich zadań na liście argumentów.That creates a Task that finishes as soon as any of the tasks in its argument list completes.

Następnie należy zaktualizować ShowTeleprompter metody i, GetInput Aby użyć config obiektu dla opóźnienia:Next, you need to update both the ShowTeleprompter and GetInput methods to use the config object for the delay:

private static async Task ShowTeleprompter(TelePrompterConfig config)
{
    var words = ReadFrom("sampleQuotes.txt");
    foreach (var word in words)
    {
        Console.Write(word);
        if (!string.IsNullOrWhiteSpace(word))
        {
            await Task.Delay(config.DelayInMilliseconds);
        }
    }
    config.SetDone();
}

private static async Task GetInput(TelePrompterConfig config)
{
    Action work = () =>
    {
        do {
            var key = Console.ReadKey(true);
            if (key.KeyChar == '>')
                config.UpdateDelay(-10);
            else if (key.KeyChar == '<')
                config.UpdateDelay(10);
            else if (key.KeyChar == 'X' || key.KeyChar == 'x')
                config.SetDone();
        } while (!config.Done);
    };
    await Task.Run(work);
}

Ta nowa wersja ShowTeleprompter wywołuje nową metodę w TeleprompterConfig klasie.This new version of ShowTeleprompter calls a new method in the TeleprompterConfig class. Teraz musisz zaktualizować Main do wywołania RunTeleprompter zamiast ShowTeleprompter :Now, you need to update Main to call RunTeleprompter instead of ShowTeleprompter:

RunTeleprompter().Wait();

PodsumowanieConclusion

W tym samouczku pokazano kilka funkcji języka C# i bibliotek .NET Core związanych z pracą w aplikacjach konsolowych.This tutorial showed you a number of the features around the C# language and the .NET Core libraries related to working in Console applications. Możesz utworzyć tę wiedzę, aby dowiedzieć się więcej o języku i klasach wprowadzonych w tym miejscu.You can build on this knowledge to explore more about the language, and the classes introduced here. Zaobserwowano podstawowe informacje na temat operacji we/wy na plikach i konsoli, blokowanie i nieblokowanie użycia programowania asynchronicznego opartego na zadaniach, przewodnik po języku C# oraz sposób organizowania programów w języku C# oraz interfejs wiersza polecenia platformy .NET Core.You've seen the basics of File and Console I/O, blocking and non-blocking use of the Task-based asynchronous programming, a tour of the C# language and how C# programs are organized, and the .NET Core CLI.

Aby uzyskać więcej informacji na temat operacji we/wy plików, zobacz temat plik i strumień we/wy .For more information about File I/O, see the File and Stream I/O topic. Aby uzyskać więcej informacji o modelu programowania asynchronicznego używanym w tym samouczku, zapoznaj się z tematem programowanie asynchroniczne oparte na zadaniach i w temacie programowanie asynchroniczne .For more information about asynchronous programming model used in this tutorial, see the Task-based Asynchronous Programming topic and the Asynchronous programming topic.