Tutorial: Besseres Ausdrücken Ihrer Entwurfsabsicht mit Verweistypen, die NULL-Werte zulassen und nicht zulassenTutorial: Express your design intent more clearly with nullable and non-nullable reference types

C# 8.0 führt Nullable-Verweistypen ein, die Verweistypen auf die gleiche Weise ergänzen, wie Nullable-Werttypen Werttypen ergänzen.C# 8.0 introduces nullable reference types, which complement reference types the same way nullable value types complement value types. Sie deklarieren eine Variable zu einem Verweistyp, der NULL-Werte zulässt, indem Sie ? an den Typen anfügen.You declare a variable to be a nullable reference type by appending a ? to the type. Beispielsweise stellt string? eine string dar, die NULL-Werte zulässt.For example, string? represents a nullable string. Mit diesen neuen Typen können Sie Ihre Entwurfsabsicht besser zum Ausdruck bringen: Einige Variablen müssen immer einen Wert haben, bei anderen kann ein Wert fehlen.You can use these new types to more clearly express your design intent: some variables must always have a value, others may be missing a value.

In diesem Tutorial lernen Sie, wie die folgenden Aufgaben ausgeführt werden:In this tutorial, you'll learn how to:

  • Integrieren von Verweistypen, die NULL-Werte zulassen und nicht zulassen, in Ihre Entwürfe.Incorporate nullable and non-nullable reference types into your designs
  • Aktivieren von Überprüfungen Ihres Verweistypen, der NULL-Werte zulässt, anhand Ihres Codes.Enable nullable reference type checks throughout your code.
  • Schreiben von Code, bei dem ein Compiler diese Entwurfsentscheidungen erzwingt.Write code where the compiler enforces those design decisions.
  • Verwenden des Verweisfeatures, das NULL-Werte zulässt, in Ihren eigenen Entwürfen.Use the nullable reference feature in your own designs

Erforderliche KomponentenPrerequisites

Sie müssen Ihren Computer zur Ausführung von .NET Core einrichten, einschließlich des C# 8.0-Compilers.You'll need to set up your machine to run .NET Core, including the C# 8.0 compiler. Der C# 8.0-Compiler ist mit Visual Studio 2019 oder .NET Core 3.0 verfügbar.The C# 8.0 compiler is available with Visual Studio 2019, or .NET Core 3.0.

In diesem Tutorial wird vorausgesetzt, dass Sie C# und .NET, einschließlich Visual Studio oder die .NET Core-CLI kennen.This tutorial assumes you're familiar with C# and .NET, including either Visual Studio or the .NET Core CLI.

Integrieren von Verweistypen, die NULL-Werte zulassen, in Ihre EntwürfeIncorporate nullable reference types into your designs

In diesem Tutorial erstellen Sie eine Bibliothek, die die Ausführung einer Umfrage modelliert.In this tutorial, you'll build a library that models running a survey. Der Code verwendet Verweistypen, die NULL-Werte zulassen bzw. nicht zulassen, zur Darstellung der realen Konzepte.The code uses both nullable reference types and non-nullable reference types to represent the real-world concepts. Die Fragen in der Umfrage können nie NULL sein.The survey questions can never be null. Ein Befragter möchte eine Frage möglicherweise nicht beantworten.A respondent might prefer not to answer a question. In diesem Fall können die Antworten null sein.The responses might be null in this case.

Der Code, den Sie für dieses Beispiel schreiben, drückt diese Absicht aus, und der Compiler setzt sie durch.The code you'll write for this sample expresses that intent, and the compiler enforces that intent.

Erstellen der Anwendung und Aktivieren der Verweistypen, die NULL-Werte zulassenCreate the application and enable nullable reference types

Erstellen Sie eine neue Konsolenanwendung in Visual Studio oder über die Befehlszeile mit dotnet new console.Create a new console application either in Visual Studio or from the command line using dotnet new console. Nennen Sie die Anwendung NullableIntroduction.Name the application NullableIntroduction. Nachdem Sie die Anwendung erstellt haben, müssen Sie angeben, dass das gesamte Projekt in einem aktivierten Nullable-Anmerkungskontext kompiliert wird.Once you've created the application, you'll need to specify that the entire project compiles in an enabled nullable annotation context. Öffnen Sie die CSPROJ-Datei, und fügen Sie dem PropertyGroup-Element ein Nullable-Element hinzu.Open the .csproj file and add a Nullable element to the PropertyGroup element. Legen Sie den Wert der Eigenschaft auf enablefest.Set its value to enable. Selbst in C# 8.0-Projekten müssen Sie das Feature für Nullable-Verweistypen aktivieren.You must opt into the nullable reference types feature, even in C# 8.0 projects. Grund dafür ist, dass bestehende Verweisvariablendeklarationen nach dem Aktivieren des Features zu Verweistypen werden, die NULL-Werte nicht zulassen.That's because once the feature is turned on, existing reference variable declarations become non-nullable reference types. Diese Entscheidung ist zwar hilfreich, um Probleme zu finden, bei denen bestehender Code möglicherweise keine ordnungsgemäßen NULL-Überprüfungen aufweist, aber möglicherweise spiegelt sie nicht genau Ihre ursprüngliche Entwurfsabsicht wider.While that decision will help find issues where existing code may not have proper null-checks, it may not accurately reflect your original design intent:

<Nullable>enable</Nullable>

Entwerfen der Typen für die AnwendungDesign the types for the application

Für diese Umfrageanwendung müssen einige Klassen erstellt werden:This survey application requires creating a number of classes:

  • Eine Klasse, die die Liste der Fragen modelliert.A class that models the list of questions.
  • Eine Klasse, die eine Liste der Personen modelliert, die für die Umfrage kontaktiert werden.A class that models a list of people contacted for the survey.
  • Eine Klasse, die die Antworten einer Person modelliert, die an der Umfrage teilgenommen hat.A class that models the answers from a person that took the survey.

Diese Typen verwenden Verweistypen, die NULL-Werte sowohl zulassen als auch nicht zulassen, um auszudrücken, welche Member erforderlich und welche optional sind.These types will make use of both nullable and non-nullable reference types to express which members are required and which members are optional. Verweistypen, die NULL-Werte zulassen, kommunizieren diese Entwurfsabsicht eindeutig:Nullable reference types communicate that design intent clearly:

  • Die Fragen, die Teil der Umfrage sind, können nie NULL sein. Es ist nicht sinnvoll, eine leere Frage zu stellen.The questions that are part of the survey can never be null: It makes no sense to ask an empty question.
  • Die Befragten können nie NULL sein.The respondents can never be null. Sie werden sicher die Personen nachverfolgen wollen, mit denen Sie Kontakt aufgenommen haben, sogar die Personen, die die Teilnahme abgelehnt haben.You'll want to track people you contacted, even respondents that declined to participate.
  • Jede Antwort auf eine Frage darf NULL sein.Any response to a question may be null. Befragten können es ablehnen, einige oder alle Fragen zu beantworten.Respondents can decline to answer some or all questions.

Wenn Sie in C# programmiert haben, sind Sie vielleicht so sehr an Verweistypen gewöhnt, die null-Werte zulassen, dass Sie andere Möglichkeiten verpasst haben, Instanzen zu deklarieren, die NULL-Werte nicht zulassen:If you've programmed in C#, you may be so accustomed to reference types that allow null values that you may have missed other opportunities to declare non-nullable instances:

  • Die Auflistung der Fragen sollte keine NULL-Werte zulassen.The collection of questions should be non-nullable.
  • Die Auflistung der Antworten sollte keine NULL-Werte zulassen.The collection of respondents should be non-nullable.

Wenn Sie den Code schreiben, werden Sie Folgendes feststellen: Indem Sie für Verweise standardmäßig einen Verweistyp verwenden, der keine NULL-Werte zulässt, lassen sich häufige Fehler vermeiden, die zu NullReferenceException-Ergebnissen führen können.As you write the code, you'll see that a non-nullable reference type as the default for references avoids common mistakes that could lead to NullReferenceExceptions. Eine Lektion aus diesem Tutorial ist, dass Sie entschieden haben, welche Variablen null sein könnten oder nicht.One lesson from this tutorial is that you made decisions about which variables could or could not be null. Die Sprache bot keine Syntax, um diese Entscheidungen auszudrücken.The language didn't provide syntax to express those decisions. Jetzt ist es möglich.Now it does.

Die von Ihnen erstellte App führt die folgenden Schritte aus:The app you'll build does the following steps:

  1. Erstellen einer Umfrage und Hinzufügen von Fragen.Creates a survey and adds questions to it.
  2. Erstellen eines pseudozufälligen Satzes von Befragten für die Umfrage.Creates a pseudo-random set of respondents for the survey.
  3. Kontaktieren der Befragten, bis die Anzahl der abgeschlossen Umfragen den Zielwert erreicht hat.Contacts respondents until the completed survey size reaches the goal number.
  4. Erstellen wichtiger Statistiken zu den Antworten.Writes out important statistics on the survey responses.

Erstellen einer Umfrage mit Typen, die NULL-Werte zulassen und nicht zulassen.Build the survey with nullable and non-nullable types

Mit dem ersten geschriebenen Code erstellen Sie die Umfrage.The first code you'll write creates the survey. Sie schreiben die Klassen, um eine Frage der Umfrage und eine Ausführung zu modellieren.You'll write classes to model a survey question and a survey run. Ihre Umfrage umfasst drei Arten von Fragen, die sich durch das Format der Antwort unterscheiden: Ja/Nein-Antworten, Zahlenantworten und Textantworten.Your survey has three types of questions, distinguished by the format of the answer: Yes/No answers, number answers, and text answers. Erstellen Sie eine public SurveyQuestion-Klasse:Create a public SurveyQuestion class:

namespace NullableIntroduction
{
    public class SurveyQuestion
    {
    }
}

Der Compiler interpretiert jede Verweistyp-Variablendeklaration für Code in einem aktivierten Nullable-Anmerkungskontext als Nicht-Nullable-Verweistyp.The compiler interprets every reference type variable declaration as a non-nullable reference type for code in an enabled nullable annotation context. Sie können Ihre erste Warnung sehen, indem Sie Eigenschaften für den Fragetext und die Art der Frage hinzufügen, wie im folgenden Code gezeigt:You can see your first warning by adding properties for the question text and the type of question, as shown in the following code:

namespace NullableIntroduction
{
    public enum QuestionType
    {
        YesNo,
        Number,
        Text
    }

    public class SurveyQuestion
    {
        public string QuestionText { get; }
        public QuestionType TypeOfQuestion { get; }
    }
}

Da Sie QuestionText noch nicht initialisiert haben, gibt der Compiler eine Warnung aus, dass noch keine Eigenschaft initialisiert wurde, nicht keine NULL-Werte zulässt.Because you haven't initialized QuestionText, the compiler issues a warning that a non-nullable property hasn't been initialized. Ihr Entwurf verlangt, dass der Fragetext nicht null ist. Also fügen Sie einen Konstruktor zur Initialisierung und den Wert QuestionType hinzu.Your design requires the question text to be non-null, so you add a constructor to initialize it and the QuestionType value as well. Die fertige Klassendefinition sieht wie im folgenden Code aus:The finished class definition looks like the following code:

namespace NullableIntroduction
{
    public enum QuestionType
    {
        YesNo,
        Number,
        Text
    }

    public class SurveyQuestion
    {
        public string QuestionText { get; }
        public QuestionType TypeOfQuestion { get; }

        public SurveyQuestion(QuestionType typeOfQuestion, string text) =>
            (TypeOfQuestion, QuestionText) = (typeOfQuestion, text);
    }
}

Durch das Hinzufügen des Konstruktors wird die Warnung entfernt.Adding the constructor removes the warning. Das Konstruktorargument ebenfalls ein Verweistyp, der keine NULL-Werte zulässt. Der Compiler gibt also keine Warnungen aus.The constructor argument is also a non-nullable reference type, so the compiler doesn't issue any warnings.

Erstellen Sie eine public-Klasse mit dem Namen SurveyRun.Next, create a public class named SurveyRun. Diese Klasse enthält eine Liste von SurveyQuestion-Objekten und Methoden, um Fragen zur Umfrage hinzuzufügen, wie im folgenden Code gezeigt:This class contains a list of SurveyQuestion objects and methods to add questions to the survey, as shown in the following code:

using System.Collections.Generic;

namespace NullableIntroduction
{
    public class SurveyRun
    {
        private List<SurveyQuestion> surveyQuestions = new List<SurveyQuestion>();

        public void AddQuestion(QuestionType type, string question) =>
            AddQuestion(new SurveyQuestion(type, question));
        public void AddQuestion(SurveyQuestion surveyQuestion) => surveyQuestions.Add(surveyQuestion);
    }
}

Wie bisher müssen Sie das Listenobjekt Wert initialisieren, der keine NULL-Werte zulässt, oder der Compiler gibt eine Warnung aus.As before, you must initialize the list object to a non-null value or the compiler issues a warning. Es gibt keine NULL-Überprüfungen in der zweiten Überladung von AddQuestion, da sie nicht benötigt werden: Sie haben diese Variable als Typ deklariert, der keine NULL-Werte zulässt.There are no null checks in the second overload of AddQuestion because they aren't needed: You've declared that variable to be non-nullable. Der Wert kann nicht null sein.Its value can't be null.

Wechseln Sie in Ihrem Editor zu Program.cs, und ersetzen Sie den Inhalt von Main durch die folgenden Codezeilen:Switch to Program.cs in your editor and replace the contents of Main with the following lines of code:

var surveyRun = new SurveyRun();
surveyRun.AddQuestion(QuestionType.YesNo, "Has your code ever thrown a NullReferenceException?");
surveyRun.AddQuestion(new SurveyQuestion(QuestionType.Number, "How many times (to the nearest 100) has that happened?"));
surveyRun.AddQuestion(QuestionType.Text, "What is your favorite color?");

Da sich das gesamte Projekt in einem aktivierten Nullable-Anmerkungskontext befindet, erhalten Sie Warnungen, wenn Sie null in Erwartung eines Nicht-Nullable-Verweistyps an eine Methode übergeben.Because the entire project is in an enabled nullable annotation context, you'll get warnings when you pass null to any method expecting a non-nullable reference type. Probieren Sie es aus, indem Sie die folgende Zeile zu Main hinzufügen:Try it by adding the following line to Main:

surveyRun.AddQuestion(QuestionType.Text, default);

Erstellen von Befragten und Erhalten von Antworten zur UmfrageCreate respondents and get answers to the survey

Schreiben Sie als Nächstes den Code, der Antworten für die Umfrage generiert.Next, write the code that generates answers to the survey. Dieser Prozess umfasst mehrere kleine Aufgaben:This process involves several small tasks:

  1. Erstellen Sie eine Methode, die Antwortobjekte generiert.Build a method that generates respondent objects. Diese repräsentieren die Personen, die um das Ausfüllen der Umfrage gebeten werden.These represent people asked to fill out the survey.
  2. Erstellen Sie eine Logik, um zu simulieren, dass Sie die Fragen an einen Befragten stellen und Antworten sammeln, oder feststellen, dass ein Befragter nicht geantwortet hat.Build logic to simulate asking the questions to a respondent and collecting answers or noting that a respondent didn't answer.
  3. Wiederholen Sie den Vorgang, bis genügend Befragten an der Umfrage teilgenommen haben.Repeat until enough respondents have answered the survey.

Sie benötigen eine Klasse zum Darstellen einer Umfrageantwort. Fügen Sie diese jetzt hinzu.You'll need a class to represent a survey response, so add that now. Aktivieren Sie Support für NULL-Werte.Enable nullable support. Fügen Sie eine Id-Eigenschaft und einen Konstruktor hinzu, der diese initialisiert, wie in folgendem Code dargestellt:Add an Id property and a constructor that initializes it, as shown in the following code:

namespace NullableIntroduction
{
    public class SurveyResponse
    {
        public int Id { get; }

        public SurveyResponse(int id) => Id = id;
    }
}

Fügen Sie als Nächstes eine static-Methode hinzu, um neuen Teilnehmer zu erstellen, indem Sie eine Zufalls-ID generieren:Next, add a static method to create new participants by generating a random ID:

private static readonly Random randomGenerator = new Random();
public static SurveyResponse GetRandomId() => new SurveyResponse(randomGenerator.Next());

Die Hauptaufgabe dieser Klasse besteht darin, die Antworten für einen Teilnehmer auf die Fragen der Umfrage zu generieren.The main responsibility of this class is to generate the responses for a participant to the questions in the survey. Diese Aufgabe umfasst einige Schritte:This responsibility has a few steps:

  1. Bitten Sie um die Teilnahme an der Umfrage.Ask for participation in the survey. Wenn eine Person nicht einverstanden ist, geben Sie eine fehlende (oder Null) Antwort zurück.If the person doesn't consent, return a missing (or null) response.
  2. Stellen Sie die einzelnen Fragen, und notieren Sie die Antwort.Ask each question and record the answer. Jede Antwort kann auch nicht vorhanden (oder null) sein.Each answer may also be missing (or null).

Fügen Sie der SurveyResponse-Klasse den folgenden Code hinzu:Add the following code to your SurveyResponse class:

private Dictionary<int, string>? surveyResponses;
public bool AnswerSurvey(IEnumerable<SurveyQuestion> questions)
{
    if (ConsentToSurvey())
    {
        surveyResponses = new Dictionary<int, string>();
        int index = 0;
        foreach (var question in questions)
        {
            var answer = GenerateAnswer(question);
            if (answer != null)
            {
                surveyResponses.Add(index, answer);
            }
            index++;
        }
    }
    return surveyResponses != null;
}

private bool ConsentToSurvey() => randomGenerator.Next(0, 2) == 1;

private string? GenerateAnswer(SurveyQuestion question)
{
    switch (question.TypeOfQuestion)
    {
        case QuestionType.YesNo:
            int n = randomGenerator.Next(-1, 2);
            return (n == -1) ? default : (n == 0) ? "No" : "Yes";
        case QuestionType.Number:
            n = randomGenerator.Next(-30, 101);
            return (n < 0) ? default : n.ToString();
        case QuestionType.Text:
        default:
            switch (randomGenerator.Next(0, 5))
            {
                case 0:
                    return default;
                case 1:
                    return "Red";
                case 2:
                    return "Green";
                case 3:
                    return "Blue";
            }
            return "Red. No, Green. Wait.. Blue... AAARGGGGGHHH!";
    }
}

Der Speicher für Umfrageantworten ist eine Dictionary<int, string>?. Damit wird angegeben, dass auch NULL zulässig ist.The storage for the survey answers is a Dictionary<int, string>?, indicating that it may be null. Sie verwenden das neue Sprachfeature, um Ihre Entwurfsabsicht zu deklarieren, sowohl gegenüber dem Compiler als auch gegenüber allen, die Ihren Code später lesen.You're using the new language feature to declare your design intent, both to the compiler and to anyone reading your code later. Wenn Sie jemals surveyResponses dereferenzieren, ohne zuerst nach dem null-Wert zu suchen, erhalten Sie eine Compilerwarnung.If you ever dereference surveyResponses without checking for the null value first, you'll get a compiler warning. Sie erhalten keine Warnung in der AnswerSurvey-Methode, da der Compiler bestimmen kann, dass die Variable surveyResponses oben auf einen Wert gesetzt wurde, der NULL-Werte zulässt.You don't get a warning in the AnswerSurvey method because the compiler can determine the surveyResponses variable was set to a non-null value above.

Die Verwendung von null für fehlende Antworten hebt einen wichtigen Punkt für die Arbeit mit NULL-Werte zulassenden Verweistypen hervor: Ihr Ziel ist nicht, alle null-Werte aus Ihrem Programm zu entfernen.Using null for missing answers highlights a key point for working with nullable reference types: your goal isn't to remove all null values from your program. Ihr Ziel ist eher, sicherzustellen, dass der Code, den Sie schreiben, Ihre Entwurfsabsicht ausdrückt.Rather, your goal is to ensure that the code you write expresses the intent of your design. Fehlende Werte sind ein notwendiges in Ihrem Code auszudrückendes Konzept.Missing values are a necessary concept to express in your code. Der null-Wert ist eine klare Möglichkeit, diese fehlenden Werte auszudrücken.The null value is a clear way to express those missing values. Der Versuch, alle null-Werte zu entfernen, führt nur zum Definieren einer anderen Möglichkeit, diese fehlenden Werte ohne null auszudrücken.Trying to remove all null values only leads to defining some other way to express those missing values without null.

Als Nächstes müssen Sie die PerformSurvey-Methode in der SurveyRun-Klasse schreiben.Next, you need to write the PerformSurvey method in the SurveyRun class. Fügen Sie den folgenden Code der SurveyRun-Klasse hinzu:Add the following code in the SurveyRun class:

private List<SurveyResponse>? respondents;
public void PerformSurvey(int numberOfRespondents)
{
    int repondentsConsenting = 0;
    respondents = new List<SurveyResponse>();
    while (repondentsConsenting < numberOfRespondents)
    {
        var respondent = SurveyResponse.GetRandomId();
        if (respondent.AnswerSurvey(surveyQuestions))
            repondentsConsenting++;
        respondents.Add(respondent);
    }
}

Auch hier geben Sie durch Ihre Auswahl von List<SurveyResponse>?, die NULL-Werte zulässt, dass die Antwort Null sein kann.Here again, your choice of a nullable List<SurveyResponse>? indicates the response may be null. Damit wird angegeben, dass die Umfrage noch keinem Befragten zugewiesen wurde.That indicates the survey hasn't been given to any respondents yet. Beachten Sie, dass Personen hinzugefügt werden, bis genügend zugestimmt haben.Notice that respondents are added until enough have consented.

Der letzte Schritt zum Ausführen der Umfrage besteht darin, einen Aufruf zur Durchführung der Umfrage am Ende der Main-Methode hinzuzufügen:The last step to run the survey is to add a call to perform the survey at the end of the Main method:

surveyRun.PerformSurvey(50);

Untersuchen von UmfrageantwortenExamine survey responses

Der letzte Schritt ist das Anzeigen von Umfrageergebnissen.The last step is to display survey results. Sie fügen Code zu vielen der Klassen hinzu, die Sie geschrieben haben.You'll add code to many of the classes you've written. Dieser Code demonstriert den Wert der Unterscheidung von Verweistypen, die NULL-Werte zulassen bzw. nicht zulassen.This code demonstrates the value of distinguishing nullable and non-nullable reference types. Beginnen Sie, indem Sie die zwei folgenden Ausdruckskörpermember zur SurveyResponse-Klasse hinzufügen:Start by adding the following two expression-bodied members to the SurveyResponse class:

public bool AnsweredSurvey => surveyResponses != null;
public string Answer(int index) => surveyResponses?.GetValueOrDefault(index) ?? "No answer";

Da surveyResponses ein Verweistyp ist, der NULL-Werte zulässt, sind vor dem Dereferenzieren NULL-Überprüfungen erforderlich.Because surveyResponses is a nullable reference type, null checks are necessary before de-referencing it. Die Answer-Methode gibt eine Zeichenfolge zurück, die keine NULL-Werte zulässt. Daher müssen wir durch die Verwendung des NULL-Sammeloperators den Fall abdecken, dass eine Antwort fehlt.The Answer method returns a non-nullable string, so we have to cover the case of a missing answer by using the null-coalescing operator.

Fügen Sie diese drei Ausdruckskörpermember zur SurveyRun-Klasse hinzu:Next, add these three expression-bodied members to the SurveyRun class:

public IEnumerable<SurveyResponse> AllParticipants => (respondents ?? Enumerable.Empty<SurveyResponse>());
public ICollection<SurveyQuestion> Questions => surveyQuestions;
public SurveyQuestion GetQuestion(int index) => surveyQuestions[index];

Das AllParticipants Member muss berücksichtigen, dass die respondents-Variable Null sein kann, der zurückgegebene Wert aber nicht Null sein darf.The AllParticipants member must take into account that the respondents variable might be null, but the return value can't be null. Wenn Sie diesen Ausdruck ändern, indem Sie ?? und die folgende leere Sequenz entfernen, warnt Sie der Compiler, dass die Methode null zurückgeben könnte, und ihre Rückgabesignatur gibt einen Typen zurück, der keine NULL-Werte zulässt.If you change that expression by removing the ?? and the empty sequence that follows, the compiler warns you the method might return null and its return signature returns a non-nullable type.

Fügen Sie abschließend die folgende Schleife am Ende der Main-Methode hinzu:Finally, add the following loop at the bottom of the Main method:

foreach (var participant in surveyRun.AllParticipants)
{
    Console.WriteLine($"Participant: {participant.Id}:");
    if (participant.AnsweredSurvey)
    {
        for (int i = 0; i < surveyRun.Questions.Count; i++)
        {
            var answer = participant.Answer(i);
            Console.WriteLine($"\t{surveyRun.GetQuestion(i)} : {answer}");
        }
    }
    else
        Console.WriteLine("\tNo responses");
}

Sie benötigen keine null-Überprüfungen in diesem Code, das Sie die darunter liegenden Schnittstellen so entworfen haben, dass sie alle einen Verweistypen zurückgeben, der keine NULL-Werte zulässt.You don't need any null checks in this code because you've designed the underlying interfaces so that they all return non-nullable reference types.

Abrufen des CodesGet the code

Sie können den Code für das abgeschlossene Tutorial aus unserem samples-Repository im Ordner csharp/NullableIntroduction abrufen.You can get the code for the finished tutorial from our samples repository in the csharp/NullableIntroduction folder.

Experimentieren Sie, indem Sie bei der Typdeklaration zwischen Verweistypen wechseln, die NULL-Werte zulassen bzw. nicht zulassen.Experiment by changing the type declarations between nullable and non-nullable reference types. Sehen Sie sich an, wie dabei verschiedene Warnungen erzeugt werden, um sicherzustellen, dass Sie nicht versehentlichnull dereferenzieren.See how that generates different warnings to ensure you don't accidentally dereference a null.

Nächste SchritteNext steps

Weitere Informationen erhalten Sie durch die Migration einer vorhandenen Anwendung zur Verwendung NULL-Werte zulassender Verweistypen:Learn more by migrating an existing application to use nullable reference types: