Question 1

What is the difference between VB.NET and C#?

Accepted Answer

In short: Both compile to the same IL and run on the same CLR with the same libraries, so performance is the same. Differences are syntax and features: VB.NET uses English-like keywords, is case-insensitive, line-based with End blocks, has XML literals, My namespace, WithEvents/Handles and optional late binding; C# uses C-style syntax, is case-sensitive and gets new language features every year while VB.NET has been feature-stable since 2020. Most new projects use C#; VB.NET is mainly maintained in legacy systems.

Question 2

What do Option Strict, Option Explicit and Option Infer do?

Accepted Answer

In short: Option Explicit On requires variables to be declared. Option Strict On disallows implicit narrowing conversions and late binding — catching type errors at compile time (strongly recommended). Option Infer On lets Dim x = 5 infer the type from the initializer. Set them per project (Compile settings) or per file at the top.

Question 3

What is the difference between Sub and Function?

Accepted Answer

In short: A Sub performs an action and returns no value (C# void method). A Function returns a value with Return (or by assigning to the function name in old code). Both can take ByVal/ByRef, Optional and ParamArray parameters.

Question 4

ByVal vs ByRef?

Accepted Answer

In short: ByVal (the default) passes a copy of the value — for reference types, a copy of the reference, so the method can modify the object but not replace the caller s variable. ByRef passes the variable itself, so assigning a new value inside the method changes the caller s variable (C# ref ).

Question 5

And vs AndAlso, Or vs OrElse?

Accepted Answer

In short: And / Or always evaluate both operands (and also act as bitwise operators on integers). AndAlso / OrElse short-circuit: the second operand is evaluated only if needed. Use AndAlso for conditions like If obj IsNot Nothing AndAlso obj.IsActive Then to avoid NullReferenceException.

Question 6

How are events handled in VB.NET?

Accepted Answer

In short: Declare with Event , raise with RaiseEvent . Subscribe statically by declaring the field WithEvents and adding a Handles obj.EventName clause to the handler (common in WinForms/Web Forms code-behind), or dynamically with AddHandler obj.Event, AddressOf Handler and RemoveHandler (like C# += / -= ).

Question 7

DirectCast vs CType vs TryCast?

Accepted Answer

In short: DirectCast performs a type cast requiring an inheritance/interface relationship and throws InvalidCastException on failure (fast, like C# (T)x ). CType performs any defined conversion including VB conversions (string to integer) and user-defined conversions. TryCast returns Nothing instead of throwing (reference types only, like C# as ).

Question 8

You must maintain a large VB.NET Web Forms app and gradually move it to modern .NET. What is your plan?

Accepted Answer

In short: Stabilise first: source control, Option Strict On, logging, tests on critical flows. Extract business logic from code-behind into class libraries (VB or new C#), target netstandard2.0 where possible so both old and new apps can use them. Put a reverse proxy (YARP/IIS ARR) in front and rebuild pages/features in ASP.NET Core (C#) one area at a time, sharing authentication and the database (strangler fig). Retire Web Forms pages as their replacements go live.

Question 9

What is the difference between a value type and a reference type?

Accepted Answer

A value type variable holds the data itself ( int , bool , decimal , DateTime , any struct / enum ). Assigning it copies the value. A reference type variable holds a reference to an object on the managed heap ( class , string , arrays, delegates, record ). Assigning it copies the reference, so two variables can point to the same object. csharp Copy var a = new List int (); var b = a; b.Add( 1 ); // a.Count == 1 — same object int x = 1 ; int y = x; y++; // x is still 1 Value types are stored inline (stack for locals, inside the parent object for fields); reference-type objects always live on the heap and are cleaned up by the GC.

Question 10

What is the difference between string and StringBuilder?

Accepted Answer

In short: string is immutable : every concatenation creates a new string object, so building a string in a loop causes many allocations (O(n²) copying). StringBuilder keeps a mutable buffer and appends in place; call ToString() once at the end. Use StringBuilder for loops or many appends, plain strings/interpolation for a handful of pieces.

Question 11

Explain const vs readonly vs static readonly.

Accepted Answer

const : compile-time constant, implicitly static, only primitives/strings; the value is baked into callers at compile time. readonly : instance field assigned at declaration or in a constructor; can differ per object. static readonly : one value per type, computed at runtime (e.g. static readonly HttpClient Client = new() ). Gotcha: if library A has public const int Max = 10 and app B uses it, changing it to 20 in A does nothing in B until B is recompiled. Use static readonly for values that may change.

Question 12

What are boxing and unboxing? Why avoid them?

Accepted Answer

In short: Boxing converts a value type to object (or an interface) by allocating a heap object and copying the value; unboxing casts it back to the exact value type. It costs an allocation, a copy and GC pressure. Typical sources: non-generic collections ( ArrayList ), string.Format with value-type arguments on old APIs, calling interface methods on structs via the interface. Generics remove most boxing.

Question 13

What is the difference between == and .Equals()?

Accepted Answer

In short: For reference types , == compares references unless the operator is overloaded; Equals() is virtual and can be overridden to compare content. string overloads both to compare text. Records generate value-based Equals and == . For value types, Equals compares content. When you override Equals , also override GetHashCode (objects that are equal must have the same hash code, or dictionaries break).

Question 14

What are ref, out and in parameters?

Accepted Answer

All three pass an argument by reference : ref — must be initialised before the call; the method can read and change it. out — need not be initialised; the method must assign it (used by TryParse ). in — read-only reference; avoids copying large structs.

Question 15

Why should you use decimal instead of double for money?

Accepted Answer

In short: double is binary floating point and can t represent many base-10 fractions exactly (0.1 + 0.2 != 0.3), so totals drift by tiny amounts that show up in invoices and reports. decimal stores base-10 digits exactly with 28–29 significant digits. Trade-off: decimal is slower and uses 16 bytes, so use double for scientific/graphics maths and decimal for money and quantities that must add up exactly. In SQL Server map it to DECIMAL(18,2) , not FLOAT .

Question 16

What is the difference between Parse, TryParse and Convert?

Accepted Answer

In short: int.Parse( x ) throws FormatException for bad input (and ArgumentNullException for null). int.TryParse(s, out var n) returns false instead of throwing — use it for user input. Convert.ToInt32(value) accepts many types (object, double, string), returns 0 for null , and rounds doubles to the nearest even number ( Convert.ToInt32(2.5) → 2) whereas a cast truncates ( (int)2.9 → 2). Pass a CultureInfo when parsing numbers and dates from files or APIs.

Question 17

What is the difference between Dictionary and Hashtable?

Accepted Answer

In short: Dictionary TKey,TValue is generic: type-safe, no boxing, faster; a missing key with the indexer throws KeyNotFoundException (use TryGetValue ). Hashtable is the old non-generic version storing object keys/values: needs casts, boxes value types, and returns null for a missing key. Both are hash tables with O(1) average lookup. For multiple threads use ConcurrentDictionary .

Question 18

What is the difference between a multidimensional and a jagged array?

Accepted Answer

In short: A multidimensional (rectangular) array int[,] is one object where every row has the same length, accessed as a[r, c] . A jagged array int[][] is an array of arrays — each row is a separate array and can have a different length, accessed as a[r][c] . Jagged arrays are more flexible and often faster in .NET; rectangular arrays suit fixed grids such as matrices.

Question 19

Explain IEnumerable, ICollection, IList and IQueryable.

Accepted Answer

IEnumerable T : forward-only iteration ( foreach ), deferred execution with LINQ to Objects, runs in memory . ICollection T : adds Count , Add , Remove , Contains . IList T : adds index access and Insert . IQueryable T : builds an expression tree that a provider (EF Core) translates to SQL and runs in the database . csharp Copy db.Orders.Where(o = o.Total 100 ).ToList(); // IQueryable: WHERE in SQL db.Orders.AsEnumerable().Where(o = o.Total 100 ).ToList(); // loads ALL rows then filters in memory

Question 20

What are delegates and events? How do they differ?

Accepted Answer

In short: A delegate is a type-safe function pointer ( Func , Action , custom delegate ). It can be multicast. An event wraps a delegate so outside code can only += / -= handlers; only the declaring class can raise it. This prevents subscribers from wiping out other handlers ( = null ) or raising the event themselves. Pattern: `public event EventHandler ? Changed; and raise with Changed?.Invoke(this, args)`.

Question 21

How does async/await work internally? Does it create a new thread?

Accepted Answer

In short: No new thread is created by await . The compiler turns the method into a state machine . When it hits await on an incomplete task, the method returns to its caller and the thread goes back to the pool. When the I/O completes, a continuation resumes the state machine — on the captured synchronisation context if there is one (UI thread), otherwise on a thread-pool thread. CPU-bound work still needs Task.Run or parallelism to move off the current thread.

Question 22

What is the difference between Task.WhenAll and awaiting tasks one by one?

Accepted Answer

In short: Awaiting sequentially makes total time the sum of the calls; starting all tasks and then await Task.WhenAll(...) makes it roughly the longest single call. WhenAll throws the first exception when awaited, but the returned task s Exception holds all of them. Use WhenAny for first to finish or timeouts.

Question 23

Why is async void dangerous?

Accepted Answer

In short: Callers can t await it, so they can t know when it finishes, and an exception thrown inside crashes the process (it is raised on the synchronisation context instead of being stored in a Task). Use async Task everywhere except event handlers.

Question 24

What is IDisposable and the using statement? Dispose vs Finalize?

Accepted Answer

In short: IDisposable.Dispose() releases unmanaged resources (connections, file handles) deterministically . using guarantees Dispose is called even if an exception is thrown (compiles to try/finally ). A finaliser is called by the GC at an unpredictable time and costs an extra GC cycle; it is only a safety net for raw unmanaged handles. In Dispose call GC.SuppressFinalize(this) if a finaliser exists. Most code just wraps SafeHandle and never writes a finaliser.

Question 25

Explain garbage collection generations.

Accepted Answer

In short: The heap is split into Gen 0 (new objects, collected very often and cheaply), Gen 1 (survivors of Gen 0, a buffer), and Gen 2 (long-lived objects, collected rarely and expensively). Most objects die young, so collecting Gen 0 frequently is efficient. Objects of 85,000 bytes or more go to the Large Object Heap , collected with Gen 2. .NET has workstation and server GC modes, plus background (concurrent) GC for Gen 2.

Question 26

How do you create a custom exception, and when should you?

Accepted Answer

In short: Derive from Exception , end the name with Exception , provide the standard constructors (parameterless, message, message + inner exception) plus constructors/properties for useful data (e.g. Balance , Requested ). Create one only when callers need to catch that specific situation (e.g. InsufficientFundsException → show a friendly message or return 409); otherwise throw the built-in ones ( ArgumentException , InvalidOperationException ). Always pass the inner exception when wrapping.

Question 27

How do you make code thread-safe? Compare lock, Monitor, SemaphoreSlim, Interlocked and concurrent collections.

Accepted Answer

lock (sugar for Monitor.Enter/Exit ): mutual exclusion inside one process, synchronous only. SemaphoreSlim : limits concurrency to N and supports WaitAsync , so use it when you must await inside the critical section. Interlocked : atomic operations on single variables (increment, compare-exchange), lock-free. ConcurrentDictionary / ConcurrentQueue / Channel T : built-in thread-safe structures. Immutability: data that never changes needs no locks. Across processes/servers: database locks, distributed locks (Redis, blob leases), Mutex for the same machine.

Question 28

What causes a deadlock with async code and how do you avoid it?

Accepted Answer

In short: Classic case: in a UI app or old ASP.NET (with a synchronisation context), code calls task.Result . The blocked thread holds the context; the awaited method s continuation needs the same context to resume, so both wait forever. Fixes: go async all the way ( await instead of .Result ), use ConfigureAwait(false) in library code, and never mix blocking and async calls. ASP.NET Core has no synchronisation context, but blocking still causes thread-pool starvation under load.

Question 29

A method builds a CSV of 200,000 rows using += on a string and takes minutes. What do you do?

Accepted Answer

In short: String concatenation in a loop copies the whole string every time, so the work is O(n²). Replace it with a StringBuilder , or better, stream the rows straight to the output ( StreamWriter , or PipeWriter in ASP.NET Core) so the full file is never held in memory. Measure before and after with a stopwatch or BenchmarkDotNet. For huge exports, page the database query and write as you read.

Question 30

Your API's memory keeps growing until the pod restarts. How would you investigate?

Accepted Answer

Confirm the trend with dotnet-counters (GC heap size, Gen 2 count, LOH size). Take memory dumps a few minutes apart with dotnet-dump collect (or dotnet-gcdump ) and compare which types grow, using Visual Studio, PerfView or dotnet-dump analyze ( dumpheap -stat , gcroot ). Usual culprits: static collections or caches with no eviction, event handlers never unsubscribed, HttpClient created per request, undisposed streams/DbContexts, large byte arrays on the LOH, unbounded MemoryCache . Fix (size-limited cache, IHttpClientFactory , using , weak events), then load-test to confirm.

Question 31

Two users update the same in-memory counter and some increments are lost. Why, and how do you fix it?

Accepted Answer

In short: count++ is read, add, write — three steps. Two threads can read the same value and both write value+1, so one increment is lost (a race condition). Fix with Interlocked.Increment(ref count) , a lock , or a concurrent type. If the counter must survive restarts or work across several servers, keep it in the database (`UPDATE ... SET Count = Count + 1 ) or in Redis INCR` instead.

Question 32

What is the CLR and what does it do?

Accepted Answer

In short: The Common Language Runtime is .NET s execution engine. It loads assemblies, verifies type safety, JIT-compiles IL to native code, manages memory with the garbage collector, handles exceptions, threads and synchronisation, provides interop with native code and exposes debugging/profiling services. Code running under it is managed code .

Question 33

What are CTS and CLS?

Accepted Answer

In short: CTS (Common Type System) defines how types are declared and used in .NET — value vs reference types, inheritance, members, visibility — so all languages share one type system (C# int = VB.NET Integer = System.Int32 ). CLS (Common Language Specification) is a subset of CTS rules that every .NET language supports, so a CLS-compliant library can be used from any language (e.g. avoid public unsigned types or names differing only in case).

Question 34

What is IL (MSIL/CIL) and what does the JIT do?

Accepted Answer

In short: IL is the CPU-independent, stack-based intermediate code the C#/VB.NET compilers produce, stored with metadata in assemblies. At runtime the JIT compiles each method s IL to native machine code on its first call, optimised for the actual CPU; tiered compilation starts with quick code and re-compiles hot methods with full optimisation. ReadyToRun and Native AOT precompile to reduce startup time.

Question 35

What is the difference between .NET Framework, .NET Core and .NET 5+?

Accepted Answer

In short: .NET Framework (2002–2019) is Windows-only, installed machine-wide, and now only maintained (4.8.1 last); it has Web Forms, WCF and WWF. .NET Core (2016–2019) was the open-source, cross-platform, high-performance rewrite. .NET 5 (2020) onward unifies them as simply .NET , released every November with LTS versions (6, 8, 10) supported for 3 years. New projects use .NET 8/10.

Question 36

What is managed vs unmanaged code?

Accepted Answer

In short: Managed code runs under the CLR, which handles memory (GC), type safety and exceptions — C#, VB.NET, F#. Unmanaged code runs directly on the OS without the CLR — C/C++ DLLs, Win32 APIs, COM components — and manages its own memory. .NET calls unmanaged code via P/Invoke or COM interop; resources from it must be released with IDisposable / SafeHandle .

Question 37

What is an assembly? What does it contain?

Accepted Answer

In short: The unit of deployment and versioning in .NET — a .dll or .exe containing IL code, metadata describing all types and members, a manifest (name, version, culture, public key token, references) and optional resources. Assemblies can be private (in the app folder), shared in the GAC (.NET Framework) or satellite (localised resources).

Question 38

Explain how the garbage collector works. What are generations?

Accepted Answer

In short: The GC allocates objects by bumping a pointer and, when the gen-0 budget is used up, suspends threads, marks all objects reachable from roots (stack, statics, handles), compacts survivors and updates references. Generations: gen 0 for new objects (collected often and cheaply), gen 1 as a buffer, gen 2 for long-lived objects (full, expensive collections). Large objects (≥ 85,000 bytes) go to the LOH, collected with gen 2 and not compacted by default.

Question 39

Dispose vs Finalize — what's the difference? What is the Dispose pattern?

Accepted Answer

In short: Dispose (from IDisposable ) is called deterministically by your code ( using ) to release resources early; a finalizer ( ~Class() ) is called non-deterministically by the GC s finalizer thread as a safety net for unmanaged resources and makes objects survive an extra GC. The Dispose pattern: Dispose() calls Dispose(true) and GC.SuppressFinalize(this) ; the finalizer calls Dispose(false) ; Dispose(bool disposing) frees managed resources only when disposing is true and unmanaged resources always. Prefer SafeHandle over writing finalizers.

Question 40

Where are value types and reference types stored?

Accepted Answer

In short: Reference-type objects are always on the managed heap; variables hold references to them. Value types are stored inline where they are declared: on the stack (or in registers) for locals, inside the containing object for fields, inside the array for array elements, and on the heap when boxed or captured by closures/async methods. So value types live on the stack is only partly true.

Question 41

Workstation vs Server GC?

Accepted Answer

In short: Workstation GC uses one heap and runs collections on the allocating thread — lower memory and shorter pauses, suited to desktop apps. Server GC creates one heap and one dedicated GC thread per logical core and collects in parallel — higher throughput and allocation rates, more memory, the default for ASP.NET Core. Both support background (concurrent) gen-2 collection; .NET 9 enables DATAS to adapt Server GC heap count to load.

Question 42

How do you find a memory leak in a production .NET application?

Accepted Answer

In short: Confirm growth with dotnet-counters / Application Insights (GC heap size and gen-2 size rising, gen-2 collections not reclaiming). Capture heap snapshots ( dotnet-gcdump ) or full dumps ( dotnet-dump ) at two points in time, compare object counts by type, and find the roots keeping them alive ( gcroot , paths to root ). Typical culprits: unbounded static caches, event handlers not unsubscribed, timers, captive dependencies in DI, undisposed resources, LOH fragmentation from large buffers.

Question 43

An ASP.NET Core API's memory grows steadily until the container is OOM-killed every few hours. What do you do?

Accepted Answer

In short: Monitor GC counters to see if the managed heap (gen 2/LOH) grows or native memory grows. Take two dotnet-gcdump snapshots and compare the biggest growing types; check their roots. Common findings: an in-memory cache without limits, a singleton holding scoped objects or request data, event subscriptions, HttpClient created per request, large response buffering in the LOH. Also set container memory limits correctly (GC respects them), consider DATAS/workstation GC for small containers, and add alerts on memory growth.

Question 44

Explain the ASP.NET Web Forms page life cycle.

Accepted Answer

In short: Page request → start (IsPostBack set) → PreInit (set master/theme, create dynamic controls) → Init (controls initialised) → InitComplete → load ViewState and postback data (postbacks) → PreLoad → Load (page then controls; load data in !IsPostBack ) → control events (change events, then the Click that caused the postback) → LoadComplete → PreRender (final changes) → SaveStateComplete (ViewState saved) → Render (HTML written) → Unload (cleanup). Mnemonic SILVER: Start, Init, Load, Validate, Event, Render.

Question 45

What is ViewState? Pros and cons?

Accepted Answer

In short: A hidden form field ( __VIEWSTATE ) holding base64-encoded, MAC-signed state of controls (and your own values) so they survive postbacks of the same page without server memory. Pros: automatic, per-page, no server storage. Cons: increases page size and request time, not secure by default (only signed, not encrypted), can t be used across pages. Disable it where unnecessary and never store sensitive data.

Question 46

What is PostBack and IsPostBack?

Accepted Answer

In short: A postback is the form submitting back to the same page so server-side events (button clicks, selection changes) can run. IsPostBack is false on the first request and true on postbacks — load initial data only when !IsPostBack , otherwise you overwrite the user s input and waste database calls.

Question 47

What state management options exist in ASP.NET?

Accepted Answer

In short: Client-side: ViewState, ControlState, hidden fields, cookies, query strings. Server-side: Session (InProc, StateServer, SQLServer, custom), Application, Cache, Profile. Choose by scope (page, user, all users), size, security and whether it must survive restarts or work in a web farm.

Question 48

Response.Redirect vs Server.Transfer?

Accepted Answer

In short: Response.Redirect sends a 302 to the browser, which makes a new request — URL changes, works for any URL, an extra round trip, previous page data lost unless passed. Server.Transfer switches execution to another page on the server within the same request — URL in the browser stays the same, faster, can access the previous page ( PreviousPage ), only within the same application.

Question 49

What are the Session state modes? Which would you use in a web farm?

Accepted Answer

In short: InProc (in the worker process memory — fastest, lost on app-pool recycle, not shared), StateServer (aspnet_state service — survives recycles, shared, serialisation needed), SQLServer (stored in SQL — durable, shared, slower), Custom (e.g. Redis provider), Off. In a web farm use SQLServer, StateServer or a Redis custom provider (or sticky sessions as a weaker alternative).

Question 50

User control vs custom control?

Accepted Answer

In short: A user control (.ascx) is markup + code-behind built visually and reused within one application (registered with @Register Src= ). A custom (server) control is a class deriving from Control / WebControl / CompositeControl that renders its own HTML, compiled into a DLL, reusable across applications, can appear in the Toolbox and support design-time features — more work to build.

Question 51

What are master pages and how do content pages use them?

Accepted Answer

In short: A master page ( .master ) defines a shared layout with ContentPlaceHolder s; content pages specify MasterPageFile and fill placeholders with asp:Content . At runtime the master page is merged into the page s control tree (as a child control). Access it with Master (strongly typed via @MasterType ), switch it dynamically in PreInit , nest masters for sections.

Question 52

What is the role of Global.asax and web.config?

Accepted Answer

In short: Global.asax holds application-level event handlers: Application_Start/End, Session_Start/End, BeginRequest, AuthenticateRequest, Application_Error. Web.config holds hierarchical configuration: connection strings, app settings, authentication/authorization, session, custom errors, modules/handlers, compilation; changes restart the app.

Question 53

A Web Forms page with a big GridView is very slow to post back. How do you fix it?

Accepted Answer

In short: Measure page size: ViewState of the GridView is likely hundreds of KB. Disable ViewState on the grid and rebind on postback, or keep only keys; use server-side paging (load only the current page from the database) instead of binding thousands of rows; replace UpdatePanels around the grid with lighter AJAX calls if needed; cache reference data; check SQL queries and session locking.

Question 54

You must add a new feature to a legacy Web Forms app while the company plans to move to ASP.NET Core. How do you build it?

Accepted Answer

In short: Put the business logic in a separate class library (netstandard2.0 or .NET Framework library with clean interfaces) and unit-test it; keep code-behind thin, calling services. If the feature is a new area, consider building it directly in the new ASP.NET Core app behind a reverse proxy sharing authentication (strangler pattern), so it doesn t need to be migrated later.

Question 55

What is MVC? Explain Model, View and Controller.

Accepted Answer

In short: An architectural pattern separating concerns: the Model holds data and business rules, the View renders the UI (Razor templates), and the Controller receives requests, works with the model/services and chooses the response. Benefits: testable controllers, clean URLs, full HTML control, parallel work on UI and logic.

Question 56

Explain the ASP.NET MVC 5 request life cycle.

Accepted Answer

In short: Request → IIS/ASP.NET pipeline → UrlRoutingModule matches a route → MvcRouteHandler → MvcHandler → controller factory creates the controller → ControllerActionInvoker selects the action → authentication and authorization filters → model binding and validation → action filters (before) → action executes and returns an ActionResult → action filters (after) → result filters → result executes (ViewResult → Razor view engine finds and renders the view) → response. Exception filters handle errors along the way.

Question 57

Describe the MVC 5 folder structure.

Accepted Answer

Controllers (classes ending in Controller), Models , Views/ Controller / Action .cshtml with Views/Shared for layouts/partials and _ViewStart.cshtml , App_Start (RouteConfig, FilterConfig, BundleConfig, IdentityConfig), Areas for modules with their own MVC folders, Content (CSS), Scripts (JS), App_Data , Global.asax for startup, Web.config (plus Views/web.config for Razor settings).

Question 58

ViewData vs ViewBag vs TempData?

Accepted Answer

In short: ViewData is a string-keyed dictionary and ViewBag a dynamic wrapper over the same data — both live only for the current request (controller → view). TempData survives until it is read in a subsequent request (stored in session by default), so it s used for messages after a redirect; Keep / Peek retain it longer. Prefer strongly typed view models for real data.

Question 59

What types of ActionResult are there?

Accepted Answer

In short: ViewResult ( View ), PartialViewResult, RedirectResult/RedirectToRouteResult ( Redirect , RedirectToAction ), JsonResult, ContentResult, FileResult ( File ), JavaScriptResult, HttpStatusCodeResult/HttpNotFoundResult, EmptyResult. Actions can also return plain types, which are converted to ContentResult.

Question 60

What are filters in MVC? Name the types and their order.

Accepted Answer

In short: Attributes/classes that run logic before or after stages of action execution: authentication filters, authorization filters ( [Authorize] ), action filters ( OnActionExecuting/Executed ), result filters ( OnResultExecuting/Executed ) and exception filters ( [HandleError] ). Order: authentication → authorization → action → result, with exception filters on errors; they can be applied globally, per controller or per action.

.NET Framework / Legacy App Developer — Interview Questions