Fix: The connection string property has not been initialized

The ‘The connection string property has not been initialized’ error occurs when a .NET application tries to access a database connection string that hasn’t been properly configured or retrieved from configuration files.

---

How the Error Happens

This error typically occurs when:

• Connection string is missing from configuration file
• Incorrect key name is used to retrieve the connection string
• Configuration file is not properly loaded
• Connection string is null or empty when accessed

---

Solution 1: Configure Connection String in appsettings.json

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MyApp;Trusted_Connection=true;TrustServerCertificate=true;"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information"
    }
  }
}

// ✅ Retrieve connection string properly
using Microsoft.Extensions.Configuration;

public class DatabaseService
{
    private readonly string _connectionString;
    
    public DatabaseService(IConfiguration configuration)
    {
        // ✅ Correct way to get connection string
        _connectionString = configuration.GetConnectionString("DefaultConnection");
    }
}

---

Solution 2: Register Configuration in Startup

// ✅ For ASP.NET Core applications
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // ✅ Add configuration and register DbContext
        services.AddDbContext<MyDbContext>(options =>
            options.UseSqlServer(
                Configuration.GetConnectionString("DefaultConnection")));
    }
}

// ✅ Program.cs for .NET 6+
var builder = WebApplication.CreateBuilder(args);

// ✅ Add configuration services
builder.Services.AddControllers();
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

var app = builder.Build();

---

Solution 3: Use Dependency Injection for Configuration

// ✅ Proper dependency injection setup
public class MyService
{
    private readonly IConfiguration _configuration;
    
    public MyService(IConfiguration configuration)
    {
        _configuration = configuration;
    }
    
    public void ConnectToDatabase()
    {
        var connectionString = _configuration.GetConnectionString("DefaultConnection");
        
        if (string.IsNullOrEmpty(connectionString))
        {
            throw new InvalidOperationException("Connection string is not configured");
        }
        
        // ✅ Use the connection string
        using var connection = new SqlConnection(connectionString);
        connection.Open();
        // Perform database operations
    }
}

---

Solution 4: Check Configuration Builder Setup

// ✅ Ensure configuration is properly built
public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);
        
        // ✅ Ensure appsettings.json is included
        builder.Configuration.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
        
        // ✅ Add other configuration sources if needed
        builder.Configuration.AddEnvironmentVariables();
        
        var app = builder.Build();
        app.Run();
    }
}

---

Solution 5: Use Connection String Validation

// ✅ Validate connection string before use
public class DatabaseHelper
{
    public static string GetValidConnectionString(IConfiguration configuration)
    {
        var connectionString = configuration.GetConnectionString("DefaultConnection");
        
        if (string.IsNullOrWhiteSpace(connectionString))
        {
            throw new InvalidOperationException(
                "Connection string 'DefaultConnection' is not configured in appsettings.json");
        }
        
        return connectionString;
    }
    
    public static bool TestConnection(string connectionString)
    {
        try
        {
            using var connection = new SqlConnection(connectionString);
            connection.Open();
            return true;
        }
        catch
        {
            return false;
        }
    }
}

---

Solution 6: For Traditional .NET Framework Applications

<!-- ✅ In App.config or Web.config -->
<configuration>
  <connectionStrings>
    <add name="DefaultConnection" 
         connectionString="Server=localhost;Database=MyApp;Trusted_Connection=true;" 
         providerName="System.Data.SqlClient" />
  </connectionStrings>
</configuration>

// ✅ Access connection string in .NET Framework
using System.Configuration;

public class LegacyDatabaseService
{
    public string GetConnectionString()
    {
        // ✅ Get connection string from config
        var connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"];
        
        if (connectionString == null)
        {
            throw new InvalidOperationException("Connection string not found");
        }
        
        return connectionString.ConnectionString;
    }
}

---

Solution 7: Environment-Specific Configuration

// ✅ appsettings.Development.json
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MyAppDev;Trusted_Connection=true;"
  }
}

// ✅ appsettings.Production.json
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=prod-server;Database=MyAppProd;User Id=user;Password=password;"
  }
}

// ✅ Automatically load environment-specific config
public class Startup
{
    public Startup(IConfiguration configuration, IWebHostEnvironment env)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
            .AddEnvironmentVariables();
            
        Configuration = builder.Build();
    }
}

---

Solution 8: Use IOptions Pattern for Complex Configuration

// ✅ Create a configuration class
public class DatabaseSettings
{
    public string ConnectionString { get; set; }
    public string DatabaseName { get; set; }
    public int CommandTimeout { get; set; }
}

// ✅ Register in startup
services.Configure<DatabaseSettings>(
    Configuration.GetSection(nameof(DatabaseSettings)));

// ✅ Use in services
public class MyService
{
    private readonly DatabaseSettings _settings;
    
    public MyService(IOptions<DatabaseSettings> settings)
    {
        _settings = settings.Value;
    }
}

---

Common Mistakes to Avoid

1. Incorrect key name: Make sure the key in configuration matches what you’re retrieving
2. Missing configuration file: Ensure appsettings.json exists in the output directory
3. Case sensitivity: Connection string names are case-sensitive
4. Build action: Set appsettings.json Build Action to “Content” and Copy to Output Directory

---

Troubleshooting Steps

1. Verify appsettings.json is in the correct location
2. Check that the connection string key name matches exactly
3. Ensure configuration is properly registered in DI container
4. Use debugging to check if configuration values are loaded
5. Check for typos in the connection string itself