As C# remains a cornerstone of modern software development, recruiters must identify C# developers with expertise in object-oriented programming, .NET frameworks, and enterprise application development. C# is widely used for desktop applications, web development (ASP.NET), game development (Unity), and cloud-based solutions.
This resource, "100+ C# Interview Questions and Answers," is tailored for recruiters to simplify the evaluation process. It covers topics from basic C# syntax to advanced application development, including LINQ, asynchronous programming, design patterns, and performance optimization.
Whether hiring C# Developers, .NET Engineers, or Software Architects, this guide enables you to assess a candidate’s:
For a streamlined assessment process, consider platforms like WeCP, which allow you to:
✅ Create customized C# assessments tailored to different job roles.
✅ Include hands-on coding challenges and real-world problem-solving tasks.
✅ Conduct remote proctored exams to ensure test integrity.
✅ Leverage AI-powered evaluation for faster and more accurate hiring decisions.
Save time, improve hiring efficiency, and confidently recruit C# developers who can build robust, high-performance applications from day one.
C# (pronounced "C-sharp") is a modern, object-oriented programming language developed by Microsoft as part of its .NET initiative. It is designed for building a wide range of applications, from web and desktop applications to mobile and cloud-based services. C# is a statically typed language, meaning variable types are determined at compile time, which helps in catching errors early in the development process.
C# supports features such as strong type checking, garbage collection, and inheritance, making it a versatile choice for developers. It has a rich set of libraries and frameworks, particularly with the .NET Framework and .NET Core, which provide a robust environment for application development. C# also incorporates various programming paradigms, including procedural, functional, and event-driven programming, which allows developers to choose the best approach for their projects.
C# syntax is similar to other C-based languages, such as C++ and Java, making it relatively easy for developers familiar with those languages to learn. The basic structure of a C# program includes:
C# provides a variety of data types to store different kinds of information. These can be broadly categorized into:
Additionally, C# supports nullable types, allowing value types to also represent null.
In C#, int and Int32 are synonymous; both refer to a 32-bit signed integer. int is an alias provided by C# for System.Int32, which is defined in the .NET framework. The primary difference lies in readability and context:
Using either in your code will yield the same functionality, but using int is generally preferred for simplicity.
In C#, a variable is declared by specifying its type followed by its name. The general syntax is:
type variableName;For example, to declare an integer variable named age, you would write:
int age;You can also initialize the variable at the time of declaration:
int age = 25;C# allows multiple variables to be declared in one line, as long as they are of the same type:
int x = 10, y = 20, z = 30;It’s important to note that variable names must follow certain rules: they must start with a letter or underscore, can contain letters, digits, or underscores, and are case-sensitive.
Operators in C# are special symbols that perform operations on variables and values. They can be categorized into several types:
Operators play a crucial role in controlling the flow of the program and performing calculations.
In C#, the == operator is used to compare two values for equality. However, C# does not have a === operator, as seen in some other languages like JavaScript. Instead, C# uses == for both value types and reference types, but its behavior can differ based on the type of data being compared:
Value Types: When comparing value types (like int, float, etc.), == compares the actual values. For instance:
int a = 5;
int b = 5;
bool result = (a == b); // trueReference Types: When comparing reference types (like objects and strings), == compares the references (memory addresses) by default. However, many reference types (like strings) override the == operator to compare the values instead:
string str1 = "hello";
string str2 = "hello";
bool result = (str1 == str2); // true, compares valuesTo explicitly compare references (the actual memory address), you can use the Object.ReferenceEquals method.
A namespace in C# is a declarative region that provides a way to group related classes, interfaces, structs, enums, and delegates. Namespaces help organize code and prevent naming conflicts, especially in larger projects or when integrating multiple libraries.
To declare a namespace, you use the namespace keyword:
namespace MyApplication
{
class MyClass
{
// Class members go here
}
}To access a class within a namespace, you can either fully qualify its name:
MyApplication.MyClass obj = new MyApplication.MyClass();Or use a using directive at the top of your file:
using MyApplication;
MyClass obj = new MyClass();Namespaces can be nested, and it’s common to organize them hierarchically, which aids in code clarity and maintainability.
Exception handling in C# is managed using try, catch, finally, and throw keywords. This mechanism allows developers to handle runtime errors gracefully, maintaining the program's flow without crashing.
Try Block: The code that might throw an exception is placed inside a try block.
try
{
// Code that may throw an exception
int result = 10 / 0; // This will throw a DivideByZeroException
}Catch Block: If an exception occurs, control is passed to the catch block, where you can handle the exception appropriately.
catch (DivideByZeroException ex)
{
Console.WriteLine("Cannot divide by zero: " + ex.Message);
}Finally Block: This block is optional and executes whether an exception is thrown or not. It’s commonly used for cleanup code, such as closing file streams.
finally
{
Console.WriteLine("This code runs regardless of exceptions.");
}Throwing Exceptions: You can also throw exceptions intentionally using the throw keyword.
if (someCondition)
{
throw new InvalidOperationException("Something went wrong.");
}A constructor in C# is a special method that is called when an instance of a class is created. Its primary purpose is to initialize the object and set its initial state. Constructors have the same name as the class and do not have a return type, not even void.
There are two main types of constructors in C#:
Default Constructor: A constructor that does not take any parameters. If no constructor is defined, C# provides a default one automatically.
public class MyClass
{
public MyClass() // Default constructor
{
// Initialization code
}
}Parameterized Constructor: A constructor that takes parameters to initialize an object with specific values.
public class MyClass
{
public int Value;
public MyClass(int value) // Parameterized constructor
{
Value = value;
}
}Constructors can also be overloaded, allowing multiple constructors with different parameters. Additionally, a constructor can call another constructor within the same class using the this keyword, facilitating code reuse.
Overall, constructors play a vital role in ensuring that objects are properly initialized and ready for use immediately after they are created.
An array in C# is a data structure that allows you to store a fixed-size sequence of elements of the same type. Arrays provide a way to organize data in a single variable, enabling efficient access and manipulation of multiple values. They are particularly useful when you need to work with a collection of related items, such as a list of student grades or temperatures over a week.
Arrays in C# are zero-indexed, meaning the first element is accessed at index 0. You can declare and initialize an array in one line, or you can declare it first and then assign values:
// Declaration and initialization in one line
int[] numbers = { 1, 2, 3, 4, 5 };
// Declaration first
int[] moreNumbers = new int[5]; // Creates an array of size 5
moreNumbers[0] = 10; // Assigning values
moreNumbers[1] = 20;You can also create multi-dimensional arrays, such as two-dimensional arrays (often used for matrices):
int[,] matrix = new int[3, 3]; // A 3x3 matrixArrays have a fixed size; once created, their length cannot be changed. For dynamic sizing, developers typically use collections like List<T>.
In C#, a list is created using the List<T> class from the System.Collections.Generic namespace. A list provides a dynamic array that can grow and shrink in size as needed, making it a versatile choice for managing collections of objects.
To create a list, you first need to include the namespace and then you can declare and initialize a list:
using System.Collections.Generic;
List<int> numbers = new List<int>(); // Create an empty list of integers
// Adding elements
numbers.Add(1);
numbers.Add(2);
numbers.Add(3);
// Initialize a list with values
List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };Lists provide various methods for manipulating data, such as Add, Remove, Insert, and Sort, allowing for easy management of elements.
While both List<T> and arrays in C# are used to store collections of items, they have several key differences:
Properties in C# are special methods (accessors) that provide a flexible mechanism to read, write, or compute the values of private fields. They are a key aspect of encapsulation, allowing control over how a field is accessed and modified.
A property consists of two accessors: get and set. The get accessor retrieves the value, while the set accessor assigns a value. Here’s an example:
public class Person
{
private string name; // Private field
public string Name // Property
{
get { return name; }
set { name = value; }
}
}You can also create auto-implemented properties, which simplify the syntax when no additional logic is required:
public class Person
{
public string Name { get; set; } // Auto-implemented property
}Properties enhance data encapsulation and help in maintaining the integrity of the data.
Encapsulation is one of the fundamental principles of object-oriented programming (OOP). It refers to the bundling of data (attributes) and methods (functions) that operate on the data into a single unit, typically a class. Encapsulation restricts direct access to some of an object's components and protects the integrity of the object's state.
By using access modifiers (such as private, protected, and public), developers can control how the data is accessed and modified. For example, you might expose a public method to update a private field while keeping the field itself inaccessible from outside the class.
public class Account
{
private double balance;
public void Deposit(double amount)
{
if (amount > 0)
{
balance += amount;
}
}
public double GetBalance()
{
return balance;
}
}In this example, balance is encapsulated; it can only be modified through the Deposit method, ensuring that it cannot be set to an invalid value.
An interface in C# is a contract that defines a set of methods, properties, events, or indexers without implementing them. Classes or structs that implement an interface must provide the actual implementations for its members. Interfaces allow for a form of multiple inheritance in C#, as a class can implement multiple interfaces.
Here’s an example of an interface and its implementation:
public interface IAnimal
{
void Speak(); // Method declaration
}
public class Dog : IAnimal
{
public void Speak() // Implementing the interface method
{
Console.WriteLine("Woof!");
}
}
public class Cat : IAnimal
{
public void Speak() // Implementing the interface method
{
Console.WriteLine("Meow!");
}
}Interfaces are useful for defining capabilities that can be shared across different classes, promoting code reusability and flexibility in programming.
The using statement in C# serves two primary purposes:
Namespace Inclusion: It allows the use of types defined in a namespace without needing to fully qualify their names. This makes code cleaner and more readable. For example:
using System;
public class MyClass
{
public void MyMethod()
{
Console.WriteLine("Hello, World!");
}
}Resource Management: The using statement is also used for automatic resource management, specifically for objects that implement the IDisposable interface. It ensures that resources are disposed of properly when they are no longer needed. For instance, when working with file streams:
using (StreamReader reader = new StreamReader("file.txt"))
{
string content = reader.ReadToEnd();
Console.WriteLine(content);
} // The StreamReader is disposed of automatically here.By utilizing the using statement, developers can prevent memory leaks and manage resources efficiently.
In C#, you can read from and write to files using classes provided by the System.IO namespace. The two commonly used classes for file operations are StreamReader for reading and StreamWriter for writing.
Writing to a File:
using System.IO;
class Program
{
static void Main()
{
using (StreamWriter writer = new StreamWriter("output.txt"))
{
writer.WriteLine("Hello, World!");
writer.WriteLine("This is a file.");
} // The StreamWriter is disposed of automatically.
}
}Reading from a File:
using System.IO;
class Program
{
static void Main()
{
using (StreamReader reader = new StreamReader("output.txt"))
{
string line;
while ((line = reader.ReadLine()) != null)
{
Console.WriteLine(line);
}
} // The StreamReader is disposed of automatically.
}
}These operations are essential for handling file input and output, allowing applications to store and retrieve data persistently.
The Main method is the entry point of a C# application. It is where the program starts executing when you run a C# console application. The method can be defined in various ways, but the most common signatures are:
static void Main(string[] args)or
static int Main(string[] args)The Main method can accept an array of strings as a parameter (args), which allows the application to receive command-line arguments.
Here’s an example of a simple Main method:
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Welcome to the application!");
}
}In this example, when the application is executed, the message "Welcome to the application!" will be displayed in the console.
Creating a simple console application in C# is straightforward. You can use an IDE like Visual Studio or Visual Studio Code, or you can use the .NET CLI (Command Line Interface).
Using Visual Studio:
Using .NET CLI:
Run the following command to create a new console application:
dotnet new console -n MyConsoleAppNavigate to the project folder:
cd MyConsoleAppRun the application with:
dotnet runYou can edit the generated Program.cs file to include your code, and upon running the application, it will execute the Main method, displaying output to the console.
Access modifiers in C# are keywords that define the accessibility of classes, methods, properties, and other members. They control how and where these members can be accessed from other parts of the code, thereby enforcing encapsulation. The main access modifiers in C# are:
These modifiers help in defining clear interfaces and protecting the internal state of classes.
The differences between these access modifiers are primarily related to where members can be accessed:
public: Members are visible and accessible from any other code. For example, a public class or method can be accessed from any other class, regardless of the assembly.
public class PublicClass
{
public void PublicMethod() { }
}private: Members are restricted to the containing class only. They cannot be accessed from outside the class, including derived classes.
public class PrivateClass
{
private void PrivateMethod() { }
}protected: Members can be accessed within the containing class and by any derived classes. This allows derived classes to access the base class's protected members.
public class BaseClass
{
protected void ProtectedMethod() { }
}internal: Members are accessible only within the same assembly. This is useful for limiting access to classes and methods that should not be exposed outside the assembly.
internal class InternalClass
{
internal void InternalMethod() { }
}These access levels provide flexibility in designing class interfaces while ensuring that implementation details remain hidden.
Inheritance is a fundamental principle of object-oriented programming (OOP) that allows one class (the derived class) to inherit the properties and behaviors (methods) of another class (the base class). This mechanism promotes code reusability and establishes a hierarchical relationship between classes.
In C#, inheritance is implemented by using the : symbol. The derived class can extend or override the base class's functionality, adding or modifying features as needed. Here's an example:
public class Animal
{
public void Eat() { }
}
public class Dog : Animal // Dog inherits from Animal
{
public void Bark() { }
}In this example, Dog inherits from Animal, meaning it can access the Eat method. Inheritance allows for the creation of more specific classes based on general classes, supporting polymorphism and better organization of code.
Polymorphism is another core concept in OOP that allows objects of different types to be treated as objects of a common super type. It enables a single interface to be used for different underlying data types, facilitating code flexibility and reuse.
There are two main types of polymorphism in C#:
Compile-time polymorphism (Method Overloading): This occurs when multiple methods have the same name but differ in parameters (type, number, or both). The appropriate method is determined at compile time.
public class MathOperations
{
public int Add(int a, int b) { return a + b; }
public double Add(double a, double b) { return a + b; }
}Run-time polymorphism (Method Overriding): This is achieved through inheritance and interfaces, where a derived class provides a specific implementation of a method that is already defined in its base class. The method to be invoked is determined at runtime based on the object's type.
public class Animal
{
public virtual void Speak() { Console.WriteLine("Animal speaks"); }
}
public class Dog : Animal
{
public override void Speak() { Console.WriteLine("Woof!"); }
}In this case, calling Speak on an Animal reference that actually points to a Dog object will invoke the Dog's Speak method.
Method overloading in C# is the ability to create multiple methods with the same name but different parameters within the same class. This allows methods to handle different types or numbers of arguments, enhancing code clarity and usability.
To implement method overloading, simply define multiple methods with the same name but varying parameter lists:
public class Calculator
{
public int Add(int a, int b) // Method with two integer parameters
{
return a + b;
}
public double Add(double a, double b) // Method with two double parameters
{
return a + b;
}
public int Add(int a, int b, int c) // Method with three integer parameters
{
return a + b + c;
}
}In this example, the Add method is overloaded with three different signatures. The appropriate method will be called based on the arguments passed when invoking it.
A static class in C# is a class that cannot be instantiated and can only contain static members (methods, properties, fields). Static classes are useful for grouping related methods that do not require object state. They help in organizing code and providing utility functions.
To declare a static class, use the static keyword:
public static class MathUtilities
{
public static int Add(int a, int b) { return a + b; }
public static double Square(double number) { return number * number; }
}You cannot create an instance of a static class:
MathUtilities math = new MathUtilities(); // This will cause a compilation errorInstead, you can call its static methods directly using the class name:
int sum = MathUtilities.Add(5, 10); // Calling a static methodIn C#, you can convert a string to an integer using several methods, depending on whether you want to handle potential errors gracefully. The most common methods are:
Using int.Parse: This method converts a string representation of a number to its integer equivalent. It throws an exception if the conversion fails.
string numberString = "123";
int number = int.Parse(numberString);Using int.TryParse: This method attempts to convert a string to an integer and returns a boolean indicating success or failure, making it safer to use when you're unsure if the string is a valid number.
string numberString = "123";
int number;
if (int.TryParse(numberString, out number))
{
Console.WriteLine("Conversion succeeded: " + number);
}
else
{
Console.WriteLine("Conversion failed.");
}Using Convert.ToInt32: This method is another way to convert a string to an integer, returning zero if the conversion fails. However, it does not throw exceptions for null strings.
string numberString = "123";
int number = Convert.ToInt32(numberString);Each method has its use cases, and it's essential to choose based on the requirements of your application.
Collections in C# are classes that provide a way to store and manage groups of related objects. They offer more flexibility and functionality than arrays, allowing dynamic resizing and built-in methods for adding, removing, and searching for items.
The main types of collections in C# are found in the System.Collections and System.Collections.Generic namespaces:
Collections make it easier to work with groups of data and are integral to many programming tasks in C#.
A delegate in C# is a type that represents references to methods with a specific parameter list and return type. Delegates are similar to function pointers in C/C++ but are type-safe. They are primarily used for implementing event handling and callback methods.
To declare a delegate, use the delegate keyword:
public delegate void Notify(string message);You can create an instance of a delegate and point it to a method with a matching signature:
public class Program
{
public static void ShowMessage(string message)
{
Console.WriteLine(message);
}
public static void Main()
{
Notify notify = ShowMessage; // Assigning method to delegate
notify("Hello, Delegates!"); // Invoking the delegate
}
}Delegates can also be combined to create multicast delegates, allowing multiple methods to be invoked with a single delegate call.
An event in C# is a special kind of delegate that provides a way for a class to notify other classes or objects when something of interest occurs. Events are based on the publisher-subscriber model, where the class that sends the notification is the publisher, and the classes that receive the notification are subscribers.
Events are defined using the event keyword and are typically used in conjunction with delegates:
public delegate void EventHandler(string message);
public class Publisher
{
public event EventHandler OnNotify;
public void Notify(string message)
{
OnNotify?.Invoke(message); // Notify subscribers
}
}Subscribers can register their methods to listen for the event:
public class Subscriber
{
public void Subscribe(Publisher publisher)
{
publisher.OnNotify += HandleNotification; // Subscribing to the event
}
private void HandleNotification(string message)
{
Console.WriteLine("Received message: " + message);
}
}In this example, the Publisher class raises an event when it calls the Notify method, and the Subscriber class can handle that event. Events provide a robust way to implement asynchronous programming and decouple classes in C#.
A switch statement in C# allows you to execute different code blocks based on the value of a variable. It's often used as a cleaner alternative to multiple if-else statements when dealing with many possible values.
Here's the basic syntax of a switch statement:
switch (expression)
{
case value1:
// Code to execute if expression equals value1
break;
case value2:
// Code to execute if expression equals value2
break;
default:
// Code to execute if expression doesn't match any case
break;
}Here's an example:
int day = 3;
switch (day)
{
case 1:
Console.WriteLine("Monday");
break;
case 2:
Console.WriteLine("Tuesday");
break;
case 3:
Console.WriteLine("Wednesday");
break;
default:
Console.WriteLine("Invalid day");
break;
}In this example, the output will be "Wednesday" because the value of day is 3. The break statement is crucial as it prevents fall-through, meaning that the code will not execute the subsequent cases unless explicitly stated.
Tuples in C# are a data structure that allows you to store multiple values of different types in a single object. They are particularly useful for returning multiple values from a method without needing to create a custom class or struct.
You can create a tuple using the Tuple class or by using the more modern syntax with value tuples introduced in C# 7.0:
var tuple = new Tuple<int, string>(1, "One");
Console.WriteLine($"Item1: {tuple.Item1}, Item2: {tuple.Item2}");var valueTuple = (Id: 1, Name: "One");
Console.WriteLine($"Id: {valueTuple.Id}, Name: {valueTuple.Name}");Value tuples allow for named elements, enhancing readability. Tuples are immutable; once created, their values cannot be changed.
In C#, data types are categorized into two main categories: value types and reference types.
int x = 10;
int y = x; // y is a copy of x, changes to y do not affect x.class Person
{
public string Name;
}
Person person1 = new Person();
person1.Name = "Alice";
Person person2 = person1; // person2 references the same object as person1
person2.Name = "Bob"; // Changes reflected in person1Understanding these differences is essential for effective memory management and avoiding unintended side effects in your code.
A nullable type in C# allows value types (like int, bool, etc.) to represent the normal range of values plus an additional null value. This is particularly useful for representing missing or undefined values, such as in database operations.
To declare a nullable type, use the ? operator:
int? nullableInt = null; // nullableInt can hold an integer or nullYou can check if a nullable type has a value using the HasValue property or by using the null-coalescing operator ??:
if (nullableInt.HasValue)
{
Console.WriteLine(nullableInt.Value);
}
else
{
Console.WriteLine("Value is null.");
}
int value = nullableInt ?? 0; // Use 0 if nullableInt is nullNullable types are especially handy in scenarios where a value might be absent, such as optional parameters or database fields.
Garbage collection (GC) in C# is an automatic memory management feature that reclaims memory occupied by objects that are no longer in use, preventing memory leaks and optimizing resource usage.
The .NET runtime includes a garbage collector that periodically checks for objects that are no longer referenced by any part of the application. Once identified, the memory used by these objects is freed, making it available for future allocations.
Key aspects of garbage collection include:
Garbage collection helps developers focus on application logic without worrying excessively about memory management.
The foreach loop in C# provides a simple and clean way to iterate over collections, arrays, and other enumerable types without needing to manage the loop index manually. It enhances readability and reduces the chance of errors.
Here’s the syntax for a foreach loop:
foreach (var item in collection)
{
// Code to execute for each item
}Here’s an example using an array:
string[] fruits = { "Apple", "Banana", "Cherry" };
foreach (var fruit in fruits)
{
Console.WriteLine(fruit);
}This will output each fruit in the array. The foreach loop automatically handles the iteration, making it easier to work with collections compared to traditional for loops.
Lambda expressions in C# are a concise way to represent anonymous methods. They enable you to create inline functions that can be used primarily in places where you need a delegate or an expression tree.
The syntax for a lambda expression is:
(parameters) => expression or { statements }For example, here's how you might use a lambda expression with a list:
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
// Using a lambda expression to filter even numbers
var evenNumbers = numbers.Where(n => n % 2 == 0).ToList();In this case, n => n % 2 == 0 is the lambda expression, which checks if a number is even. Lambda expressions are widely used in LINQ queries and event handling.
In C#, you can handle multiple exceptions by using multiple catch blocks after a single try block. Each catch block can handle a specific exception type, allowing for granular error handling.
Here’s an example:
try
{
// Code that may throw exceptions
int result = 10 / int.Parse("0"); // This will throw an exception
}
catch (DivideByZeroException ex)
{
Console.WriteLine("Cannot divide by zero: " + ex.Message);
}
catch (FormatException ex)
{
Console.WriteLine("Invalid format: " + ex.Message);
}
catch (Exception ex) // General catch block
{
Console.WriteLine("An unexpected error occurred: " + ex.Message);
}In this example, specific exceptions (DivideByZeroException and FormatException) are handled with dedicated catch blocks, while a general catch block handles any other exceptions. This allows for more specific responses to different error conditions.
LINQ (Language Integrated Query) is a powerful feature in C# that allows developers to query collections (like arrays, lists, and databases) in a more readable and expressive manner using syntax that is integrated into the C# language.
LINQ provides a consistent way to query various data sources, regardless of their underlying structure. You can use LINQ with:
Here’s an example of using LINQ to filter a list of numbers:
List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
// Using LINQ to filter even numbers
var evenNumbers = numbers.Where(n => n % 2 == 0).ToList();
foreach (var num in evenNumbers)
{
Console.WriteLine(num); // Outputs: 2, 4, 6
}LINQ enhances productivity by allowing developers to express complex queries in a clear, concise manner, improving code maintainability.
string and StringBuilder are both used to handle text in C#, but they have different characteristics and use cases:
string str = "Hello";
str += " World"; // Creates a new string, "Hello World"StringBuilder sb = new StringBuilder("Hello");
sb.Append(" World"); // Modifies the existing instance
string result = sb.ToString(); // Convert back to stringUsing StringBuilder in scenarios with multiple concatenations can greatly enhance performance by reducing memory allocation overhead.
Generics in C# allow you to define classes, interfaces, and methods with a placeholder for the type of data they store or manipulate. This means you can create reusable code components that work with any data type without sacrificing type safety.
Benefits of Generics:
Example: Here’s a simple generic class:
public class GenericList<T>
{
private T[] items = new T[10];
private int count = 0;
public void Add(T item)
{
items[count++] = item;
}
public T Get(int index)
{
return items[index];
}
}
// Usage
var intList = new GenericList<int>();
intList.Add(1);
intList.Add(2);
var stringList = new GenericList<string>();
stringList.Add("Hello");
stringList.Add("World");The async and await keywords in C# are used to facilitate asynchronous programming, allowing developers to write code that can perform potentially long-running operations without blocking the main thread.
Example:
public async Task<string> DownloadDataAsync(string url)
{
using (var client = new HttpClient())
{
var response = await client.GetStringAsync(url);
return response;
}
}In this example, DownloadDataAsync will not block the calling thread while waiting for the web request to complete, improving responsiveness in applications.
Dependency Injection (DI) is a design pattern used in software development to achieve Inversion of Control (IoC) between classes and their dependencies. Rather than a class creating its own dependencies, they are provided to the class externally, typically through the constructor.
Benefits of Dependency Injection:
Example:
public interface IMessageService
{
void SendMessage(string message);
}
public class EmailService : IMessageService
{
public void SendMessage(string message)
{
// Code to send email
}
}
public class Notification
{
private readonly IMessageService _messageService;
public Notification(IMessageService messageService) // Dependency Injection
{
_messageService = messageService;
}
public void Notify(string message)
{
_messageService.SendMessage(message);
}
}In C#, an interface is a contract that defines a set of methods and properties without implementing them. Classes that implement the interface must provide implementations for all its members.
Defining an Interface:
public interface IAnimal
{
void Speak();
}Implementing an Interface:
public class Dog : IAnimal
{
public void Speak()
{
Console.WriteLine("Woof!");
}
}
public class Cat : IAnimal
{
public void Speak()
{
Console.WriteLine("Meow!");
}
}When a class implements an interface, it guarantees that it provides implementations for all methods defined in that interface. This enables polymorphism, allowing you to use interface types interchangeably.
Reflection is a feature in C# that allows you to inspect the metadata of types at runtime. This includes accessing information about classes, methods, properties, and other members, even if you don’t have compile-time access to them.
Common Uses of Reflection:
Example:
Type type = typeof(Dog);
Console.WriteLine("Methods of Dog class:");
foreach (var method in type.GetMethods())
{
Console.WriteLine(method.Name);
}This example retrieves and prints all methods defined in the Dog class using reflection.
Attributes in C# are a way to add metadata to your code elements (classes, methods, properties, etc.). They provide additional information that can be retrieved at runtime via reflection.
Attributes are defined by creating a class that derives from System.Attribute and can be applied to various elements of your code.
Example:
[AttributeUsage(AttributeTargets.Class)]
public class DeveloperAttribute : Attribute
{
public string Name { get; }
public DeveloperAttribute(string name)
{
Name = name;
}
}
[Developer("Alice")]
public class SampleClass
{
}In this example, the DeveloperAttribute is applied to SampleClass, adding metadata about the developer’s name. You can retrieve this information using reflection.
The IDisposable interface is used to provide a mechanism for releasing unmanaged resources (like file handles, database connections, etc.) when they are no longer needed. It includes a single method, Dispose(), which is called to free resources.
Implementing IDisposable: When a class implements IDisposable, it should provide the Dispose() method to clean up resources:
public class ResourceHolder : IDisposable
{
private bool disposed = false; // Track whether resources are disposed
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this); // Prevent finalizer from being called
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
// Free managed resources
}
// Free unmanaged resources
disposed = true;
}
}
~ResourceHolder() // Finalizer
{
Dispose(false);
}
}Using IDisposable is essential for managing resource cleanup effectively, especially in scenarios with unmanaged resources.
Extension methods allow you to add new methods to existing types without modifying the original type or creating a new derived type. They are defined as static methods in static classes and use the this keyword in the first parameter to specify the type being extended.
Example:
public static class StringExtensions
{
public static bool IsNullOrEmpty(this string str)
{
return string.IsNullOrEmpty(str);
}
}
// Usage
string name = null;
bool isEmpty = name.IsNullOrEmpty(); // Calling the extension methodIn this example, the IsNullOrEmpty method extends the string type, allowing you to call it as if it were a method on string instances.
Threading in C# allows multiple threads to run concurrently, enabling applications to perform tasks simultaneously. The System.Threading namespace provides classes for creating and managing threads.
You can create a new thread using the Thread class:
Thread thread = new Thread(new ThreadStart(MyMethod));
thread.Start();
void MyMethod()
{
// Code to run on the new thread
}Alternatively, you can use the Task class from the System.Threading.Tasks namespace, which provides a higher-level abstraction for working with threads:
Task.Run(() => MyMethod());Using Task is often preferred for its ease of use and better integration with async programming.
The Task and Thread classes in C# are both used for asynchronous programming, but they serve different purposes and have different characteristics:
Thread thread = new Thread(() => { /* Work */ });
thread.Start();Task task = Task.Run(() => { /* Work */ });In summary, use Task for asynchronous programming where you want to simplify concurrency management, and use Thread when you need fine-grained control over thread execution.
The lock statement in C# is used to ensure that a block of code runs exclusively by one thread at a time. It helps to prevent race conditions when multiple threads attempt to access shared resources simultaneously.
Syntax:
lock (object)
{
// Code to execute
}Example:
private static readonly object _lock = new object();
private static int _counter = 0;
public void IncrementCounter()
{
lock (_lock)
{
_counter++;
}
}In this example, when one thread is executing the code within the lock block, other threads attempting to enter this block will be blocked until the first thread exits. This ensures thread safety when incrementing the _counter variable.
The volatile keyword in C# is used to indicate that a field can be accessed by multiple threads. It tells the compiler and the runtime not to cache the value of that field in a register or optimize access to it, ensuring that every read/write operation goes directly to memory.
Use Case: The volatile keyword is typically used for simple fields that need to be accessed across threads without locking. However, it should be used with caution, as it does not provide complete thread safety.
Example:
private volatile bool _isRunning;
public void Stop()
{
_isRunning = false;
}
public void Start()
{
while (_isRunning)
{
// Do work
}
}In this example, _isRunning is marked as volatile to ensure that all threads see the latest value without caching.
In C#, working with JSON is commonly done using libraries like Newtonsoft.Json (Json.NET) or the built-in System.Text.Json library (available in .NET Core 3.0 and later). These libraries provide methods for serializing and deserializing JSON data.
Example with Newtonsoft.Json:
using Newtonsoft.Json;
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
// Serialization
var person = new Person { Name = "Alice", Age = 30 };
string json = JsonConvert.SerializeObject(person);
// Deserialization
var deserializedPerson = JsonConvert.DeserializeObject<Person>(json);Example with System.Text.Json:
using System.Text.Json;
// Serialization
var person = new Person { Name = "Alice", Age = 30 };
string json = JsonSerializer.Serialize(person);
// Deserialization
var deserializedPerson = JsonSerializer.Deserialize<Person>(json);Both libraries make it easy to convert between C# objects and JSON strings, allowing for easy data exchange in web applications and APIs.
A lambda expression is a concise way to represent anonymous methods in C#. It allows you to define inline functions that can be passed as arguments or used to create delegates.
Syntax:
(parameters) => expressionExample:
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
// Using a lambda expression with LINQ
var evenNumbers = numbers.Where(n => n % 2 == 0).ToList();In this example, n => n % 2 == 0 is a lambda expression that checks if a number is even. Lambda expressions are often used with LINQ for filtering, mapping, and reducing collections.
Anonymous types in C# allow you to create simple, unnamed types on the fly, primarily for grouping a set of related properties. They are defined using the new keyword and can contain read-only properties.
Example:
var person = new
{
Name = "Alice",
Age = 30
};
// Accessing properties
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");Anonymous types are particularly useful when you need to quickly encapsulate data without creating a formal class. However, they can only be used in the scope where they are created, and you cannot pass them as parameters or return them from methods.
Asynchronous programming in C# is typically implemented using the async and await keywords. This allows methods to perform time-consuming operations without blocking the calling thread, enhancing responsiveness, especially in UI applications.
Example:
public async Task<string> FetchDataAsync(string url)
{
using (var client = new HttpClient())
{
string result = await client.GetStringAsync(url);
return result;
}
}
// Calling the asynchronous method
var data = await FetchDataAsync("https://example.com");In this example, the FetchDataAsync method fetches data from a URL asynchronously. The await keyword is used to pause the execution until the data is received, allowing the calling thread to perform other tasks in the meantime.
The async keyword is used to declare an asynchronous method in C#. It allows the method to contain await expressions, which indicate that the method may perform an asynchronous operation. When an async method is called, it returns a Task or Task<T>, representing the ongoing operation.
Key Points:
Example:
public async Task<int> CalculateAsync()
{
await Task.Delay(1000); // Simulating a delay
return 42;
}You can prevent a class from being instantiated by using a private constructor. This is often used in singleton patterns or when creating static classes.
Example of a Static Class:
public static class Utility
{
public static void DoSomething() { }
}Example of a Singleton:
public class Singleton
{
private static Singleton _instance;
private Singleton() { } // Private constructor
public static Singleton Instance
{
get
{
if (_instance == null)
{
_instance = new Singleton();
}
return _instance;
}
}
}In this singleton example, the class cannot be instantiated from outside the class itself, ensuring that only one instance exists.
The singleton pattern is a design pattern that restricts a class to a single instance and provides a global point of access to that instance. It is commonly used for managing shared resources, such as configuration settings or database connections.
Implementation Steps:
Example:
public class Logger
{
private static Logger _instance;
private Logger() { }
public static Logger Instance
{
get
{
if (_instance == null)
{
_instance = new Logger();
}
return _instance;
}
}
public void Log(string message)
{
Console.WriteLine(message);
}
}In this example, Logger can only be instantiated once, and you can access it through Logger.Instance.
Both abstract classes and interfaces are used to define contracts for classes in C#, but they have distinct characteristics and use cases:
public abstract class Animal
{
public abstract void Speak(); // Abstract method
public void Sleep() { } // Concrete method
}public interface IAnimal
{
void Speak();
}Usage:
The observer pattern is a behavioral design pattern that defines a one-to-many dependency between objects so that when one object (the subject) changes state, all its dependents (observers) are notified and updated automatically.
Implementation Steps:
Example:
// Subject Interface
public interface ISubject
{
void Attach(IObserver observer);
void Detach(IObserver observer);
void Notify();
}
// Observer Interface
public interface IObserver
{
void Update(string message);
}
// Concrete Subject
public class NewsPublisher : ISubject
{
private List<IObserver> _observers = new List<IObserver>();
private string _news;
public void Attach(IObserver observer) => _observers.Add(observer);
public void Detach(IObserver observer) => _observers.Remove(observer);
public void Notify()
{
foreach (var observer in _observers)
{
observer.Update(_news);
}
}
public void PublishNews(string news)
{
_news = news;
Notify();
}
}
// Concrete Observer
public class NewsSubscriber : IObserver
{
public void Update(string message) => Console.WriteLine($"Received news: {message}");
}
// Usage
var publisher = new NewsPublisher();
var subscriber = new NewsSubscriber();
publisher.Attach(subscriber);
publisher.PublishNews("New design pattern article released!");IEnumerable and IQueryable are both interfaces used for querying collections in C#, but they have different purposes and behaviors:
IEnumerable<int> numbers = new List<int> { 1, 2, 3 }.Where(n => n > 1);IQueryable<int> queryableNumbers = dbContext.Numbers.Where(n => n > 1);In summary, use IEnumerable for in-memory collections and IQueryable for querying data from an external data source.
Handling large data sets in C# requires strategies to manage memory and optimize performance. Here are some common techniques:
var pageSize = 100;
var pageNumber = 1;
var pagedData = dbContext.Records.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList();A circular reference occurs when two or more objects reference each other, creating a cycle in the object graph. This can lead to memory leaks and issues with garbage collection if not handled properly.
Example:
public class A
{
public B BReference { get; set; }
}
public class B
{
public A AReference { get; set; }
}
// Usage
var a = new A();
var b = new B();
a.BReference = b;
b.AReference = a;In this example, A has a reference to B, and B has a reference back to A, creating a circular reference. To avoid issues, you can use weak references or design patterns like Dependency Injection to manage object lifetimes.
The yield keyword is used in C# to create an iterator, which allows you to define a method that can return a sequence of values one at a time, rather than all at once. This is useful for working with large collections or streams of data where you want to minimize memory usage.
Example:
public IEnumerable<int> GetNumbers(int count)
{
for (int i = 0; i < count; i++)
{
yield return i; // Return each value one at a time
}
}
// Usage
foreach (var number in GetNumbers(10))
{
Console.WriteLine(number);
}In this example, the GetNumbers method returns an IEnumerable<int> and produces numbers one by one, allowing the calling code to process each number without needing to load all of them into memory simultaneously.
