Скачать или смотреть How to Migrate Away from ConfigurationManager in .NET 6

Discover how to seamlessly transition from `ConfigurationManager` to modern practices in .NET 6. Explore a simple solution to update your legacy code without excessive refactoring.
---
This video is based on the question https://stackoverflow.com/q/71005957/ asked by the user 'daxu' ( https://stackoverflow.com/u/1223876/ ) and on the answer https://stackoverflow.com/a/71007193/ provided by the user 'Funk' ( https://stackoverflow.com/u/4838058/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: how to migrate away from ConfigurationManager in .net 6

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Introduction: Migrating Legacy Projects to .NET 6

Migrating a legacy .NET Framework project to .NET 6 can be a daunting task, particularly when it comes to handling system configurations. One common challenge that developers encounter is the transition from ConfigurationManager to the new configuration system introduced in .NET 6. This guide will address how to manage configuration values effectively during this migration.

The Problem: Using ConfigurationManager

Many legacy applications rely on ConfigurationManager to access application settings. For example, a Constants class in the legacy code might look like this:

[[See Video to Reveal this Text or Code Snippet]]

Here, the MaxCodes variable is initialized with a value fetched from the configuration settings during application startup. However, in .NET 6, ConfigurationManager is not the preferred method for managing configurations, leaving developers to search for alternatives.

The Challenge: Static Classes and Dependency Injection

While migrating to .NET 6, you might consider making the Constants class non-static to leverage dependency injection, which allows for more modular and testable code. But this change could lead to a significant amount of refactoring throughout your codebase, making it a less desirable choice.

The Solution: Maintain the Static Class Structure

Fortunately, there’s a more straightforward approach that allows you to maintain the static structure of your Constants class. Here’s how you can do that:

Step 1: Introduce an Initialization Method

Instead of directly accessing configuration values in the static field, you can create an Initialize method that accepts an IConfiguration instance. This method will be responsible for setting your configuration values during the application's startup.

Step 2: Update the Constants Class

Here’s a modified version of the Constants class that implements this approach:

[[See Video to Reveal this Text or Code Snippet]]

Explanation

Initialization Method: The Initialize method takes an IConfiguration object as its parameter. This allows the class to retrieve configuration values during application startup rather than at runtime.

_isInitialized Flag: The private field _isInitialized ensures that the values are set only once, preventing any accidental changes after the bootstrap process.

Private Setters: The property MaxCodes has a private setter, making it immutable from outside the class after initialization.

Step 3: Call Initialize During Startup

Finally, you need to ensure that you call the Initialize method in your application’s startup logic:

[[See Video to Reveal this Text or Code Snippet]]

Conclusion

Migrating away from ConfigurationManager to a more modern configuration approach in .NET 6 doesn’t have to be a massive overhaul of your codebase. By keeping your Constants class static and using an initialization method, you can smoothly transition to .NET 6 without extensive refactoring.

Key Takeaways:

Static Class Usage: Maintain a static class structure while still leveraging dependency injection.

Initialization Logic: Centralize configuration loading in a single Initialize method.

Immutable Configuration: Protect static properties from being modified after the application starts.

By following this approach, you can keep your code cleaner and maintainable, while taking advantage of the best practices available in the latest .NET framework.