DEV Community: DIVAKAR UPADHYAY

Core objects and the connected model — ADO.NET

DIVAKAR UPADHYAY — Sun, 08 Nov 2026 06:12:34 +0000

Lesson 1 of 9 in the free ADO.NET — Connected & Disconnected Data Access course on DevLadder.

Object	Role
`SqlConnection`	Connection to the DB (pooled)
`SqlCommand`	SQL statement or stored procedure
`SqlParameter`	Typed parameter value — prevents SQL injection
`SqlDataReader`	Fast, forward-only, read-only stream of rows
`SqlDataAdapter`	Bridge between DB and `DataSet`
`DataSet` / `DataTable`	In-memory relational data
`SqlTransaction`	Groups commands atomically
`SqlBulkCopy`	High-speed bulk insert

const string cs = "Server=.;Database=Shop;Integrated Security=True;TrustServerCertificate=True";

await using var conn = new SqlConnection(cs);
await conn.OpenAsync(ct);

await using var cmd = new SqlCommand("SELECT Id, Name, Price FROM Products WHERE CategoryId = @cat", conn);
cmd.Parameters.Add("@cat", SqlDbType.Int).Value = categoryId;

await using var reader = await cmd.ExecuteReaderAsync(ct);
var list = new List<Product>();
while (await reader.ReadAsync(ct))
{
    list.Add(new Product(
        reader.GetInt32(0),
        reader.GetString(1),
        reader.GetDecimal(2)));
}

Use ordinal getters (GetInt32(0)) or cache reader.GetOrdinal("Name") for speed; check reader.IsDBNull(i) before reading nullable columns.

Interview questions on ADO.NET

What is ADO.NET? Name its main objects.

ADO.NET is .NET's core data access library (System.Data + provider packages). Main objects: Connection (connects to the DB), Command (executes SQL/procs), Parameter, DataReader (forward-only fast read), DataAdapter (fills/updates DataSets), DataSet/DataTable (in-memory data), Transaction. For SQL Server use Microsoft.Data.SqlClient (SqlConnection, SqlCommand...).

What is the difference between connected and disconnected architecture?

Connected: the connection stays open while you read with a DataReader — forward-only, read-only, very fast, minimal memory. Disconnected: a DataAdapter fills a DataSet/DataTable, then closes the connection; you can navigate, edit and later push changes back with Update() — more memory, more flexibility. Modern apps mostly use the connected model (directly or via Dapper/EF).

What is the difference between ExecuteReader, ExecuteScalar and ExecuteNonQuery?

ExecuteReader returns a DataReader for one or more result sets. ExecuteScalar returns the first column of the first row (COUNT, SUM, new identity via OUTPUT/SCOPE_IDENTITY()). ExecuteNonQuery runs INSERT/UPDATE/DELETE/DDL and returns the number of rows affected (-1 for statements that don't affect rows, or when SET NOCOUNT ON is set).

Read the full lesson with progress tracking and the rest of the course on DevLadder — free step-by-step tutorials and interview questions for developers.

Next in the course: ExecuteReader vs ExecuteScalar vs ExecuteNonQuery →

Singleton — Design Patterns (GoF + Enterprise) in C#

DIVAKAR UPADHYAY — Sun, 08 Nov 2026 06:11:14 +0000

Lesson 1 of 18 in the free Design Patterns (GoF + Enterprise) in C# course on DevLadder.

Ensure a class has one instance with a global access point.

// Thread-safe, lazy Singleton
public sealed class AppConfig
{
    private static readonly Lazy<AppConfig> _instance = new(() => new AppConfig());
    public static AppConfig Instance => _instance.Value;
    private AppConfig() { /* load settings once */ }
    public string ConnectionString { get; private set; } = "";
}

// Modern .NET: let the DI container own the lifetime instead
builder.Services.AddSingleton<IAppConfig, AppConfig>();

Other thread-safe options: a static readonly field (initialised by the CLR's type initialiser, thread-safe), or double-checked locking. Downsides of the hand-written pattern: global state, hidden dependencies, hard to test. Prefer AddSingleton.

Interview questions on Design Patterns (GoF + Enterprise) in C

What are design patterns? Name the three GoF categories.

Reusable, named solutions to recurring design problems. GoF (1994) lists 23 in three categories: Creational (Singleton, Factory Method, Abstract Factory, Builder, Prototype), Structural (Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy), Behavioural (Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, Visitor).

How do you implement a thread-safe Singleton in C#?

Use Lazy<T>: private static readonly Lazy<Svc> _i = new(() => new Svc()); public static Svc Instance => _i.Value; with a private constructor and a sealed class. Lazy<T> is thread-safe by default (ExecutionAndPublication). Alternatives: a static readonly field (thread-safe because of the type initialiser), or double-checked locking with volatile. In ASP.NET Core, prefer services.AddSingleton<ISvc, Svc>(). It's testable and the container manages the lifetime.

What is the difference between Factory Method and Abstract Factory?

Factory Method creates one product, and subclasses (or a method) decide which concrete class to create. Abstract Factory creates a family of related products through an interface with several create methods (button + textbox for a theme; connection + command + parameter for a DB provider). Factory Method uses inheritance; Abstract Factory uses composition (you pass the factory object).

Read the full lesson with progress tracking and the rest of the course on DevLadder — free step-by-step tutorials and interview questions for developers.

Next in the course: Factory Method and Simple Factory →

S — Single Responsibility Principle — SOLID Principles with Examples

DIVAKAR UPADHYAY — Sun, 08 Nov 2026 06:09:54 +0000

Lesson 1 of 8 in the free SOLID Principles with Examples course on DevLadder.

"A class should have one, and only one, reason to change." — Robert C. Martin

"Reason to change" = one actor or stakeholder. A class that formats invoices and saves them and emails them changes when finance, DBAs or the email provider change.

// ❌ Violates SRP — three reasons to change
public class InvoiceService
{
    public decimal Calculate(Invoice i) => i.Lines.Sum(l => l.Qty * l.Price) * 1.18m;
    public void Save(Invoice i) { using var c = new SqlConnection("..."); /* INSERT ... */ }
    public void Email(Invoice i) { var smtp = new SmtpClient("smtp.example.com"); /* ... */ }
}

// ✅ One responsibility each
public class InvoiceCalculator { public decimal Total(Invoice i) => i.Lines.Sum(l => l.Qty * l.Price) * 1.18m; }
public interface IInvoiceRepository { Task SaveAsync(Invoice i); }
public interface IInvoiceSender { Task SendAsync(Invoice i); }

public class InvoiceWorkflow(InvoiceCalculator calc, IInvoiceRepository repo, IInvoiceSender sender)
{
    public async Task CompleteAsync(Invoice i)
    {
        i.Total = calc.Total(i);
        await repo.SaveAsync(i);
        await sender.SendAsync(i);
    }
}

Interview tip: SRP doesn't mean "one method per class". It means one cohesive job. Controllers that only orchestrate are fine.

Interview questions on SOLID Principles with Examples

What are the SOLID principles? Explain each briefly.

Single Responsibility: one reason to change per class.
Open/Closed: extend behaviour by adding code, not modifying existing code.
Liskov Substitution: subclasses must work anywhere the base class works.
Interface Segregation: small client-specific interfaces instead of a fat one.
Dependency Inversion: high- and low-level modules depend on abstractions; inject dependencies.

Follow with one concrete example from your own project, e.g. "payment providers behind IPaymentGateway, registered in DI — that's OCP and DIP."

Give a real example of the Single Responsibility Principle.

An InvoiceService that calculates totals, writes to SQL and sends email has three reasons to change. Split it into InvoiceCalculator, IInvoiceRepository and IInvoiceSender, with a small workflow class orchestrating them. Now an SMTP-to-SendGrid change touches only the sender, and each part has focused unit tests.

How do you implement the Open/Closed Principle in C#?

Through abstractions and polymorphism: define an interface (IDiscountRule, IExportFormatter), implement each variant as its own class, and let the consumer receive IEnumerable<IDiscountRule> from DI. Adding a variant means a new class and registration; no existing, tested code changes. Other OCP tools: Strategy, Decorator, middleware, filters, events.

Read the full lesson with progress tracking and the rest of the course on DevLadder — free step-by-step tutorials and interview questions for developers.

Next in the course: O — Open/Closed Principle →

Class, object, fields, properties and methods — OOP Concepts in C#

DIVAKAR UPADHYAY — Sun, 08 Nov 2026 06:08:34 +0000

Lesson 1 of 15 in the free OOP Concepts in C# course on DevLadder.

A class is a blueprint; an object is an instance created from it at runtime.

public class BankAccount
{
    private decimal _balance;                       // field (state) — private
    public string Owner { get; }                    // read-only property
    public decimal Balance => _balance;             // computed property

    public BankAccount(string owner, decimal opening = 0)   // constructor
    {
        Owner = owner;
        _balance = opening;
    }

    public void Deposit(decimal amount)             // method (behaviour)
    {
        if (amount <= 0) throw new ArgumentOutOfRangeException(nameof(amount));
        _balance += amount;
    }
}

var acc = new BankAccount("Divakar", 500);           // object
acc.Deposit(250);
Console.WriteLine(acc.Balance);                      // 750

Interview questions on OOP Concepts in C

What are the four pillars of OOP? Explain each with an example.

Encapsulation — private state with a controlled public API. BankAccount keeps _balance private and exposes Deposit() that rejects negative amounts.
Abstraction — expose what, hide how. IPaymentGateway.ChargeAsync() hides HTTP calls, signatures and retries.
Inheritance — a derived class reuses and extends a base. Contractor : Employee reuses Name and Describe().
Polymorphism — the same call behaves differently by type. employee.MonthlyPay() runs the Permanent or Contractor override at runtime.

What is the difference between a class and an object?

A class is a type definition (blueprint) describing fields, properties and methods; it exists in code and metadata. An object is an instance of that class created at runtime with new, occupying memory with its own state. One class, many objects.

What is the difference between method overloading and method overriding?

Overloading	Overriding
Same name, different parameters	Same signature in a derived class
Same class (or derived)	Requires `virtual`/`abstract` + `override`
Resolved at compile time	Resolved at runtime by the object's type
Return type alone can't differ	Return type the same (covariant returns allowed since C# 9)

Read the full lesson with progress tracking and the rest of the course on DevLadder — free step-by-step tutorials and interview questions for developers.

Next in the course: Constructors: default, parameterised, static, private, chaining →

.NET Framework vs .NET Core vs .NET 5+ — the history explained — .NET Internals

DIVAKAR UPADHYAY — Sun, 08 Nov 2026 06:07:14 +0000

Lesson 1 of 11 in the free .NET Internals — CLR, CTS, CLS, IL, JIT, Memory Management & Garbage Collection course on DevLadder.

	.NET Framework	.NET Core 1–3.1	.NET 5+
Years	2002–2019 (4.8.1 in 2022)	2016–2019	2020 →
OS	Windows only	Windows, Linux, macOS	Windows, Linux, macOS, mobile (MAUI), WebAssembly
Source	Closed (reference source available)	Open source (MIT)	Open source
Deployment	Machine-wide install, part of Windows	Side-by-side, self-contained possible	Same + single-file, Native AOT
Web	ASP.NET Web Forms, MVC 5, Web API 2	ASP.NET Core	ASP.NET Core
Performance	Good	Much faster	Fastest; improves every release
Status	Maintenance only	Out of support	Active

Mono (2004, open source, by Ximian → Xamarin → Microsoft) ran .NET on Linux/macOS/mobile and powers Unity and Xamarin; today its runtime is used inside .NET for mobile and WebAssembly.

Interview tip: "Why did they skip .NET 4?" — to avoid confusion with .NET Framework 4.x; .NET 5 dropped "Core" from the name because it became the .NET going forward.

Interview questions on .NET Internals

What is the CLR and what does it do?

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".

What are CTS and CLS?

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).

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

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.

Read the full lesson with progress tracking and the rest of the course on DevLadder — free step-by-step tutorials and interview questions for developers.

Next in the course: CLR, CTS, CLS — what each one does →

Program structure, modules and the Main method — VB.NET

DIVAKAR UPADHYAY — Sun, 08 Nov 2026 06:05:54 +0000

Lesson 1 of 12 in the free VB.NET — Visual Basic .NET from Basics to Advanced (with C# Comparison) course on DevLadder.

Option Strict On          ' no implicit narrowing conversions or late binding — always turn on
Option Explicit On        ' every variable must be declared
Option Infer On           ' allow Dim x = 5 (type inferred)

Imports System.Text       ' = C# using

Namespace Divakar.Shop
    Module Program                       ' a Module = C# static class; members are Shared automatically
        Sub Main(args As String())
            Console.WriteLine("Hello, Divakar!")
            Dim name As String = If(args.Length > 0, args(0), "world")
            Console.WriteLine($"Welcome {name}")       ' string interpolation (VB 14)
        End Sub
    End Module
End Namespace

Statements end at the line break (no semicolons); use _ for explicit line continuation, though VB 10+ allows implicit continuation after operators, commas and opening brackets.
Comments start with ' (or REM).
Blocks end with End X (End If, End Sub, End Class).
Keywords and identifiers are case-insensitive (dim = Dim; the IDE fixes casing).

C#	VB.NET
`using System;`	`Imports System`
`static class Helpers`	`Module Helpers`
`static void Main(string[] args)`	`Sub Main(args As String())`
`// comment`	`' comment`
`Console.WriteLine("x");`	`Console.WriteLine("x")`

Interview questions on VB.NET

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

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.

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

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.

What is the difference between Sub and Function?

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.

Read the full lesson with progress tracking and the rest of the course on DevLadder — free step-by-step tutorials and interview questions for developers.

Next in the course: Data types, variables, constants and conversions →

What C# and .NET are — C# Language

DIVAKAR UPADHYAY — Sun, 08 Nov 2026 06:04:34 +0000

Lesson 1 of 38 in the free C# Language — Basics to Advanced course on DevLadder.

C# is the language; .NET is the platform (runtime + base class library + SDK). You write C#, the compiler produces IL, and the .NET runtime executes it.

CLR (Common Language Runtime): JIT, GC, type safety, exception handling, threading.
BCL (Base Class Library): System, System.Collections.Generic, System.IO, System.Net.Http, ...
CTS / CLS: the common type system that lets C#, F# and VB.NET interoperate.

// Program.cs — a complete program using top-level statements (C# 9+)
Console.WriteLine("Hello, Divakar!");
var name = args.Length > 0 ? args[0] : "world";
Console.WriteLine($"Hello, {name}");

dotnet new console -n HelloApp
cd HelloApp
dotnet run -- Divakar

Interview tip: "Managed code" = code whose execution is managed by the CLR (memory, security, exceptions). "Unmanaged code" = native code outside the CLR, e.g. Win32 DLLs called via P/Invoke.

Interview questions on C# Language

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

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.

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.

What is the difference between `string` and `StringBuilder`?

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.

Explain `const` vs `readonly` vs `static readonly`.

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.

Read the full lesson with progress tracking and the rest of the course on DevLadder — free step-by-step tutorials and interview questions for developers.

Next in the course: First program, namespaces and keywords →

DEV Community: DIVAKAR UPADHYAY

Core objects and the connected model — ADO.NET

Interview questions on ADO.NET

What is ADO.NET? Name its main objects.

What is the difference between connected and disconnected architecture?

What is the difference between ExecuteReader, ExecuteScalar and ExecuteNonQuery?

Singleton — Design Patterns (GoF + Enterprise) in C#

Interview questions on Design Patterns (GoF + Enterprise) in C

What are design patterns? Name the three GoF categories.

How do you implement a thread-safe Singleton in C#?

What is the difference between Factory Method and Abstract Factory?

S — Single Responsibility Principle — SOLID Principles with Examples

Interview questions on SOLID Principles with Examples

What are the SOLID principles? Explain each briefly.

Give a real example of the Single Responsibility Principle.

How do you implement the Open/Closed Principle in C#?

Class, object, fields, properties and methods — OOP Concepts in C#

Interview questions on OOP Concepts in C

What are the four pillars of OOP? Explain each with an example.

What is the difference between a class and an object?

What is the difference between method overloading and method overriding?

.NET Framework vs .NET Core vs .NET 5+ — the history explained — .NET Internals

Interview questions on .NET Internals

What is the CLR and what does it do?

What are CTS and CLS?

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

Program structure, modules and the Main method — VB.NET

Interview questions on VB.NET

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

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

What is the difference between Sub and Function?

What C# and .NET are — C# Language

Interview questions on C# Language

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

What is the difference between string and StringBuilder?

Explain const vs readonly vs static readonly.

What is the difference between `string` and `StringBuilder`?

Explain `const` vs `readonly` vs `static readonly`.