![\"fsd](\"https:\/\/www.placementpreparation.io\/blog\/wp-content\/uploads\/2025\/01\/fsd-student-program-banner-horizontal.webp\")
<\/a><\/h2>Practice .NET Interview Questions and Answers<\/h2>
Below are the top 50 .NET interview questions for freshers with answers:<\/p>
1. What is .NET Framework?<\/h3>
Answer:<\/strong><\/p> .NET Framework is a software development framework created by Microsoft for building and running applications on Windows. It provides a consistent object-oriented programming environment with a rich set of libraries for building desktop, web, and mobile applications.<\/p> It supports multiple languages like C#, VB.NET, and F#, and includes the Common Language Runtime (CLR) for memory management, exception handling, and security. Answer:<\/strong><\/p> The Common Language Runtime (CLR) is the runtime environment in the .NET Framework that handles the execution of code. It provides services like memory management, garbage collection, security, and exception handling.<\/p> The CLR ensures that .NET applications run efficiently and securely by managing resources and enforcing code safety. Answer:<\/strong><\/p> .NET Framework is designed for building Windows applications, while .NET Core is a cross-platform framework for building modern cloud, IoT, and mobile applications. .NET Core is more modular and supports Linux, macOS, and Windows, unlike .NET Framework which is limited to Windows.<\/p> .NET Core offers better performance and scalability for microservices and cloud applications. Answer:<\/strong><\/p> The Garbage Collector (GC) in .NET automatically manages memory by freeing up unused objects from the heap. It reduces memory leaks and eliminates the need for developers to manually allocate and deallocate memory.<\/p> The GC works in generations (0, 1, and 2) to optimize the collection of short-lived and long-lived objects. Answer:<\/strong><\/p> An assembly is the building block of a .NET application. It is a compiled code library used by the CLR for deployment, versioning, and security. Assemblies can be DLLs (Dynamic Link Libraries) or EXE files.<\/p> Assemblies contain metadata and IL (Intermediate Language) code, and can be either private or shared (GAC – Global Assembly Cache). Answer:<\/strong><\/p> Managed code is executed by the CLR and benefits from features like garbage collection, security, and type safety. Unmanaged code is executed directly by the OS, without CLR intervention, and requires manual memory management.<\/p> Examples of unmanaged code include C++ programs or COM components. Answer:<\/strong><\/p> Boxing is the process of converting a value type to an object type, while unboxing converts an object type back to a value type. Boxing wraps the value inside an object, and unboxing extracts the value from the object.<\/p> Boxing and unboxing are expensive operations, as they involve memory allocation and copying. Answer:<\/strong><\/p> An interface defines a contract with no implementation, while an abstract class can contain both abstract methods (without implementation) and non-abstract methods (with implementation).<\/p> Interfaces support multiple inheritances, whereas a class can only inherit from one abstract class. Answer:<\/strong><\/p> LINQ (Language Integrated Query) is a query syntax in .NET for querying collections, databases, XML, and more. It provides a unified approach to querying different data sources using a consistent syntax.<\/p> LINQ allows developers to write queries in C# or VB.NET in a readable and efficient way. Answer:<\/strong><\/p> The Just-In-Time (JIT) compiler in .NET compiles the Intermediate Language (IL) code into machine code just before execution. This allows .NET applications to be platform-independent until runtime, where the IL code is converted to native machine code for the target platform.<\/p> The JIT optimizes performance by compiling only the code needed for execution. Answer:<\/strong><\/p> ADO.NET is a data access technology in .NET for interacting with databases. It provides classes to connect to databases, execute commands, retrieve results, and manage data.<\/p> ADO.NET supports connected and disconnected architectures using SqlConnection<\/strong>, SqlCommand<\/strong>, DataSet<\/strong>, and other classes. Answer:<\/strong><\/p> .NET Standard is a specification that defines a set of APIs that must be implemented by all .NET platforms (e.g., .NET Core, .NET Framework, Xamarin). It ensures compatibility across different .NET platforms, enabling developers to create libraries that work everywhere.<\/p> .NET Standard allows for greater code sharing between different platforms. Answer:<\/strong><\/p> Generics in .NET allow you to define classes, methods, and interfaces with type parameters. They provide type safety and performance by allowing code reusability without the need for boxing\/unboxing.<\/p> Generics are used in collections like List<T><\/strong>, Dictionary<TKey<\/strong>, TValue><\/strong>, etc. Answer:<\/strong><\/p> The Global Assembly Cache (GAC) is a repository in .NET that stores shared assemblies that can be used by multiple applications. Assemblies in the GAC are versioned, enabling applications to use specific versions of shared libraries.<\/p> Assemblies must be strongly named to be added to the GAC. Answer:<\/strong><\/p> Entity Framework (EF) is an Object-Relational Mapper (ORM) that allows developers to interact with databases using .NET objects instead of SQL queries. EF supports LINQ to query the database and simplifies CRUD operations.<\/p> Entity Framework makes data access more abstract, allowing developers to work with data as objects and properties. Answer:<\/strong><\/p> Task<\/strong> represents an asynchronous operation, while Thread<\/strong> represents a separate path of execution. Tasks in .NET are used for managing asynchronous operations and work at a higher level of abstraction than threads.<\/p> Tasks make it easier to handle parallelism and are optimized for resource management. Answer:<\/strong><\/p> async<\/strong> and await<\/strong> are used to write asynchronous code in .NET. The async<\/strong> modifier is applied to methods that perform asynchronous operations, and await<\/strong> is used to pause the execution until the awaited task is completed.<\/p> Async programming helps prevent blocking the main thread and improves responsiveness in applications. Answer:<\/strong><\/p> IEnumerable<\/strong> is used for iterating over in-memory collections and works well with LINQ-to-Objects. IQueryable<\/strong> is used for querying data sources, like databases, and performs queries on the server-side.<\/p> IQueryable<\/strong> provides better performance for large datasets because it generates database-specific queries, while IEnumerable<\/strong> fetches all data into memory before processing. Answer:<\/strong><\/p> .NET Core is a cross-platform, open-source framework for building modern applications, whereas .NET Framework is limited to Windows.<\/p> .NET Core supports cloud-based, IoT, and microservice architectures and offers better performance and scalability compared to .NET Framework.<\/p> .NET Core is modular and lightweight, making it suitable for containerized applications. Answer:<\/strong><\/p> ASP.NET Core is a cross-platform framework for building modern web applications. It is a modular framework that allows for high-performance and scalable applications. ASP.NET Core unifies MVC and Web API into a single framework.<\/p> ASP.NET Core supports dependency injection, middleware, and cross-platform deployment. Answer:<\/strong><\/p> Dependency Injection (DI) is a design pattern in which dependencies (services) are injected into a class, rather than being created inside the class. This promotes loose coupling and enhances testability and maintainability.<\/p> ASP.NET Core has built-in support for DI, allowing you to register services in the Startup.ConfigureServices()<\/strong> method. Answer:<\/strong><\/p> appsettings.json<\/strong> is used to store configuration settings for a .NET Core application. It contains settings like connection strings, API keys, and environment-specific configurations. The contents are loaded into the application’s configuration at runtime and can be accessed using the IConfiguration<\/strong> interface.<\/p> .NET Core supports environment-specific configurations through files like appsettings.Development.json.<\/strong> Answer:<\/strong><\/p> Extension methods allow you to add new methods to existing types without modifying the original class or creating a new derived type. They are defined as static methods in static classes, and the first parameter of the method specifies the type it extends.<\/p> Extension methods improve code readability and maintainability by adding functionality to existing types. Answer:<\/strong><\/p> The Task Parallel Library (TPL) in .NET provides a framework for parallel programming and efficient task management. It simplifies writing concurrent and asynchronous code by using Task<\/strong> objects to represent asynchronous operations.<\/p> TPL improves performance by utilizing multi-core processors and simplifying code structure for parallel operations. Answer:<\/strong><\/p> MVC (Model-View-Controller) is a design pattern used in ASP.NET Core and .NET Framework to separate an application’s concerns. The Model represents the data, the View displays the UI, and the Controller handles user input and interactions.<\/p> The MVC pattern promotes modularity and makes applications more maintainable by separating logic, UI, and data access. Answer:<\/strong><\/p> SignalR is a library in .NET used for adding real-time web functionality to applications. It enables the server to push content to connected clients instantly, supporting features like chat applications, live dashboards, and notifications.<\/p> SignalR abstracts communication technologies like WebSockets and Long Polling to provide real-time communication. Answer:<\/strong><\/p> A delegate in .NET is a type that represents references to methods with a specific signature. Delegates are used to pass methods as arguments to other methods and are the foundation of events and callback methods.<\/p> Delegates provide flexibility by allowing methods to be treated as first-class objects. Answer:<\/strong><\/p> A lambda expression is a concise way to represent anonymous methods in .NET. Lambda expressions are used extensively in LINQ queries, event handling, and asynchronous programming.<\/p> They provide a more readable and functional style of writing code, allowing inline definitions of small methods. Answer:<\/strong><\/p> An event in .NET is a way for objects to notify other objects when something of interest occurs. Events are based on delegates and follow the publisher-subscriber model, where an event is raised by one object (publisher), and other objects (subscribers) respond to it.<\/p> Events are commonly used in GUIs, where user actions like button clicks trigger events. Answer:<\/strong><\/p> REST (Representational State Transfer) is an architectural style for building web services that interact using HTTP methods like GET, POST, PUT, DELETE. RESTful services are stateless and use URLs to represent resources.<\/p> In .NET, REST APIs are typically implemented using ASP.NET Core or ASP.NET Web API, with methods mapped to HTTP verbs. Answer:<\/strong><\/p> async<\/strong> and await<\/strong> are used to simplify asynchronous programming in .NET. They allow methods to run asynchronously without blocking the main thread, making the application more responsive, especially for I\/O-bound tasks like network requests.<\/p> await<\/strong> is used to wait for the completion of an asynchronous operation, while async<\/strong> marks the method that contains asynchronous code.<\/p> csharp<\/p> Copy code Answer:<\/strong><\/p> A struct<\/strong> in .NET is a value type used to encapsulate small groups of related variables, such as the coordinates of a point. Unlike classes, structs<\/strong> are stored on the stack and have value semantics, meaning they are copied when passed to functions.<\/p> structs<\/strong> are suitable for small data objects and can be used for performance-critical operations. Answer:<\/strong><\/p> const<\/strong> defines a compile-time constant, while readonly<\/strong> defines a runtime constant that can only be assigned in the constructor. const<\/strong> fields are static and cannot be changed after compilation, while readonly<\/strong> fields can be initialized at runtime.<\/p> readonly<\/strong> is often used when the value needs to be constant after object creation but is not known at compile time. public MyClass(int minValue) { Answer:<\/strong><\/p> Attributes in .NET are used to add metadata to code elements such as classes, methods, or properties. Attributes provide additional information to the runtime or compiler, such as indicating obsolete code or requiring special permissions.<\/p> Attributes are placed directly above the code they affect and are processed at runtime via reflection. Answer:<\/strong><\/p> Reflection in .NET allows programs to inspect and manipulate their own metadata at runtime. It provides the ability to dynamically discover types, methods, properties, and fields in assemblies. Reflection is often used in frameworks, serialization, and for accessing private members of classes.<\/p> Reflection can also be used to create instances of types dynamically. Answer:<\/strong><\/p> Finalize<\/strong> is used for cleanup by the garbage collector and is automatically called when an object is being collected, whereas Dispose<\/strong> is explicitly called to release unmanaged resources before the object is collected.<\/p> Dispose<\/strong> is part of the IDisposable<\/strong> interface and provides a deterministic way to clean up resources like file handles or database connections. Answer:<\/strong><\/p> Arrays have a fixed size, while List<T><\/strong> is a dynamic collection that can grow or shrink as needed. Arrays can store elements of a specific type, whereas List<T><\/strong> is a generic class that allows for type-safe storage of elements with more flexible operations like Add<\/strong> and Remove.<\/strong><\/p> List<T><\/strong> also provides more built-in functionality for operations like searching, sorting, and filtering. Answer:<\/strong><\/p> A namespace<\/strong> is a way to organize and group related classes, interfaces, enums, and other elements in .NET. It helps prevent naming conflicts by distinguishing between classes with the same name but in different namespaces.<\/p> Namespaces provide a logical hierarchy and make code easier to maintain by grouping related functionality together. Answer:<\/strong><\/p> A sealed<\/strong> class in .NET cannot be inherited by other classes. It is useful when you want to prevent further derivation, typically for reasons related to security, performance, or design.<\/p> Sealing a class ensures that the class cannot be extended, which may enhance stability and prevent accidental overrides. Answer:<\/strong><\/p> The IDisposable<\/strong> interface defines a method Dispose()<\/strong> that is used to release unmanaged resources, such as file handles or database connections, when they are no longer needed.<\/p> It provides a standardized way to perform cleanup operations, and objects that use unmanaged resources should implement IDisposable.<\/strong> Answer:<\/strong><\/p> Asynchronous programming allows for non-blocking execution, meaning tasks can run in the background without stopping the main thread. It is implemented using async<\/strong> and await<\/strong> keywords in .NET.<\/p> This is especially useful for I\/O-bound operations, such as reading from files or making HTTP requests, as it prevents UI freezing or unnecessary thread blocking. Answer:<\/strong><\/p> Properties in .NET are members of a class that provide a flexible mechanism to access and modify data fields. They use get<\/strong> and set<\/strong> accessors to encapsulate the fields of a class.<\/p> Properties are a safer way to expose class data compared to public fields because you can control the logic in the get<\/strong> or set<\/strong> methods. Answer:<\/strong><\/p> Polymorphism in .NET is the ability of different classes to be treated as instances of the same base class. It allows one method to have different implementations based on the derived class.<\/p> Polymorphism can be achieved through method overriding (runtime polymorphism) and method overloading (compile-time polymorphism).
\n<\/p>
\nConsole.WriteLine(“Hello, .NET Framework!”);
\n<\/div><\/div>2. What is the CLR in .NET?<\/h3>
\n<\/p>
\nint number = 10;
\n<\/div><\/div>3. What is the difference between .NET Core and .NET Framework?<\/h3>
\n<\/p>
\ndotnet new console
\ndotnet run
\n<\/div><\/div>4. What is the purpose of the Garbage Collector (GC) in .NET?<\/h3>
\n<\/p>
\nvar obj = new MyClass();
\n<\/div><\/div>5. What are assemblies in .NET?<\/h3>
\n<\/p>
\ndotnet build
\n<\/div><\/div>6. What is the difference between managed and unmanaged code?<\/h3>
\n<\/p>
\nint x = 5;
\n<\/div><\/div>7. Explain the concept of boxing and unboxing in .NET.<\/h3>
\n<\/p>
\nint x = 10;
\nobject obj = x; \/\/ Boxing
\nint y = (int)obj; \/\/ Unboxing
\n<\/div><\/div>8. What is the difference between an interface and an abstract class in .NET?<\/h3>
\n<\/p>
\npublic interface IAnimal {
\nvoid MakeSound();
\n}
\n\/\/ Abstract class example
\npublic abstract class Animal {
\npublic abstract void MakeSound();
\npublic void Eat() {
\nConsole.WriteLine(“Eating”);
\n}
\n}
\n<\/div><\/div>9. What is LINQ in .NET?<\/h3>
\n<\/p>
\nint[] numbers = { 1, 2, 3, 4, 5 };
\nvar evenNumbers = from num in numbers
\nwhere num % 2 == 0
\nselect num;
\n<\/div><\/div>10. What is the role of the JIT compiler in .NET?<\/h3>
\n<\/p>
\nConsole.WriteLine(“JIT compiling…”);
\n<\/div><\/div>11. What is ADO.NET in .NET?<\/h3>
\n<\/p>
\nusing (SqlConnection connection = new SqlConnection(connectionString)) {
\nconnection.Open();
\nSqlCommand cmd = new SqlCommand(“SELECT * FROM Users”, connection);
\nSqlDataReader reader = cmd.ExecuteReader();
\n}
\n<\/div><\/div>12. What is .NET Standard?<\/h3>
\n<\/p>
\npublic class MyClass {
\npublic string Greet() {
\nreturn “Hello, .NET Standard!”;
\n}
\n}
\n<\/div><\/div>13. What are generics in .NET?<\/h3>
\n<\/p>
\npublic class Box<T> {
\npublic T Value { get; set; }
\n}
\n<\/div><\/div>14. What is the Global Assembly Cache (GAC) in .NET?<\/h3>
\n<\/p>
\ngacutil -i MyAssembly.dll
\n<\/div><\/div>15. What is Entity Framework in .NET?<\/h3>
\n<\/p>
\nusing (var context = new MyDbContext()) {
\nvar users = context.Users.ToList();
\n}
\n<\/div><\/div>16. What is the difference between Task and Thread in .NET?<\/h3>
\n<\/p>
\nTask.Run(() => Console.WriteLine(“Running asynchronously”));
\n<\/div><\/div>17. What is the role of async and await in .NET?<\/h3>
\n<\/p>
\npublic async Task<string> FetchDataAsync() {
\nawait Task.Delay(1000);
\nreturn “Data fetched”;
\n}
\n<\/div><\/div>18. What is the difference between IEnumerable and IQueryable in .NET?<\/h3>
\n<\/p>
\nvar query = dbContext.Users.Where(u => u.Age > 30);
\n<\/div><\/div>19. What is .NET Core, and how is it different from .NET Framework?<\/h3>
\n<\/p>
\ndotnet new console
\ndotnet run
\n<\/div><\/div>20. What is ASP.NET Core?<\/h3>
\n<\/p>
\npublic void Configure(IApplicationBuilder app) {
\napp.UseRouting();
\napp.UseEndpoints(endpoints => {
\nendpoints.MapControllers();
\n});
\n}
\n}
\n<\/div><\/div>21. What is Dependency Injection (DI) in .NET?<\/h3>
\n<\/p>
\npublic void ConfigureServices(IServiceCollection services) {
\nservices.AddScoped<IMyService, MyService>();
\n}
\n}
\n<\/div><\/div>22. What is the purpose of the appsettings.json file in .NET Core?<\/h3>
\n<\/p>
\n“ConnectionStrings”: {
\n“DefaultConnection”: “Server=localhost;Database=mydb;Trusted_Connection=True;”
\n}
\n}
\n<\/div><\/div>23. What are extension methods in .NET?<\/h3>
\n<\/p>
\npublic static class StringExtensions {
\npublic static bool IsNullOrEmpty(this string value) {
\nreturn string.IsNullOrEmpty(value);
\n}
\n}
\n<\/div><\/div>24. What is the Task Parallel Library (TPL) in .NET?<\/h3>
\n<\/p>
\nTask.Run(() => DoWork());
\n<\/div><\/div>25. What is MVC in .NET?<\/h3>
\n<\/p>
\npublic class HomeController : Controller {
\npublic IActionResult Index() {
\nreturn View();
\n}
\n}
\n<\/div><\/div>26. What is SignalR in .NET?<\/h3>
\n<\/p>
\npublic class ChatHub : Hub {
\npublic async Task SendMessage(string user, string message) {
\nawait Clients.All.SendAsync(“ReceiveMessage”, user, message);
\n}
\n}
\n<\/div><\/div>27. What is a delegate in .NET?<\/h3>
\n<\/p>
\npublic delegate void MyDelegate(string message);
\npublic void PrintMessage(string message) {
\nConsole.WriteLine(message);
\n}
\n<\/div><\/div>28. What is a lambda expression in .NET?<\/h3>
\n<\/p>
\nFunc<int, int, int> add = (a, b) => a + b;
\nConsole.WriteLine(add(5, 3)); \/\/ Output: 8
\n<\/div><\/div>29. What is an event in .NET, and how is it used?<\/h3>
\n<\/p>
\npublic class Button {
\npublic event EventHandler Clicked;
\npublic void OnClick() {
\nClicked?.Invoke(this, EventArgs.Empty);
\n}
\n}
\n<\/div><\/div>30. What is REST, and how do you implement it in .NET?<\/h3>
\n<\/p>
\n[HttpGet(“{id}”)]\npublic IActionResult GetItem(int id) {
\nvar item = _repository.GetItemById(id);
\nreturn Ok(item);
\n}
\n<\/div><\/div>31. What is async and await in .NET, and why are they important?<\/h3>
\n<\/p>
\npublic async Task<string> GetDataAsync() {
\nawait Task.Delay(1000);
\nreturn “Data loaded”;
\n}
\n<\/div><\/div>32. What is a struct in .NET?<\/h3>
\n<\/p>
\npublic struct Point {
\npublic int X;
\npublic int Y;
\n}
\n<\/div><\/div>33. What is the difference between const and readonly in .NET?<\/h3>
\n<\/p>
\npublic const int MaxValue = 100;
\npublic readonly int MinValue;\n
\nMinValue = minValue;
\n}
\n<\/p><\/div><\/div>34. What are attributes in .NET?<\/h3>
\n<\/p>
\n\/\/ Old code
\n}
\n<\/div><\/div>35. What is reflection in .NET?<\/h3>
\n<\/p>
\nType type = typeof(MyClass);
\nMethodInfo method = type.GetMethod(“MyMethod”);
\nobject result = method.Invoke(myClassInstance, null);
\n<\/div><\/div>36. What is the difference between finalize and dispose in .NET?<\/h3>
\n<\/p>
\npublic void Dispose() {
\n\/\/ Clean up resources
\n}
\n<\/div><\/div>37. What are the key differences between List and Array in .NET?<\/h3>
\n<\/p>
\nList<int> numbers = new List<int> { 1, 2, 3 };
\nnumbers.Add(4);
\n<\/div><\/div>38. What is a namespace in .NET, and why is it important?<\/h3>
\n<\/p>
\nnamespace MyApplication {
\npublic class MyClass {
\npublic void MyMethod() {
\nConsole.WriteLine(“Hello from MyClass”);
\n}
\n}
\n}
\n<\/div><\/div>39. What is a sealed class in .NET?<\/h3>
\n<\/p>
\npublic sealed class MyClass {
\npublic void DisplayMessage() {
\nConsole.WriteLine(“This is a sealed class”);
\n}
\n}
\n<\/div><\/div>40. What is the IDisposable interface in .NET?<\/h3>
\n<\/p>
\npublic class ResourceHolder : IDisposable {
\npublic void Dispose() {
\n\/\/ Clean up resources
\n}
\n}
\n<\/div><\/div>41. What is asynchronous programming, and how is it implemented in .NET?<\/h3>
\n<\/p>
\npublic async Task<string> GetDataAsync() {
\nawait Task.Delay(1000); \/\/ Simulates async work
\nreturn “Data fetched”;
\n}
\n<\/div><\/div>42. What are properties in .NET?<\/h3>
\n<\/p>
\npublic class Person {
\nprivate string _name;
\npublic string Name {
\nget { return _name; }
\nset { _name = value; }
\n}
\n}
\n<\/div><\/div>43. What is polymorphism in .NET?<\/h3>
\n<\/p>