Static Constructors in .NET Core

-
Static Constructors in .NET Core

⚙️ Static Constructors in .NET Core

Static constructors in C# are designed to initialize the class itself, not instances. They're perfect for one-time setup of static fields, configuration, logging, and more.

🔹 Syntax

public class MyClass
{
    public static int StaticField;

    static MyClass()
    {
        StaticField = 42;
        Console.WriteLine("Static constructor called.");
    }
}

📌 Key Characteristics

  • ✅ Called once per app lifetime (before any static or instance member access)
  • ✅ Automatically invoked by the CLR — you can't call it manually
  • ✅ Thread-safe by default
  • ✅ Cannot accept parameters

💡 When is it Called?

  • 🔸 When any static member is accessed
  • 🔸 When an instance of the class is created

🧪 Example: Database Initialization

public class Database
{
    public static string ConnectionString { get; set; }
    public static int MaxConnections { get; set; }

    static Database()
    {
        ConnectionString = "Server=myServer;Database=db;User Id=user;";
        MaxConnections = 100;
        Console.WriteLine("Static constructor executed: Database initialized.");
    }
}

🚀 Real-World Example with Lazy Initialization

public class ConnectionManager
{
    private static Lazy<ConnectionPool> _pool = new(() => new ConnectionPool());

    static ConnectionManager()
    {
        Console.WriteLine("ConnectionManager static constructor called.");
    }

    public static ConnectionPool GetConnectionPool() => _pool.Value;
}

public class ConnectionPool
{
    public ConnectionPool()
    {
        Console.WriteLine("ConnectionPool initialized.");
    }
}

This ensures the expensive object is created only when needed.

✅ Benefits

  • 🔹 One-time Initialization: No repeated setup calls
  • 🔹 Cleaner Code: Centralizes all static setup logic
  • 🔹 Thread-Safe: No manual locks required
  • 🔹 Lazy Evaluation: Combine with Lazy<T> for on-demand loading

⚠️ Limitations

  • ⚠️ No parameters allowed
  • ⚠️ Cannot be explicitly called
  • ⚠️ Should not perform complex or long-running operations
Best Practice: Avoid time-consuming operations in static constructors. Use Lazy<T> or defer initialization when possible.

📌 When to Use

  • 🛠 Initializing static configuration or settings
  • 🌐 Setting up shared connections or service clients
  • 🧪 Preparing logging or analytics libraries

🧾 Summary

Static constructors are a powerful way to configure shared state in .NET Core. They execute once, are safe in multithreaded environments, and keep initialization logic clean. Use them wisely to enhance performance and structure.

Comments

Post a Comment

Popular posts from this blog

Promises in Angular

-
🚀 Promises in Angular – The Complete Beginner’s Guide (with Examples) 📘 Introduction In modern Angular development, handling asynchronous operations is essential. Whether you're fetching data from an API, loading files, or wrapping browser-native APIs, Promises offer a clean and readable way to deal with one-time asynchronous operations. This guide explains: What Promises are How they compare with Observables Real-world examples using .then() and async/await When to use Promises vs Observables in Angular 📚 Table of Contents 🔍 What is a Promise? 🔁 Promise Lifecycle ✨ Key Features 📌 Syntax 💻 Example 1: Fetch 💻 Example 2: setTimeout 📊 Promises vs Observables 🎯 When to Use Promises 📦 Angular Service Example 🔄 Observable vs Promise ❓ FAQ ✅ Summary 🔍 What is a Promise? A Promise is a JavaScript object that represents the eventual success (fulfilled) or failure (rejected) of an asynchronous operation. 📌 Com...
Read more

Debouncing & Throttling in RxJS: Optimizing API Calls and User Interactions

-
RxJS Debounce vs Throttle in Angular – Best Practices & Examples What is RxJS — quick primer RxJS (Reactive Extensions for JavaScript) provides Observables and operators to model and manipulate streams of asynchronous events — from keystrokes and HTTP requests to timers and WebSocket messages. 💡 Why this matters: Operators like debounceTime and throttleTime help you control event frequency, reducing wasted CPU and network work while improving UX. 1. Debouncing — emit after silence Debouncing delays emitting a value until a specified period of inactivity. It's best for typeahead inputs where only the final value after the user stops typing is relevant. Live search example (production-ready) // search.component.ts import { Component, OnDestroy } from '@angular/core'; import { FormControl } from '@angular/forms'; import { Subject } from 'rxjs'; import { debounc...
Read more

Comprehensive Guide to C# and .NET Core OOP Concepts and Language Features

-
Comprehensive Guide to C# and .NET Core OOP Concepts Class A class is a blueprint for creating objects that encapsulate both data and behavior. Access Modifiers : public, internal, abstract, sealed control visibility and inheritance. Static Classes : Cannot be instantiated, contain only static members. Partial Classes : Split across files using partial keyword for better organization. public class Car { public string Model; public void Drive() => Console.WriteLine($"{Model} is driving."); } Analogy: A car blueprint used to build many actual cars. Benefits: Reusability, Encapsulation, Abstraction, Inheritance Object An object is an instance of a class. Managed by Garbage Collector for automatic memory cleanup. Boxing/Unboxing allows value types to be treated a...
Read more