Share c# 7.3 nullable

[sihoangnguyentuong]

Các loại tham chiếu ## C# 7.3 Các loại tham chiếu vô hiệu

C# 7.3 đã giới thiệu các loại tham chiếu vô hiệu, cho phép bạn khai báo các biến có thể giữ các giá trị null.Điều này có thể hữu ích cho các tình huống mà bạn muốn có thể phân biệt giữa một giá trị được đặt rõ ràng thành NULL và một giá trị chưa được khởi tạo.

Để khai báo loại tham chiếu có thể vô hiệu hóa, bạn sử dụng ký tự `?` Sau tên loại.Ví dụ: mã sau tuyên bố biến `int` vô hiệu:

`` `C#
int?MynullableInt;
`` `

Bạn cũng có thể khai báo một mảng các loại tham chiếu vô hiệu.Ví dụ: mã sau đây khai báo một mảng có thể vô hiệu hóa `int`:

`` `C#
int? [] MynullableIntarray;
`` `

Khi bạn gán một giá trị cho một loại tham chiếu vô hiệu, bạn có thể chỉ định rõ ràng giá trị là null hoặc bạn có thể bỏ qua giá trị.Nếu bạn bỏ qua giá trị, biến sẽ được khởi tạo thành `null`.

Ví dụ: mã sau gán giá trị `10` cho biến` mynullableInt`:

`` `C#
mynullableInt = 10;
`` `

Mã sau đây cũng gán giá trị `10` cho biến` mynullableInt`, nhưng nó làm như vậy bằng cách bỏ qua giá trị.

`` `C#
mynullableInt = null;
`` `

Bạn có thể kiểm tra xem một loại tham chiếu có thể vô hiệu hóa có phải là null hay không bằng cách sử dụng toán tử `is`.Ví dụ: mã sau kiểm tra xem biến `mynullableInt` là null:

`` `C#
if (mynullableInt là null)
{
// Biến là null.
}
khác
{
// Biến không phải là null.
}
`` `

Bạn cũng có thể sử dụng toán tử `! =` Để kiểm tra xem loại tham chiếu có thể không có được.Ví dụ: mã sau kiểm tra xem biến `mynullableInt` không phải là null:

`` `C#
if (mynullableInt! = null)
{
// Biến không phải là null.
}
`` `

## hashtags

* #csharp
* #Nullable
* #referencetypes
* #csharp7.3
* #Programming
=======================================
Reference Types ## C# 7.3 Nullable Reference Types

C# 7.3 introduced nullable reference types, which allow you to declare variables that can hold null values. This can be useful for situations where you want to be able to differentiate between a value that is explicitly set to null and a value that has not been initialized yet.

To declare a nullable reference type, you use the `?` character after the type name. For example, the following code declares a nullable `int` variable:

```c#
int? myNullableInt;
```

You can also declare an array of nullable reference types. For example, the following code declares an array of nullable `int`s:

```c#
int?[] myNullableIntArray;
```

When you assign a value to a nullable reference type, you can either explicitly specify the value as null, or you can omit the value. If you omit the value, the variable will be initialized to `null`.

For example, the following code assigns the value `10` to the `myNullableInt` variable:

```c#
myNullableInt = 10;
```

The following code also assigns the value `10` to the `myNullableInt` variable, but it does so by omitting the value.

```c#
myNullableInt = null;
```

You can check whether a nullable reference type is null by using the `is` operator. For example, the following code checks whether the `myNullableInt` variable is null:

```c#
if (myNullableInt is null)
{
// The variable is null.
}
else
{
// The variable is not null.
}
```

You can also use the `!=` operator to check whether a nullable reference type is not null. For example, the following code checks whether the `myNullableInt` variable is not null:

```c#
if (myNullableInt != null)
{
// The variable is not null.
}
```

## Hashtags

* #csharp
* #Nullable
* #referencetypes
* #csharp7.3
* #Programming