Share 10 digit phone number validation in c#

[thuloanphamcat]

### 10 chữ số xác thực số điện thoại trong C#

Xác thực số điện thoại là một nhiệm vụ phổ biến trong nhiều ứng dụng.Bài viết này sẽ chỉ cho bạn cách xác thực số điện thoại 10 chữ số trong C#.

#### 1. Thuật toán Luhn

Thuật toán Luhn là một cách đơn giản nhưng hiệu quả để xác nhận số điện thoại.Nó hoạt động bằng cách thêm các chữ số của số điện thoại lại với nhau, bắt đầu bằng chữ số cuối cùng và hoạt động trở lại chữ số đầu tiên.Sau đó, bạn nhân số tổng với 10 và thêm 1. Nếu số kết quả là chia hết cho 10, thì số điện thoại là hợp lệ.

Dưới đây là một ví dụ về cách thuật toán Luhn hoạt động:

`` `
Số điện thoại: 123-456-7890

Tổng các chữ số: 4 + 5 + 6 + 7 + 8 + 9 + 0 = 40

10 * 40 + 1 = 401

401 chia hết cho 10, vì vậy số điện thoại là hợp lệ.
`` `

#### 2. Thực hiện thuật toán Luhn trong C#

Để thực hiện thuật toán LuHN trong C#, bạn có thể sử dụng mã sau:

`` `C#
Công khai Bool Isvalidphonenumber (Chuỗi Phonenumber)
{
// Xóa bất kỳ khoảng trống nào khỏi số điện thoại.
phonenumber = phonenumber.replace ("", "");

// Kiểm tra xem số điện thoại có dài 10 chữ số không.
if (phonenumber.length! = 10)
{
trả lại sai;
}

// Tính tổng của các chữ số trong số điện thoại.
int sum = 0;
for (int i = phonenumber.length-1; i> = 0; i--)
{
int digit = int.parse (phonenumber .toString ());
sum += chữ số;
}

// Nhân số tổng với 10 và thêm 1.
tổng *= 10;
tổng += 1;

// Kiểm tra xem số kết quả là chia hết cho 10.
if (sum % 10 == 0)
{
trả lại đúng;
}

trả lại sai;
}
`` `

#### 3. Kiểm tra thuật toán Luhn

Bạn có thể kiểm tra thuật toán LuHN bằng cách sử dụng mã sau:

`` `C#
// Tạo danh sách các số điện thoại hợp lệ.
Var ValidphonEnumbers = Danh sách mới <String>
{
"123-456-7890",
"(123) 456-7890",
"+1 234 567 8900"
};

// Tạo danh sách các số điện thoại không hợp lệ.
var không hợp lệ
{
"123-456-789",
"(123) 456-789",
"+1 234 567 890"
};

// Loop thông qua các số điện thoại hợp lệ và kiểm tra xem chúng có hợp lệ không.
foreach (var phonenumber trong Validphonenumbers)
{
if (! isvalidphonenumber (phonenumber))
{
Ném ngoại lệ mới ("Số điện thoại" + Phonenumber + "không hợp lệ.");
}
}

// Vòng lặp qua các số điện thoại không hợp lệ và kiểm tra xem chúng có hợp lệ không.
foreach (var phonenumber trong không hợp lệ)
{
if (isvalidphonenumber (phonenumber))
{
Ném ngoại lệ mới ("Số điện thoại" + Phonenumber + "là hợp lệ, nhưng nó phải không hợp lệ.");
}
}

// Mã không nên ném bất kỳ ngoại lệ nào, vì vậy thuật toán Luhn đang hoạt động chính xác.
`` `

#### 4. Kết luận

Thuật toán Luhn là một cách đơn giản nhưng hiệu quả để xác nhận số điện thoại.Nó rất dễ thực hiện và có thể được sử dụng trong nhiều ứng dụng khác nhau
=======================================
### 10 Digit Phone Number Validation in C#

Phone number validation is a common task in many applications. This article will show you how to validate a 10-digit phone number in C#.

#### 1. The Luhn algorithm

The Luhn algorithm is a simple but effective way to validate a phone number. It works by adding the digits of the phone number together, starting with the last digit and working your way back to the first digit. Then, you multiply the sum by 10 and add 1. If the resulting number is divisible by 10, then the phone number is valid.

Here is an example of how the Luhn algorithm works:

```
Phone number: 123-456-7890

Sum of digits: 4 + 5 + 6 + 7 + 8 + 9 + 0 = 40

10 * 40 + 1 = 401

401 is divisible by 10, so the phone number is valid.
```

#### 2. Implementing the Luhn algorithm in C#

To implement the Luhn algorithm in C#, you can use the following code:

```c#
public static bool IsValidPhoneNumber(string phoneNumber)
{
// Remove any spaces from the phone number.
phoneNumber = phoneNumber.Replace(" ", "");

// Check if the phone number is 10 digits long.
if (phoneNumber.Length != 10)
{
return false;
}

// Calculate the sum of the digits in the phone number.
int sum = 0;
for (int i = phoneNumber.Length - 1; i >= 0; i--)
{
int digit = int.Parse(phoneNumber.ToString());
sum += digit;
}

// Multiply the sum by 10 and add 1.
sum *= 10;
sum += 1;

// Check if the resulting number is divisible by 10.
if (sum % 10 == 0)
{
return true;
}

return false;
}
```

#### 3. Testing the Luhn algorithm

You can test the Luhn algorithm by using the following code:

```c#
// Create a list of valid phone numbers.
var validPhoneNumbers = new List<string>
{
"123-456-7890",
"(123) 456-7890",
"+1 234 567 8900"
};

// Create a list of invalid phone numbers.
var invalidPhoneNumbers = new List<string>
{
"123-456-789",
"(123) 456-789",
"+1 234 567 890"
};

// Loop through the valid phone numbers and check if they are valid.
foreach (var phoneNumber in validPhoneNumbers)
{
if (!IsValidPhoneNumber(phoneNumber))
{
throw new Exception("The phone number " + phoneNumber + " is invalid.");
}
}

// Loop through the invalid phone numbers and check if they are invalid.
foreach (var phoneNumber in invalidPhoneNumbers)
{
if (IsValidPhoneNumber(phoneNumber))
{
throw new Exception("The phone number " + phoneNumber + " is valid, but it should be invalid.");
}
}

// The code should not throw any exceptions, so the Luhn algorithm is working correctly.
```

#### 4. Conclusion

The Luhn algorithm is a simple but effective way to validate a phone number. It is easy to implement and can be used in a variety of applications