Top 300 .NET & Angular Interview Questions - Fullstack

Introduce the main oops concepts, illustrated by a diagram, and present questions on these concepts, suitable for any experience level, with about 40 minutes of content.

Explore the main concepts of oops, including objects, classes, inheritance, polymorphism, abstraction, and encapsulation, and learn how constructors, fields, properties, and methods define and use a class instance.

Define abstraction as doing only the required work while hiding background details, illustrated by a car driver and hidden methods like calculate basic salary and calculate HRA.

Encapsulation wraps data and methods into a single unit, using private fields and public properties to control access, as shown by an employee class example.

Polymorphism lets a variable or function take multiple forms, shown by method overloading with the same name but different parameters, including compile-time overloading and runtime overriding.

Explore method overloading, a dot net compile-time polymorphism where multiple methods share the same name but differ by parameter count, type, or order, as shown in add examples.

Explore difference between overloading and overriding, where overloading uses different signatures in one class and overriding uses the same signature across base and derived classes with virtual, override, and polymorphism.

Learn the difference between method overriding and method hiding, using virtual and override for base-to-derived behavior and the new keyword to hide base methods.

Explore the advantages of oops, including code reuse through inheritance, flexibility via polymorphism, data security with encapsulation, and modular upgrades, along with limitations for small apps.

Explore the most important interview questions, including the difference between abstract class and interface, split into five follow-up questions for a total of about 15 minutes.

Explore the differences between abstract classes and interfaces, including declaration versus definition, the abstract keyword, and multiple inheritance, noting interfaces may declare methods and, in newer versions, define them.

Explain when to use interface versus abstract class: use abstract class for concrete, shared methods, and an interface for a contract that may be implemented differently, enabling multiple inheritance.

Explore why interfaces matter by enforcing a contract across employee types, ensuring mandatory methods like set salary and set project, and maintaining consistency and extensibility with multiple inheritance.

Interfaces cannot have constructors and cannot be instantiated; they can only be derived from. A Visual Studio Code demo shows an error when adding a constructor to an interface.

Learn why you cannot instantiate abstract classes or interfaces in .NET. See the Visual Studio error, and understand how the abstract class constructor runs when a derived object is created.

Explore general oop and c-sharp interview questions, including boxing concepts, to prepare for top .NET and Angular fullstack interviews.

Learn C# access specifiers—public, private, protected, internal, and protected internal—and how they govern accessibility of class methods, properties, and fields. The default class modifier is internal.

Explore boxing and unboxing in C#. Convert value types to reference types and back, with explicit unboxing and implicit boxing, illustrated by int to object.

Differentiate between string and string builder in C#: strings are immutable and create new instances on modification, while string builders are mutable. Use string builder for modifications to improve performance.

Master basic string operations in C# by using concatenate with the concatenate method or the plus operator, replace, rim to remove trailing spaces, and contains to test for substrings.

Explain nullable types and how the question mark enables storing null values in value types, with code showing compile-time errors for non-nullable ints and how nullable types fix them.

Explore generics in C#, explaining how they make classes and methods type independent and type safe, avoid boxing, and improve performance, with examples of generic methods and a generic class.

Dive into exception handling with C-sharp as the introduction covers common questions on the topic. Practice through a series of questions spanning roughly 12 minutes of content.

Discover how to implement exception handling in C# with try, catch, finally, and throw, including error logging and ensuring code executes in all cases.

Handle multiple catch blocks in exception handling; only one catch executes for a given exception. Use multiple blocks to treat different errors differently or to keep the program running.

Explain the finally block and demonstrate how it executes regardless of exceptions, ensuring resources like a database connection are closed in all scenarios.

Demonstrates that a try block may run without a catch, but a finally block is required to ensure mandatory statements execute, even on early returns.

Explore the four main loop types in C#: while, do-while, for, and foreach, with their initialization, condition, and increment behavior, plus how foreach iterates collections.

Compare array and arraylist by highlighting that arrays are strongly typed with a fixed size, while arraylists store any type and grow without a fixed count.

Compare ArrayList and Hashtable by showing that ArrayList stores items only, while Hashtable stores key-value pairs; you can retrieve values directly by keys in Hashtable, an advanced version of ArrayList.

Discover how C# collections store and manage data, from normal collections such as ArrayList and Hashtable to generic collections like List and Dictionary, and concurrent collections for multithreading.

Explore how the IEnumerable interface enables for each loop iteration over collections in C#, including how List implements IEnumerable and how GetEnumerator supports both generic and non-generic iteration.

Explain the difference between IEnumerable and IEnumerator in C# by showing how foreach uses IEnumerable and how a custom collection implements IEnumerable and IEnumerator to enable iteration via GetEnumerator.

Compare IEnumerable and IQueryable to understand why IQueryable filters data at the database level for SQL queries, reducing network load and improving performance.

Explain how out and ref parameters pass by reference in C#, enabling multiple return values and modification of values. Out requires initialization before use; ref must be initialized before passing.

Explain how the params keyword lets a method accept a variable number of arguments by receiving them as an array, iterating with foreach, and handling unknown parameter counts.

Understand that a constructor is a class method automatically invoked when an instance is created. Learn the default, parameterized, copy, static, and private constructors in C#.

Use a private constructor in classes with only static members to prevent instantiation and inheritance, and apply it in the singleton design pattern.

Explore extension methods in C# to add behavior to existing classes without modifying their source, using static classes and the this binding to extend string with a right substring example.

Define a delegate as a reference to a method, and show when to use it to pass methods as parameters for operations like add and multiply.

Understand anonymous delegates in C#: inline logic with no named methods using the delegate keyword. The default return type is void, and they suit one or two methods, not many.

Explain the differences between delegates and events: delegates hold references to methods; events are notification mechanisms that depend on delegates. Events provide a security wrapper by abstracting the background functions.

Cover key c# and oop keywords such as using, is, as, readonly, static, dynamic, and enum in a 25-minute session that introduces top fullstack interview topics.

Learn how the this keyword in C# references the current instance, distinguishes fields from parameters, and prevents naming conflicts in class constructors.

Explore the purpose of the using keyword in C#: the using directive and the using statement that auto-disposes managed objects via IDisposable, with database connection examples.

Explain how the is operator checks an object's type and returns a boolean, while the as operator converts to a compatible reference type, such as object to string, in C#.

Explore the differences between read only and constant variables, including where they can be assigned (declaration vs constructor), runtime versus compile-time constants, and how parameterized constructors affect read only fields.

Define a static class as a container for static members, since it cannot be instantiated or inherited, and use it as a wrapper for static methods and constructors.

Compare var and dynamic in C#. Understand that var uses compile-time type inference, while dynamic uses runtime type checks.

Define a group of related constants with the enum keyword, access values like level.medium, and use zero-based numbering for weekdays to read and write constants across the application.

Explain that the global assembly cache (GAC) stores public assemblies for shared use. Showcase that private assemblies can be added to the GAC via the GACUtil tool to become public.

Serialize objects into binary, XML, or JSON formats to store or transmit them, then deserialize the data back into objects for use in applications, commonly via web APIs.

Define globalization as designing software to support multiple cultures and languages, and localization as adapting that globalized app to a specific culture locale, illustrated by adding a new language.

Cover garbage collection in .NET with five interview questions after reviewing .NET framework basics, highlighting the background processes behind it.

Learn how the CLR's garbage collector automatically manages memory by disposing unused objects, improving free memory, and handling allocation and release in .NET applications.

Understand how the .NET garbage collector uses generations to manage memory, promoting short-lived objects from generation zero to generation one and two, as generation zero is visited most often.

Explain the difference between dispose and finalize: finalize is automatic via the garbage collector, while dispose is explicit and often used with using statements to release unmanaged objects.

Differentiate between finalize and finally: finalize cleans up objects via garbage collection and is invoked automatically in the background, while the finally block executes code irrespective of exceptions.

Learn how to force garbage collection in .NET using GC.Collect, why it's discouraged for performance reasons, and how the dispose method releases only the objects you want.