Custom exceptions in .NET are user-defined exceptions that inherit from System.Exception. They provide specific error information tailored to an application’s needs, improving code readability and error handling.

The most commonly used types of exceptions in .NET include: System.Exception: Base class for all exceptions. System.NullReferenceException: Thrown when attempting to use a null object reference. System.IndexOutOfRangeException: Thrown when an array index is out of bounds. System.InvalidOperationException: Thrown when a method call is invalid for the object’s current state. System.ArgumentException: Thrown when an argument provided […]

An object pool in .NET is a design pattern used to manage a collection of reusable objects. It aims to reduce the overhead of creating and destroying objects by reusing them. This is particularly useful for objects that are expensive to create or require significant resources. By maintaining a pool of objects, you can improve […]

Generics in C# .NET allow you to define classes, methods, and data structures with a placeholder for the type of data they store or use. This provides type safety without the need to specify an exact data type upfront, promoting code reuse and reducing runtime errors. For example, List T can store any type of […]

Circular references occur when two or more objects reference each other directly or indirectly, creating a loop. This can lead to issues such as memory leaks, as the garbage collector cannot reclaim the memory used by these objects since they are still considered in use due to their mutual references.

Dispose(): Purpose: Explicitly releases unmanaged resources. Usage: Called by the developer manually. Implementation: Part of the IDisposable interface. Timing: Immediate, deterministic cleanup. Finalize(): Purpose: Implicitly releases unmanaged resources. Usage: Called by the garbage collector. Implementation: Defined using a destructor syntax (~ClassName). Timing: Non-deterministic, depends on garbage collection timing. Key Difference: Dispose() is called manually for […]

Abstract Class: Can have both abstract (no implementation) and concrete methods. A class can inherit only one abstract class. Can contain fields and properties. Interface: Only contains method signatures (no implementation). A class can implement multiple interfaces. Cannot contain fields, only properties with signatures.

To sort array elements in descending order in C#, you can use the Array.Sort() method followed by the Array.Reverse() method. Here’s the short answer: Array.Sort(array); Array.Reverse(array); This first sorts the array in ascending order and then reverses it to get descending order.

What’s the difference between the System.Array.CopyTo() and System.Array.Clone() ? System.Array.CopyTo(): Purpose: Copies the elements of an array to another existing array starting at a specified index. Operation: Requires a destination array with sufficient size. Usage: sourceArray.CopyTo(destinationArray, startIndex); System.Array.Clone(): Purpose: Creates a shallow copy of the array. Operation: Returns a new array with the same elements. […]

What are the differences between System.String and System.Text.StringBuilder classes? System.String: Immutable: Once created, the value cannot be changed. Performance: Creating a new string for every modification can be slower for frequent changes. Usage: Suitable for scenarios with infrequent or few string modifications. System.Text.StringBuilder: Mutable: Can be modified without creating a new instance. Performance: More efficient […]