Partager via


Tutoriel : Concevoir une base de données relationnelle dans Azure SQL Database en C# avec ADO.NET

S’applique à : Azure SQL Database

Azure SQL Database est une solution DBaaS relationnelle dans Microsoft Cloud (Azure). Ce didacticiel vous montre comment utiliser le portail Azure et ADO.NET avec Visual Studio pour :

  • Créer une base de données à l’aide du portail Azure
  • Configurer une règle de pare-feu IP au niveau du serveur à l’aide du portail Azure
  • Se connecter à la base de données avec ADO.NET et Visual Studio
  • Créer des tables avec ADO.NET
  • Insérer, mettre à jour et supprimer des données avec ADO.NET
  • Interroger les données avec ADO.NET

Conseil

Ce module Learn gratuit explique comment Développer et configurer une application ASP.Net qui interroge une base de données Azure SQL Database, ce qui comprend la création d’une base de données simple.

Prérequis

Connectez-vous au portail Azure.

Connectez-vous au portail Azure.

Créer une règle de pare-feu IP au niveau du serveur

SQL Database crée un pare-feu IP au niveau du serveur. Ce pare-feu empêche les applications et outils externes de se connecter au serveur et à toutes les bases de données sur ce serveur, sauf si une règle de pare-feu autorise leur adresse IP à traverser le pare-feu. Pour activer la connectivité externe à votre base de données, vous devez d’abord ajouter une règle de pare-feu IP pour votre adresse IP (ou plage d’adresses IP). Suivez ces étapes pour créer une règle de pare-feu IP au niveau du serveur.

Important

SQL Database communique par le biais du port 1433. Si vous essayez de vous connecter à ce service à partir d’un réseau d’entreprise, le trafic sortant sur le port 1433 peut ne pas être autorisé par le pare-feu de votre réseau. Dans ce cas, vous ne pouvez pas vous connecter à votre base de données, sauf si votre administrateur ouvre le port 1433.

  1. Une fois le déploiement terminé, sélectionnez Bases de données SQL dans le menu de gauche, puis sélectionnez yourDatabase dans la page Bases de données SQL. La page de vue d’ensemble de votre base de données s’ouvre. Elle affiche le nom complet du serveur (par exemple, yourserver.database.windows.net) et fournit des options pour poursuivre la configuration.

  2. Copiez le nom complet du serveur pour vous connecter à votre serveur et aux bases de données à partir de SQL Server Management Studio.

    Capture d’écran du portail Azure, page de vue d’ensemble de la base de données, avec le nom du serveur en évidence.

  3. Dans le portail Azure, accédez au serveur SQL logique pour votre instance Azure SQL Database. Le moyen le plus simple consiste à sélectionner la valeur Nom du serveur dans la page de la base de données SQL.

  4. Dans le menu de la ressource, sous Paramètres, sélectionnez Réseau.

  5. Choisissez l’onglet Accès public, puis sélectionnez Réseaux sélectionnés sous Accès réseau public.

    Capture d’écran de la page Portail Azure, Mise en réseau, montrant l’accès au réseau public activé.

  6. Faites défiler vers le bas jusqu’à la section Règles de pare-feu.

    Capture d’écran de la page Réseaux du Portail Azure, section Règles de pare-feu.

  7. Dans la barre d’outils, sélectionnez Ajouter l’adresse IPv4 de votre client afin d’ajouter votre adresse IP actuelle à une nouvelle règle de pare-feu IP. Une règle de pare-feu IP peut ouvrir le port 1433 pour une seule adresse IP ou une plage d’adresses IP.

  8. Sélectionnez Enregistrer. Une règle de pare-feu IP au niveau du serveur est créée pour votre adresse IP actuelle et ouvre le port 1433 sur le serveur.

  9. Sélectionnez OK, puis fermez la page Paramètres de pare-feu.

    Votre adresse IP peut désormais traverser le pare-feu IP. Vous pouvez maintenant vous connecter à votre base de données à l’aide de SQL Server Management Studio ou tout autre outil de votre choix. Veillez à utiliser le compte d’administrateur de serveur que vous avez créé précédemment.

Important

Par défaut, l’accès par le biais du pare-feu IP SQL Database est activé pour tous les services Azure. Sélectionnez DÉSACTIVÉ sur cette page pour désactiver l’accès pour tous les services Azure.

Exemple de programme C#

Les sections suivantes de cet article présentent un programme C# qui utilise ADO.NET pour envoyer des instructions Transact-SQL (T-SQL) à la base de données SQL. Le programme C# fait la démonstration des opérations suivantes :

Diagramme des relations d’entité (ERD)

Les instructions CREATE TABLE impliquent le mot clé REFERENCES pour créer une relation de clé étrangère (FK) entre deux tables. Si vous utilisez tempdb, vous pouvez laisser un commentaire sur le mot clé --REFERENCES en le faisant précéder de deux tirets.

Ensuite, le diagramme affiche la relation entre les deux tables. Les valeurs présentes dans la colonne enfant tabEmployee.DepartmentCode sont limitées par celles de la colonne parente tabDepartment.DepartmentCode.

Diagramme affichant la clé étrangère

Notes

Vous pouvez modifier le code T-SQL pour ajouter un préfixe # aux noms des tables, ce qui les enregistre comme tables temporaires dans tempdb. Cette action est utile lors de démonstrations, si aucune base de données test n’est disponible. Aucune référence aux clés étrangères n’est appliquée lors de leur utilisation, et les tables temporaires sont automatiquement supprimées lorsque la connexion se termine à l’issue de l’exécution du programme.

Compilation et exécution

Logiquement, le programme C# est un fichier .cs qui est physiquement divisé en plusieurs blocs de code, ce qui rend chaque bloc plus facile à interpréter. Pour compiler et exécuter le programme, effectuez les étapes suivantes :

  1. Créez un projet C# dans Visual Studio. Le type de projet doit être une Console, située sous Modèles>Visual C#>Windows Desktop>Application console (.NET Framework) .

  2. Dans le fichier Program.cs, remplacez les lignes de code de démarrage par les étapes suivantes :

    1. Copiez et collez les blocs de code suivants, dans la même séquence que celle suivant laquelle ils sont présentés. Consultez Se connecter à la base de données, Générer des instructions T-SQL et envoyer à la base de données.

    2. Modifiez les valeurs suivantes dans la méthode Main :

      • cb.DataSource
      • cb.UserID
      • cb.Password
      • cb.InitialCatalog
  3. Vérifiez que l’assembly System.Data.dll est référencé. Pour vérifier, développez le nœud Références dans le volet Explorateur de solutions.

  4. Pour créer et exécuter le programme à partir de Visual Studio, sélectionnez le bouton Démarrer. La sortie du rapport s’affiche dans une fenêtre de programme, même si les valeurs GUID varient entre les séries de tests.

    =================================
    T-SQL to 2 - Create-Tables...
    -1 = rows affected.
    
    =================================
    T-SQL to 3 - Inserts...
    8 = rows affected.
    
    =================================
    T-SQL to 4 - Update-Join...
    2 = rows affected.
    
    =================================
    T-SQL to 5 - Delete-Join...
    2 = rows affected.
    
    =================================
    Now, SelectEmployees (6)...
    8ddeb8f5-9584-4afe-b7ef-d6bdca02bd35 , Alison , 20 , acct , Accounting
    9ce11981-e674-42f7-928b-6cc004079b03 , Barbara , 17 , hres , Human Resources
    315f5230-ec94-4edd-9b1c-dd45fbb61ee7 , Carol , 22 , acct , Accounting
    fcf4840a-8be3-43f7-a319-52304bf0f48d , Elle , 15 , NULL , NULL
    View the report output here, then press any key to end the program...
    

Se connecter à SQL Database avec ADO.NET

using System;
using System.Data.SqlClient;   // System.Data.dll
//using System.Data;           // For:  SqlDbType , ParameterDirection

namespace csharp_db_test
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                var cb = new SqlConnectionStringBuilder();
                cb.DataSource = "your_server.database.windows.net";
                cb.UserID = "your_user";
                cb.Password = "your_password";
                cb.InitialCatalog = "your_database";

                using (var connection = new SqlConnection(cb.ConnectionString))
                {
                    connection.Open();

                    Submit_Tsql_NonQuery(connection, "2 - Create-Tables", Build_2_Tsql_CreateTables());

                    Submit_Tsql_NonQuery(connection, "3 - Inserts", Build_3_Tsql_Inserts());

                    Submit_Tsql_NonQuery(connection, "4 - Update-Join", Build_4_Tsql_UpdateJoin(),
                        "@csharpParmDepartmentName", "Accounting");

                    Submit_Tsql_NonQuery(connection, "5 - Delete-Join", Build_5_Tsql_DeleteJoin(),
                        "@csharpParmDepartmentName", "Legal");

                    Submit_6_Tsql_SelectEmployees(connection);
                }
            }
            catch (SqlException e)
            {
                Console.WriteLine(e.ToString());
            }

            Console.WriteLine("View the report output here, then press any key to end the program...");
            Console.ReadKey();
        }

Méthodes qui retournent des instructions T-SQL

static string Build_2_Tsql_CreateTables()
{
    return @"
        DROP TABLE IF EXISTS tabEmployee;
        DROP TABLE IF EXISTS tabDepartment;  -- Drop parent table last.

        CREATE TABLE tabDepartment
        (
            DepartmentCode  nchar(4)          not null    PRIMARY KEY,
            DepartmentName  nvarchar(128)     not null
        );

        CREATE TABLE tabEmployee
        (
            EmployeeGuid    uniqueIdentifier  not null  default NewId()    PRIMARY KEY,
            EmployeeName    nvarchar(128)     not null,
            EmployeeLevel   int               not null,
            DepartmentCode  nchar(4)              null
            REFERENCES tabDepartment (DepartmentCode)  -- (REFERENCES would be disallowed on temporary tables.)
        );
    ";
}

static string Build_3_Tsql_Inserts()
{
    return @"
        -- The company has these departments.
        INSERT INTO tabDepartment (DepartmentCode, DepartmentName)
        VALUES
            ('acct', 'Accounting'),
            ('hres', 'Human Resources'),
            ('legl', 'Legal');

        -- The company has these employees, each in one department.
        INSERT INTO tabEmployee (EmployeeName, EmployeeLevel, DepartmentCode)
        VALUES
            ('Alison'  , 19, 'acct'),
            ('Barbara' , 17, 'hres'),
            ('Carol'   , 21, 'acct'),
            ('Deborah' , 24, 'legl'),
            ('Elle'    , 15, null);
    ";
}

static string Build_4_Tsql_UpdateJoin()
{
    return @"
        DECLARE @DName1  nvarchar(128) = @csharpParmDepartmentName;  --'Accounting';

        -- Promote everyone in one department (see @parm...).
        UPDATE empl
        SET
            empl.EmployeeLevel += 1
        FROM
            tabEmployee   as empl
        INNER JOIN
            tabDepartment as dept ON dept.DepartmentCode = empl.DepartmentCode
        WHERE
            dept.DepartmentName = @DName1;
    ";
}

static string Build_5_Tsql_DeleteJoin()
{
    return @"
        DECLARE @DName2  nvarchar(128);
        SET @DName2 = @csharpParmDepartmentName;  --'Legal';

        -- Right size the Legal department.
        DELETE empl
        FROM
            tabEmployee   as empl
        INNER JOIN
            tabDepartment as dept ON dept.DepartmentCode = empl.DepartmentCode
        WHERE
            dept.DepartmentName = @DName2

        -- Disband the Legal department.
        DELETE tabDepartment
            WHERE DepartmentName = @DName2;
    ";
}

static string Build_6_Tsql_SelectEmployees()
{
    return @"
        -- Look at all the final Employees.
        SELECT
            empl.EmployeeGuid,
            empl.EmployeeName,
            empl.EmployeeLevel,
            empl.DepartmentCode,
            dept.DepartmentName
        FROM
            tabEmployee   as empl
        LEFT OUTER JOIN
            tabDepartment as dept ON dept.DepartmentCode = empl.DepartmentCode
        ORDER BY
            EmployeeName;
    ";
}

Envoyer T-SQL à la base de données

static void Submit_6_Tsql_SelectEmployees(SqlConnection connection)
{
    Console.WriteLine();
    Console.WriteLine("=================================");
    Console.WriteLine("Now, SelectEmployees (6)...");

    string tsql = Build_6_Tsql_SelectEmployees();

    using (var command = new SqlCommand(tsql, connection))
    {
        using (SqlDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                Console.WriteLine("{0} , {1} , {2} , {3} , {4}",
                    reader.GetGuid(0),
                    reader.GetString(1),
                    reader.GetInt32(2),
                    (reader.IsDBNull(3)) ? "NULL" : reader.GetString(3),
                    (reader.IsDBNull(4)) ? "NULL" : reader.GetString(4));
            }
        }
    }
}

static void Submit_Tsql_NonQuery(
    SqlConnection connection,
    string tsqlPurpose,
    string tsqlSourceCode,
    string parameterName = null,
    string parameterValue = null
    )
{
    Console.WriteLine();
    Console.WriteLine("=================================");
    Console.WriteLine("T-SQL to {0}...", tsqlPurpose);

    using (var command = new SqlCommand(tsqlSourceCode, connection))
    {
        if (parameterName != null)
        {
            command.Parameters.AddWithValue(  // Or, use SqlParameter class.
                parameterName,
                parameterValue);
        }
        int rowsAffected = command.ExecuteNonQuery();
        Console.WriteLine(rowsAffected + " = rows affected.");
    }
}
} // EndOfClass
}

Conseil

Pour en savoir plus sur l’écriture de requêtes T-SQL, consultez Didacticiel : écrire des instructions Transact-SQL.

Étape suivante

Passez au tutoriel suivant pour en savoir plus sur la migration des données.