web-dev-qa-db-fra.com

Quelle est la meilleure façon de tester la connexion SQL Server par programme?

Je dois développer une seule routine qui sera déclenchée toutes les 5 minutes pour vérifier si une liste de serveurs SQL (10 à 12) est opérationnelle.

Je peux essayer d’obtenir une requête simple dans chacun des serveurs, mais cela signifie que je dois créer une procédure table, vue ou stockée sur chaque serveur, même si j’utilise une méthode déjà faite SP Je dois également avoir un utilisateur enregistré sur chaque serveur. Les serveurs ne se trouvent pas au même emplacement physique, il serait donc complexe de satisfaire à ces exigences. Existe-t-il un moyen de "cingler" simplement à partir de C # one SQL Server?

Merci d'avance!

c#sql-serverdatabase-connectivity
67
backslash17

Execute SELECT 1 et vérifiez si ExecuteScalar renvoie 1.

63
Andrew Bezzub

J'ai eu un problème avec l'EF lorsque la connexion du serveur est arrêtée ou suspendue et j'ai soulevé la même question. Donc, pour compléter les réponses ci-dessus, voici le code.

/// <summary>
/// Test that the server is connected
/// </summary>
/// <param name="connectionString">The connection string</param>
/// <returns>true if the connection is opened</returns>
private static bool IsServerConnected(string connectionString)
{
    using (SqlConnection connection = new SqlConnection(connectionString))
    {
        try
        {
            connection.Open();
            return true;
        }
        catch (SqlException)
        {
            return false;
        }
    }
}
64
peterincumbria

Voir le projet suivant sur GitHub: https://github.com/ghuntley/csharp-mssql-connectivity-tester

try
{
    Console.WriteLine("Connecting to: {0}", AppConfig.ConnectionString);
    using (var connection = new SqlConnection(AppConfig.ConnectionString))
    {
        var query = "select 1";
        Console.WriteLine("Executing: {0}", query);

        var command = new SqlCommand(query, connection);

        connection.Open();
        Console.WriteLine("SQL Connection successful.");

        command.ExecuteScalar();
        Console.WriteLine("SQL Query execution successful.");
    }
}
catch (Exception ex)
{
    Console.WriteLine("Failure: {0}", ex.Message);
}
10
Geoffrey Huntley

Établir une connexion à la base de données ne le ferait-il pas pour vous? Si la base de données n'est pas en place, vous ne pourrez pas établir de connexion.

7
Ken Henderson

Pour ce que Joel Coehorn a suggéré, avez-vous déjà essayé l'utilitaire nommé tcping . Je sais que c'est quelque chose que vous ne faites pas par programme. C'est un exécutable autonome qui vous permet de faire un ping à chaque intervalle de temps spécifié. Ce n'est pas en C # cependant. Aussi .. Je ne suis pas sûr Si cela fonctionnerait Si la machine cible avait un pare-feu..hmmm ..

[Je suis un peu nouveau sur ce site et a ajouté ceci à tort comme un commentaire, maintenant ajouté ceci comme une réponse. Faites-moi savoir si cela peut être fait ici car j'ai des commentaires en double (en commentaire et en réponse) ici. Je ne peux pas supprimer les commentaires ici.]

1
Ashish Gupta

Recherchez un écouteur ouvert sur le port 1433 (le port par défaut). Si vous obtenez une réponse après avoir créé une connexion TCP, le serveur est probablement opérationnel.

1
Joel Coehoorn

Pourquoi ne pas simplement vous connecter à une session telnet sur le port du serveur SQL. S'il se connecte, le serveur SQL est opérationnel et heureux. Sinon, vous n'avez pas de chance.

Cet autre StackOverflow post pourrait être un bon point de départ pour cela.

EDIT: OK, maintenant que j’ai entièrement lu les autres posts, ce n’est pas vraiment la meilleure solution ... Pourtant, si vous voulez juste envoyer une requête ping sur le port ...

0
pms1969
public static class SqlConnectionExtension
{
    #region Public Methods

    public static bool ExIsOpen(this SqlConnection connection, MessageString errorMsg)
    {
        if (connection == null) return false;
        if (connection.State != ConnectionState.Open)
        {
            try
            {
                connection.Open();
            }
            catch (Exception ex) { errorMsg.Append(ex.ToString()); }
        }
        return true;
    }

    public static bool ExIsReady(this SqlConnection connction, MessageString errorMsg)
    {
        if (ExIsOpen(connction, errorMsg) == false) return false;
        try
        {
            using (SqlCommand command = new SqlCommand("select 1", connction))
            using (SqlDataReader reader = command.ExecuteReader())
                if (reader.Read()) return true;
        }
        catch (Exception ex) { errorMsg.Append(ex.ToString()); }
        return false;
    }

    #endregion Public Methods
}



public class MessageString : IDisposable
{
    #region Protected Fields

    protected StringBuilder _messageBuilder = new StringBuilder();

    #endregion Protected Fields

    #region Public Constructors

    public MessageString()
    {
    }

    public MessageString(int capacity)
    {
        _messageBuilder.Capacity = capacity;
    }

    public MessageString(string value)
    {
        _messageBuilder.Append(value);
    }

    #endregion Public Constructors

    #region Public Properties

    public int Length {
        get { return _messageBuilder.Length; }
        set { _messageBuilder.Length = value; }
    }

    public int MaxCapacity {
        get { return _messageBuilder.MaxCapacity; }
    }

    #endregion Public Properties

    #region Public Methods

    public static implicit operator string(MessageString ms)
    {
        return ms.ToString();
    }

    public static MessageString operator +(MessageString ms1, MessageString ms2)
    {
        MessageString ms = new MessageString(ms1.Length + ms2.Length);
        ms.Append(ms1.ToString());
        ms.Append(ms2.ToString());
        return ms;
    }

    public MessageString Append<T>(T value) where T : IConvertible
    {
        _messageBuilder.Append(value);
        return this;
    }

    public MessageString Append(string value)
    {
        return Append<string>(value);
    }

    public MessageString Append(MessageString ms)
    {
        return Append(ms.ToString());
    }

    public MessageString AppendFormat(string format, params object[] args)
    {
        _messageBuilder.AppendFormat(CultureInfo.InvariantCulture, format, args);
        return this;
    }

    public MessageString AppendLine()
    {
        _messageBuilder.AppendLine();
        return this;
    }

    public MessageString AppendLine(string value)
    {
        _messageBuilder.AppendLine(value);
        return this;
    }

    public MessageString AppendLine(MessageString ms)
    {
        _messageBuilder.AppendLine(ms.ToString());
        return this;
    }

    public MessageString AppendLine<T>(T value) where T : IConvertible
    {
        Append<T>(value);
        AppendLine();
        return this;
    }

    public MessageString Clear()
    {
        _messageBuilder.Clear();
        return this;
    }

    public void Dispose()
    {
        _messageBuilder.Clear();
        _messageBuilder = null;
    }

    public int EnsureCapacity(int capacity)
    {
        return _messageBuilder.EnsureCapacity(capacity);
    }

    public bool Equals(MessageString ms)
    {
        return Equals(ms.ToString());
    }

    public bool Equals(StringBuilder sb)
    {
        return _messageBuilder.Equals(sb);
    }

    public bool Equals(string value)
    {
        return Equals(new StringBuilder(value));
    }

    public MessageString Insert<T>(int index, T value)
    {
        _messageBuilder.Insert(index, value);
        return this;
    }

    public MessageString Remove(int startIndex, int length)
    {
        _messageBuilder.Remove(startIndex, length);
        return this;
    }

    public MessageString Replace(char oldChar, char newChar)
    {
        _messageBuilder.Replace(oldChar, newChar);
        return this;
    }

    public MessageString Replace(string oldValue, string newValue)
    {
        _messageBuilder.Replace(oldValue, newValue);
        return this;
    }

    public MessageString Replace(char oldChar, char newChar, int startIndex, int count)
    {
        _messageBuilder.Replace(oldChar, newChar, startIndex, count);
        return this;
    }

    public MessageString Replace(string oldValue, string newValue, int startIndex, int count)
    {
        _messageBuilder.Replace(oldValue, newValue, startIndex, count);
        return this;
    }

    public override string ToString()
    {
        return _messageBuilder.ToString();
    }

    public string ToString(int startIndex, int length)
    {
        return _messageBuilder.ToString(startIndex, length);
    }

    #endregion Public Methods
}
0
Final Heaven

Similaire à la réponse proposée par Andrew, mais j'utilise:

Sélectionnez GetDate () comme CurrentDate

Cela me permet de voir si SQL Server et le client ont des problèmes de différence de fuseau horaire, dans la même action.

0
JustDaveN