How to implement a singleton pattern in C#?
Singleton mode has many implementation methods in C# and is suitable for different scenarios. 1. The basic thread safety implementation uses double check locking to ensure that only one instance is created in a multi-threaded environment; 2. The static constructor is simple but not delayed loading; 3. Lazy
The Singleton pattern is commonly used in C# to ensure that a class has only one instance and provides a global access point. There are many ways to implement, and different implementation methods are chosen in different scenarios. Below are some common and practical implementation methods that are suitable for different needs.
Basic thread-safe implementation
If you want to ensure the correctness of a singleton in a multithreaded environment, you can use static initialization plus lock to ensure that the instance is created only once. This method is simple to implement and is suitable for most scenarios.
public class Singleton
{
private static Singleton _instance;
private static readonly object _lock = new object();
private Singleton() { }
public static Singleton GetInstance()
{
if (_instance == null)
{
lock (_lock)
{
if (_instance == null)
{
_instance = new Singleton();
}
}
}
return _instance;
}
}"Double-Check Locking" is used here to reduce the frequency of lock usage. Locking is only added when the instance has not been created. Subsequent accesses directly return to the existing instance.
Static constructor implementation (simple but not lazy loading)
If you don't need lazy loading, you can use the feature of the static constructor automatically running only once to implement a singleton:
public class Singleton
{
private static readonly Singleton _instance = new Singleton();
private Singleton() { }
public static Singleton Instance => _instance;
}This method is simple in code and thread-safe, but the disadvantage is that the instance will be initialized as soon as the class is loaded, even if you haven't used it yet.
Using Lazy<T> Implement lazy loading
If you want to do lazy loading but don't want to handle thread safety yourself, you can use Lazy<T> provided by .NET:
public class Singleton
{
private static readonly Lazy<Singleton> _instance = new Lazy<Singleton>(() => new Singleton());
private Singleton() { }
public static Singleton Instance => _instance.Value;
} Lazy<T> is thread-safe by default, and instances are created only when Value is accessed for the first time, taking into account both latency loading and thread-safety.
Using Dependency Injection (recommended modern projects)
If your project uses dependency injection (such as ASP.NET Core), it is recommended not to implement singletons manually, but to manage the life cycle through service registration:
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton<ISingletonService, SingletonService>();
}Then inject through the constructor where needed:
public class SomeOtherClass
{
private readonly ISingletonService _service;
public SomeOtherClass(ISingletonService service)
{
_service = service;
}
}This method is more in line with the development specifications of modern C# projects and is easier to test and maintain.
Depending on your project type and requirements, you can choose different implementation methods. For example, small projects can be used with Lazy<t></t> , and dependency injection is recommended in large projects or frameworks. Basically all is it, not complicated but it is easy to ignore details.
The above is the detailed content of How to implement a singleton pattern in C#?. For more information, please follow other related articles on the PHP Chinese website!
Hot AI Tools
Undress AI Tool
Undress images for free
Undresser.AI Undress
AI-powered app for creating realistic nude photos
AI Clothes Remover
Online AI tool for removing clothes from photos.
Clothoff.io
AI clothes remover
Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!
Hot Article
Hot Tools
Notepad++7.3.1
Easy-to-use and free code editor
SublimeText3 Chinese version
Chinese version, very easy to use
Zend Studio 13.0.1
Powerful PHP integrated development environment
Dreamweaver CS6
Visual web development tools
SublimeText3 Mac version
God-level code editing software (SublimeText3)
Creating and Applying Custom Attributes in C#
Jul 07, 2025 am 12:03 AM
CustomAttributes are mechanisms used in C# to attach metadata to code elements. Its core function is to inherit the System.Attribute class and read through reflection at runtime to implement functions such as logging, permission control, etc. Specifically, it includes: 1. CustomAttributes are declarative information, which exists in the form of feature classes, and are often used to mark classes, methods, etc.; 2. When creating, you need to define a class inherited from Attribute, and use AttributeUsage to specify the application target; 3. After application, you can obtain feature information through reflection, such as using Attribute.GetCustomAttribute();
Designing Immutable Objects and Data Structures in C#
Jul 15, 2025 am 12:34 AM
The core of designing immutable objects and data structures in C# is to ensure that the state of the object is not modified after creation, thereby improving thread safety and reducing bugs caused by state changes. 1. Use readonly fields and cooperate with constructor initialization to ensure that the fields are assigned only during construction, as shown in the Person class; 2. Encapsulate the collection type, use immutable collection interfaces such as ReadOnlyCollection or ImmutableList to prevent external modification of internal collections; 3. Use record to simplify the definition of immutable model, and generate read-only attributes and constructors by default, suitable for data modeling; 4. It is recommended to use System.Collections.Imm when creating immutable collection operations.
Creating Custom Middleware in ASP.NET Core C#
Jul 11, 2025 am 01:55 AM
Create custom middleware in ASP.NETCore, which can be implemented by writing classes and registering. 1. Create a class containing the InvokeAsync method, handle HttpContext and RequestDelegatenext; 2. Register with UseMiddleware in Program.cs. Middleware is suitable for general operations such as logging, performance monitoring, exception handling, etc. Unlike MVC filters, it acts on the entire application and does not rely on the controller. Rational use of middleware can improve structural flexibility, but should avoid affecting performance.
Writing Maintainable and Testable C# Code
Jul 12, 2025 am 02:08 AM
The key to writing C# code well is maintainability and testability. Reasonably divide responsibilities, follow the single responsibility principle (SRP), and take data access, business logic and request processing by Repository, Service and Controller respectively to improve structural clarity and testing efficiency. Multi-purpose interface and dependency injection (DI) facilitate replacement implementation, extension of functions and simulation testing. Unit testing should isolate external dependencies and use Mock tools to verify logic to ensure fast and stable execution. Standardize naming and splitting small functions to improve readability and maintenance efficiency. Adhering to the principles of clear structure, clear responsibilities and test-friendly can significantly improve development efficiency and code quality.
Best Practices for Using LINQ in C# Effectively
Jul 09, 2025 am 01:04 AM
The following points should be followed when using LINQ: 1. Priority is given to LINQ when using declarative data operations such as filtering, converting or aggregating data to avoid forced use in scenarios with side effects or performance-critical scenarios; 2. Understand the characteristics of delayed execution, source set modifications may lead to unexpected results, and delays or execution should be selected according to requirements; 3. Pay attention to performance and memory overhead, chain calls may generate intermediate objects, and performance-sensitive codes can be replaced by loops or spans; 4. Keep the query concise and easy to read, and split complex logic into multiple steps to avoid excessive nesting and mixing of multiple operations.
Deep Dive into C# Generics Constraints and Covariance
Jul 12, 2025 am 02:00 AM
Generic constraints are used to restrict type parameters to ensure specific behavior or inheritance relationships, while covariation allows subtype conversion. For example, whereT:IComparable ensures that T is comparable; covariation such as IEnumerable allows IEnumerable to be converted to IEnumerable, but it is only read and cannot be modified. Common constraints include class, struct, new(), base class and interface, and multiple constraints are separated by commas; covariation requires the out keyword and is only applicable to interfaces and delegates, which is different from inverter (in keyword). Note that covariance does not support classes, cannot be converted at will, and constraints affect flexibility.
Understanding C# Async and Await Pitfalls
Jul 15, 2025 am 01:37 AM
Common problems with async and await in C# include: 1. Incorrect use of .Result or .Wait() causes deadlock; 2. Ignoring ConfigureAwait(false) causes context dependencies; 3. Abuse of asyncvoid causes control missing; 4. Serial await affects concurrency performance. The correct way is: 1. The asynchronous method should be asynchronous all the way to avoid synchronization blocking; 2. The use of ConfigureAwait(false) in the class library is used to deviate from the context; 3. Only use asyncvoid in event processing; 4. Concurrent tasks need to be started first and then await to improve efficiency. Understanding the mechanism and standardizing the use of asynchronous code that avoids writing substantial blockage.
Implementing Fluent Interfaces with C# Extension Methods
Jul 10, 2025 pm 01:08 PM
Fluent interface is a design method that improves code readability and expressivity through chain calls. The core of it is that each method returns the current object, so that multiple operations can be called continuously, such as varresult=newStringBuilder().Append("Hello").Append("").Append("World"). When implementing, you need to combine the extension method and the design pattern that returns this, such as defining the FluentString class and returning this in its method, and creating an initial instance through the extension method. Common application scenarios include building configurators (such as verification rules), checking
