Testing an Entity Framework database connection

The solution as @Danilo Breda pointed out is to call the DbContext.Database.Connection.Open()

It is tested with EF6.

My implementaion:

    public static bool CheckConnection()
    {
        try
        {
            MyContext.Database.Connection.Open();
            MyContext.Database.Connection.Close();
        }
        catch(SqlException)
        {
            return false;
        }
        return true;
    }

In EntityFramework Core you can simply call: Database.CanConnect();.

(using EF Core 2.2.1)

Summary: Determines whether or not the database is available and can be connected to.

Note that being able to connect to the database does not mean that it is up-to-date with regard to schema creation, etc.

I use this code for my project:

private bool TestConnectionEF()
{
    using (var db = new SistemaContext())
    {
        db.Database.Connection.Open();

        if (db.Database.Connection.State == ConnectionState.Open)
        {
            Console.WriteLine(@"INFO: ConnectionString: " + db.Database.Connection.ConnectionString 
                     + "\n DataBase: " + db.Database.Connection.Database 
                     + "\n DataSource: " + db.Database.Connection.DataSource 
                     + "\n ServerVersion: " + db.Database.Connection.ServerVersion 
                     + "\n TimeOut: " + db.Database.Connection.ConnectionTimeout);

            db.Database.Connection.Close();

            return true;
        }

        return false;
    }
}

I know this is an old question, but here is my answer for anyone looking for a newer implementation.

I was able to use CanConnect to check the status of the database:

_database.Database.CanConnect();

# Async too
await _database.Database.CanConnectAsync(_cancellationTokenSource.Token);

I hope this helps others as well. Cheers!

I used the answer from @Sandor and did an extension method to use with EntityFramework Core.

Here's the code:

using Microsoft.EntityFrameworkCore;
using System.Data.Common;

namespace TerminalInventory
{
    public static class ExtensionMethods
    {
        public static bool TestConnection(this DbContext context)
        {
            DbConnection conn = context.Database.GetDbConnection();

            try
            {
                conn.Open();   // Check the database connection

                return true;
            }
            catch
            {
                return false;
            }
        }
    }
}

Now you just have to call:

if (!context.TestConnection())
{
    logger.LogInformation("No database connection. Check the connection string in settings.json. {0}", configuration["connectionString"]);

    return;
}

To verify Server and Database connection in Entity Framework, You can use the object Database with its ExecuteSql method. Here a function that returns true of false:

  public bool it_pg_DatabaseConnectionCheck()
  {
    bool Ok ;
    try { 
      int N = _context.Database.ExecuteSql($"SELECT COUNT(*) FROM AnyTableName");
      Ok= true;
    }
    catch (Exception ex) 
    {
      Ok= false;
    }
    return Ok ;
}

where:

• AnyTableName is the name of any table inside the database you want to verify
• _context is the class (derived by DbContext as usual) you use in EF

Remarks: mandatory use of dollar sign ($) in front of the sql command string.

This approach have some advantages:

• no needs to take care of the underlying database type
• no needs to create manually objects like SqlCommand or other kinds

I am using the following code for MS SQL connection. Maybe, it will be useful for MySQL too. You don’t even need to use an EF or EF Core.

    public bool IsDbConnectionOK()
    {
        SqlConnectionStringBuilder conStr = new SqlConnectionStringBuilder
        {
            DataSource = ButtonServerName.Text,  // <-- My Form Elements
            InitialCatalog = ButtonDBName.Text, // <-- My Form Elements
            UserID = EditUserName.Text, // <-- My Form Elements
            Password = EditPassword.Text, // <-- My Form Elements
            IntegratedSecurity = false,
            ConnectTimeout = 30
        };

        string connectionstring = conStr.ToString();

        try
        {
            using (System.Data.SqlClient.SqlConnection connection = new System.Data.SqlClient.SqlConnection(connectionstring))
            {
                connection.Open();
                return true;
            }
        }
        catch (System.Data.SqlClient.SqlException ex)
        {
            MessageBox.Show(ex.Message + Environment.NewLine +
                "Error line: " + ex.LineNumber + Environment.NewLine +
                "Procedure name: " + ex.Procedure);
            return false;
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
            return false;
        }
    }