Câu hỏi phỏng vấn C# và .Net - Senior

Marshalling là gì và tại sao chúng ta cần nó?

Marshalling trong C# là quá trình chuyển đổi các loại dữ liệu giữa mã quản lý (.NET) và mã không quản lý (native code). Mã quản lý được thực thi bởi Common Language Runtime (CLR), trong khi mã không quản lý được thực thi trực tiếp bởi hệ điều hành.

Marshalling là cần thiết khi bạn muốn tương tác với các thành phần sau:

• Thư viện hệ thống: Nhiều thư viện hệ thống được viết bằng ngôn ngữ lập trình khác (như C/C++), và do đó là mã không quản lý.
• API: Các API hệ điều hành cũng thường được viết bằng mã không quản lý.
• COM: Component Object Model (COM) là một công nghệ cho phép các thành phần phần mềm được viết bằng các ngôn ngữ lập trình khác nhau giao tiếp với nhau. COM sử dụng mã không quản lý.

Sự khác biệt giữa phương thức dispose và finalize là gì trong C#?

Phương thức Dispose:

• Được định nghĩa trong interface IDisposable.
• Được gọi trực tiếp bởi mã C# để giải phóng tài nguyên không được quản lý.
• Cung cấp khả năng kiểm soát rõ ràng hơn việc giải phóng tài nguyên.
• Có thể được gọi nhiều lần trên cùng một đối tượng.
• Nên được sử dụng khi bạn muốn giải phóng tài nguyên ngay lập tức.

Phương thức Finalize:

• Được tạo tự động bởi trình biên dịch C# từ destructor (hàm hủy) của lớp.
• Được gọi bởi Garbage Collector (GC) để giải phóng tài nguyên không được quản lý của các đối tượng không còn được tham chiếu.
• Không cung cấp khả năng kiểm soát việc giải phóng tài nguyên.
• Chỉ được gọi một lần trên mỗi đối tượng.
• Nên được sử dụng khi bạn không cần giải phóng tài nguyên ngay lập tức.

Bảng so sánh:

Sự khác biệt giữa late binding và early binding trong C#?

Late binding:

• Liên kết được thực hiện tại thời điểm thực thi.
• Loại của đối tượng được xác định bằng cách sử dụng reflection.
• Cho phép linh hoạt hơn trong việc sử dụng các thành phần.
• Có thể dẫn đến hiệu suất thấp hơn vì liên kết phải được thực hiện mỗi lần truy cập thành phần.
• Ví dụ: sử dụng reflection để gọi phương thức của một đối tượng.

Early binding:

• Liên kết được thực hiện tại thời điểm biên dịch.
• Loại của đối tượng được xác định trực tiếp từ mã.
• Cung cấp hiệu suất cao hơn vì liên kết chỉ được thực hiện một lần.
• Ít linh hoạt hơn trong việc sử dụng các thành phần.
• Ví dụ: gọi phương thức của một đối tượng được khai báo trực tiếp trong mã.

Bảng so sánh:

Constructor Chaining trong C# là gì?

Constructor Chaining là kỹ thuật trong lập trình C# cho phép một constructor (hàm khởi tạo) gọi một constructor khác của cùng một lớp hoặc của lớp cơ sở (base class). Constructor Chaining dùng để khởi tạo các thuộc tính của đối tượng theo thứ tự.

Ví dụ

public class Person
{
    public Person()
    {
        Console.WriteLine("Person constructor");
    }

    public Person(string name) : this()
    {
        Console.WriteLine("Person constructor with name: {0}", name);
    }
}

public class Student : Person
{
    public Student()
    {
        Console.WriteLine("Student constructor");
    }

    public Student(string name, int age) : base(name)
    {
        Console.WriteLine("Student constructor with name: {0} and age: {1}", name, age);
    }
}

class Program
{
    static void Main(string[] args)
    {
        var person = new Person("John Doe");
        var student = new Student("Jane Doe", 21);
    }
}

Kết quả

Person constructor
Person constructor with name: John Doe
Student constructor
Student constructor with name: Jane Doe and age: 21

Sự khác biệt giữa toán tử is và as trong C# là gì?

Toán tử is:

• Dùng để kiểm tra xem một đối tượng có phải là một instance của một kiểu cụ thể hay không.
• Trả về giá trị true nếu đối tượng là kiểu được chỉ định hoặc false nếu không phải.
• Không thực hiện chuyển đổi kiểu.
• Thường được sử dụng trong các câu lệnh điều kiện để kiểm tra kiểu trước khi thực hiện các thao tác cụ thể với đối tượng.

Toán tử as:

• Dùng để thực hiện chuyển đổi kiểu an toàn giữa các kiểu tham chiếu hoặc nullable types.
• Trả về đối tượng được chuyển đổi nếu chuyển đổi thành công; nếu không thành công, nó trả về null thay vì ném ra một ngoại lệ.
• Thực hiện chuyển đổi kiểu an toàn.
• Thường được sử dụng khi bạn muốn chuyển đổi một đối tượng sang một kiểu cụ thể và bạn không chắc chắn rằng chuyển đổi sẽ thành công.

Bảng so sánh:

Kết luận:

Nên sử dụng toán tử is để kiểm tra kiểu và toán tử as để thực hiện chuyển đổi kiểu an toàn.

Lưu ý:

• Toán tử is chỉ có thể được sử dụng với các kiểu tham chiếu.
• Toán tử as có thể được sử dụng với cả kiểu tham chiếu và kiểu giá trị.

Các tác vụ bất đồng bộ Async/Await hoạt động như thế nào trong .NET?

Async/Await là một mô hình lập trình cho phép bạn thực hiện các tác vụ bất đồng bộ một cách hiệu quả và dễ dàng. Nó bao gồm hai từ khóa: async và await.

Từ khóa async:

• Được sử dụng để đánh dấu một phương thức hoặc lambda expression có thể thực hiện bất đồng bộ.
• Cho phép phương thức hoặc lambda expression trả về một Task hoặc Task<T>, đại diện cho kết quả của tác vụ bất đồng bộ.

Từ khóa await:

• Được sử dụng để tạm dừng thực thi của một phương thức async cho đến khi một tác vụ bất đồng bộ hoàn thành.
• Cho phép bạn lấy kết quả của tác vụ bất đồng bộ hoặc xử lý ngoại lệ nếu có.

Cách thức hoạt động:

Khi bạn gọi một phương thức async, nó sẽ khởi chạy một tác vụ bất đồng bộ và trả về một Task. Sau đó, bạn có thể sử dụng await để tạm dừng thực thi của phương thức hiện tại cho đến khi tác vụ bất đồng bộ hoàn thành. Khi tác vụ hoàn thành, kết quả sẽ được trả về hoặc ngoại lệ sẽ được ném ra.

Lợi ích:

• Cải thiện hiệu suất: Cho phép bạn thực hiện nhiều tác vụ song song, giúp cải thiện hiệu suất ứng dụng.
• Cải thiện khả năng phản hồi: Cho phép giao diện người dùng phản hồi với người dùng trong khi các tác vụ bất đồng bộ đang được thực hiện.
• Dễ sử dụng: Cung cấp một cách đơn giản và dễ dàng để viết code bất đồng bộ.

ConfigureAwait(false) và ConfigureAwait(true) có ý nghĩa gì?

ConfigureAwait(false) thưởng được sử dụng cho các Library

ConfigureAwait(true) thường được sử dụng cho UI (Giao diện người dùng)

Vậy tại sao lại phải như thế?

ConfigureAwait(false) cho Library:

• Tránh deadlocks: Việc sử dụng ConfigureAwait(true) trong library có thể dẫn đến deadlocks (tình trạng bế tắc) nếu library được sử dụng bởi nhiều thread.
• Tối ưu hóa hiệu suất: ConfigureAwait(false) giúp tối ưu hóa hiệu suất bằng cách tránh việc marshaling kết quả giữa các thread.
• Giảm thiểu phụ thuộc vào ngữ cảnh: Library không nên phụ thuộc vào ngữ cảnh UI.

ConfigureAwait(true) cho UI:

• Đảm bảo tính đồng bộ: ConfigureAwait(true) đảm bảo rằng các thao tác trên kết quả được thực hiện trên thread UI, giúp đảm bảo tính đồng bộ của giao diện người dùng.
• Tránh lỗi giao diện: Việc sử dụng ConfigureAwait(false) có thể dẫn đến lỗi giao diện nếu kết quả được xử lý trên thread khác với thread UI.
• Đơn giản hóa code: ConfigureAwait(true) giúp đơn giản hóa code UI bằng cách loại bỏ việc xử lý marshaling kết quả.

Ví dụ:

• Library: Một library tải xuống dữ liệu từ API nên sử dụng ConfigureAwait(false) để tránh deadlocks và tối ưu hóa hiệu suất.
• UI: Một ứng dụng UI hiển thị hình ảnh nên sử dụng ConfigureAwait(true) để đảm bảo hình ảnh được hiển thị đúng cách trên giao diện người dùng.

Tóm lại:

• Sử dụng ConfigureAwait(false) cho library để tránh deadlocks, tối ưu hóa hiệu suất và giảm thiểu phụ thuộc vào ngữ cảnh.
• Sử dụng ConfigureAwait(true) cho UI để đảm bảo tính đồng bộ, tránh lỗi giao diện và đơn giản hóa code.

Indexer trong C# là gì?

Indexer trong C# là một tính năng cho phép bạn truy cập các thành viên của một lớp hoặc struct như thể chúng là các phần tử của mảng.

Ví dụ:

public class MyCollection
{
    private string[] _data = new string[10];

    public string this[int index]
    {
        get { return _data[index]; }
        set { _data[index] = value; }
    }
}

//Sử dụng
var myCollection = new MyCollection();

myCollection[0] = "Hello";
var value = myCollection[1];

Khi nào sử dụng ArrayList thay vì array[] trong C#?

Nên sử dụng ArrayList thay vì array[] khi cần sự linh hoạt trong việc quản lý kích thước tập dữ liệu, thêm hoặc xóa phần tử thường xuyên, truy cập phần tử bằng tên hoặc sử dụng các phương thức thao tác dữ liệu sẵn có.

Từ khóa yield được sử dụng để làm gì trong C#?

Từ khóa yield trong C# được sử dụng để tạo iterator block, giúp bạn có thể tạo ra các lớp iterable (lớp có thể được lặp qua) một cách dễ dàng.

Lợi ích của yield:

• Giúp tạo các lớp iterable một cách dễ dàng.
• Giúp tiết kiệm bộ nhớ và hiệu suất.
• Cho phép bạn tạo ra các trình lặp vô hạn.

Ví dụ

public IEnumerable<string> GetWords(string text)
{
  var words = text.Split(' ');
  foreach (var word in words)
  {
    yield return word;
  }
}

// Sử dụng yield để tạo ra một trình lặp vô hạn
public IEnumerable<int> GetInfiniteNumbers()
{
  var i = 0;
  while (true)
  {
    yield return i++;
  }
}

Giải thích luồng chạy:

1. Phương thức GetWords(string text):

• Bước 1: Nhận chuỗi text làm đầu vào.
• Bước 2: Tách chuỗi thành các từ bằng text.Split(' ').
• Bước 3: Duyệt qua từng từ trong mảng words.
• Bước 4: Sử dụng yield return word để trả về từng từ một.
  • Khi gặp yield return, phương thức tạm dừng và trả về từ hiện tại.
  • Khi cần từ tiếp theo, phương thức tiếp tục từ điểm tạm dừng và trả về từ tiếp theo.
• Bước 5: Tiếp tục lặp lại bước 4 cho đến khi duyệt hết tất cả các từ.

2. Phương thức GetInfiniteNumbers():

• Bước 1: Khởi tạo biến i bằng 0.
• Bước 2: Bắt đầu một vòng lặp vô hạn while (true).
• Bước 3: Sử dụng yield return i++ để trả về giá trị hiện tại của i.
  • Giống như GetWords, phương thức tạm dừng và trả về giá trị i.
  • Khi cần giá trị tiếp theo, phương thức tiếp tục và trả về i đã tăng thêm 1.
• Bước 4: Lặp lại bước 3, tạo ra một trình lặp vô hạn các số nguyên.

Lưu ý quan trọng:

• Các phương thức sử dụng yield không trả về tất cả các giá trị cùng một lúc.
• Chúng trả về từng giá trị khi được gọi đến trong vòng lặp foreach.
• Điều này giúp tiết kiệm bộ nhớ và hiệu suất, đặc biệt khi làm việc với tập dữ liệu lớn.

Giải thích sự khác biệt giữa Select và Where?

Select:

• Dùng để chuyển đổi các phần tử trong một tập hợp sang một tập hợp mới.
• Mỗi phần tử trong tập hợp mới được tạo ra từ một phần tử trong tập hợp ban đầu.
• Có thể sử dụng các biểu thức lambda để thực hiện các phép toán phức tạp trên từng phần tử.

Where:

• Dùng để lọc các phần tử trong một tập hợp dựa trên một điều kiện.
• Chỉ những phần tử thỏa mãn điều kiện mới được đưa vào tập hợp mới.
• Có thể sử dụng các biểu thức lambda để xác định điều kiện lọc.

Sự khác biệt giữa Func và delegate?

Func:

• Là một delegate kiểu generic được sử dụng để tham chiếu đến phương thức nhận vào một số tham số và trả về một giá trị.
• Cú pháp ngắn gọn và dễ đọc.
• Có thể sử dụng với các kiểu dữ liệu khác nhau.

Delegate:

• Là một từ khóa được sử dụng để định nghĩa một kiểu delegate không generic hoặc generic.
• Có thể tham chiếu đến bất kỳ phương thức nào có chữ ký phù hợp.
• Cung cấp nhiều tùy chỉnh hơn so với Func.

Giải thích sự khác biệt giữa các phương thức destructor, dispose và finalize?

1. Destructor:

• Destructor là một phương thức đặc biệt được tự động gọi bởi hệ thống khi một đối tượng bị hủy.
• Destructor được sử dụng để giải phóng tài nguyên được cấp phát bởi chính đối tượng đó.
• Destructor không thể được gọi trực tiếp bởi lập trình viên.
• Destructor có thể gây ra rò rỉ bộ nhớ nếu không được sử dụng đúng cách.

2. Dispose:

• Dispose là một phương thức được định nghĩa trong interface IDisposable.
• Dispose được sử dụng để giải phóng tài nguyên được cấp phát bởi cả đối tượng và các đối tượng phụ thuộc của nó.
• Dispose có thể được gọi trực tiếp bởi lập trình viên.
• Dispose giúp giải phóng tài nguyên một cách rõ ràng và hiệu quả, tránh rò rỉ bộ nhớ.

3. Finalize:

• Finalize là một phương thức được gọi bởi bộ thu gom rác (garbage collector) trong .NET Framework.
• Finalize được sử dụng để giải phóng tài nguyên không được quản lý (unmanaged resources) được cấp phát bởi đối tượng.
• Finalize không thể được gọi trực tiếp bởi lập trình viên.
• Finalize được gọi tự động bởi bộ thu gom rác, nhưng thời điểm gọi không được đảm bảo.

Bảng so sánh:

Từ khóa volatile được sử dụng để làm gì?

Trong C#, từ khóa volatile được sử dụng để đảm bảo tính nhất quán của dữ liệu được truy cập bởi nhiều luồng.

Khi được áp dụng cho một biến, volatile thông báo cho trình biên dịch và hệ thống thời gian chạy rằng giá trị của biến có thể thay đổi bất cứ lúc nào bởi các luồng khác.

Điều này giúp đảm bảo rằng tất cả các luồng đều nhìn thấy giá trị cập nhật nhất của biến, tránh các lỗi tiềm ẩn do dữ liệu không nhất quán.

Ví dụ:

int count = 0;

void IncrementCount()
{
  count++;
}

void DecrementCount()
{
  count--;
}

void Main()
{
  // Khởi tạo hai luồng
  Thread thread1 = new Thread(IncrementCount);
  Thread thread2 = new Thread(DecrementCount);

  // Bắt đầu hai luồng
  thread1.Start();
  thread2.Start();

  // Chờ cho cả hai luồng kết thúc
  thread1.Join();
  thread2.Join();

  // In giá trị cuối cùng của count
  Console.WriteLine(count);
}

Kết quả = 0