Shulou(Shulou.com)06/01 Report--

This article mainly explains "how to use C# nullable reference types". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn how to use C# nullable reference types.

Installation

You must download the preview version of Visual Studio 2017 (currently the latest release is 15.4)

Install the preview version of the Roslyn extension:

Download and extract Roslyn_Nullable_References_Preview.zip [latest version 11-15-17]

Close all running Visual Studio

Run the.\ install.bat script in the zip root directory (if you need to uninstall the extension, you can run the.\ uninstall.bat script)

Grammar and types

Syntactically, the syntax that can be used for a nullable reference type is the same as that for a nullable type, appended after the type? That's it.

Class Person {public string FirstName; public string? MiddleName; public string LastName;}

We all know that when Microsoft added nullable types, it actually added System.Nullable types to the framework, and you would certainly ask what new types were added to the framework for null reference types.

Let's look at a demonstration:

Class Program {static void Main (string [] args) {Console.WriteLine (typeof (string?) .FullName);}}

Output result:

Do you find it strange how the output is System.String? yes, Microsoft did not add any type to the framework. We compiled the Person type and decompiled it through dotPeek to understand what happened.

The result of decompilation:

Internal class Person {public string FirstName; [Nullable] public string MiddleName; public string LastName;}

It's just that the System.Runtime.CompilerServices.NullableAttribute tag is added to the MiddleName field.

Let's take a look at the comparison of properties, parameters, variables, and return values before and after compilation.

Attribute

/ / pre-compilation: public string? MiddleName {get; set;} / / compiled: [Nullable] public string MiddleName {[return: Nullable] get; [param: Nullable] set;}

Parameters.

/ / pre-compilation: public Person (string? MiddleName) {this.MiddleName = middleName;} / / compiled: public Person ([Nullable] string middleName) {this.MiddleName = middleName;}

Return value

/ / pre-compilation: public string? DoSomething () {return null;} / / compiled: [return: Nullable] public string DoSomething () {return (string) null;}

Variable

/ / pre-compilation: string? Name; / / compiled: string name

Except for variables, everything else is decorated with NullableAttribute tags.

What can it do?

From the above section, we know that nullable reference types are simply decorated with NullableAttribute tags in parameters, properties, parameters, and return values, which actually have no effect on the normal operation of the program. So what can it do for us?

Express one's intention

Cannot express this variable, parameter, field, property, return value in C # may be null or cannot be null, but an empty type can help us solve this problem.

Class Person {public string FirstName; / / is not null public string? MiddleName; / / may be null public string LastName; / / not null}

This type can mean that everyone should have FristName and LastName, but not everyone should have MiddleName.

Compiler detection

Another advantage of nullable reference types is that the compiler can help us detect code, such as warning about properties that directly use nullable reference types.

Void M (Person p) {p.FirstName = null; / / 1 WARNING: Cannot convert null to non-nullable reference. P.LastName = p.MiddleName; / / 2 WARNING: Possible null reference assignment. String s = default (string); / / 3 WARNING: Cannot convert null to non-nullable reference. If (p.MiddleName! = null) {WriteLine (p.MiddleName.Length); / / ok} WriteLine (p.MiddleNameplate. Length); / / ok} class Person {public string FirstName; / / 4 WARNING: Non-nullable field 'FirstName' is uninitialized. Public string? MiddleName; public string LastName; / / 5 WARNING: Non-nullable field 'LastName' is uninitialized. }

The compiler will help us do the following tests:

If you assign a null value to a non-nullable reference type or a value that can be nullable, a warning is issued

If a nullable reference type is used directly, a warning is issued

If a property that is not a nullable reference type has never been assigned a value, a warning is issued

If you need to use nullable reference types directly, you need to use! The symbol tells the compiler that you have confirmed that the value cannot be empty.

Of course, this is just the behavior of the compiler, and you can disable the warning prompts associated with it.

At this point, I believe you have a deeper understanding of "how to use C# nullable reference types". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.