ADO.NET est-il possible dans .NET Core ?

Question

La plupart des tutoriels portent sur Entity Framework et ne mentionnent pas Ado.Net dans les projets .Net Core. J'ai une base de données "héritée", donc une approche EF/"Code-First" n'est pas une option.

Pour les connexions ADO.NET, est-ce que le System.Data.SqlClient disponibles pour un projet ASP.NET Core ?

Il est disponible lorsque j'utilise un modèle de projet .NET Framework, mais est-il encore disponible dans un projet .NET Core ?

Answer 1

L'existant SqlConnection et d'autres connexions connexes existe toujours au sein de la System.Data.SqlClient et devrait fonctionner comme prévu avec le cadre complet ou .NET Core.

Il vous suffira d'ajouter les références et les instructions d'utilisation appropriées pour l'inclure, par exemple par le biais de l'attribut System.Data.SqlClient comme indiqué ci-dessous dans votre project.json fichier :

et l'appeler ensuite via la syntaxe à laquelle vous êtes habitué :

using(var connection = new SqlConnection("{your-connection-string}"))
{
      // Do work here
}

Tant que vous disposez d'une chaîne de connexion valide pour vous connecter à votre ancienne base de données existante, tout devrait bien se passer.

Concernant l'utilisation de l'ORM

J'ai aussi découvert que certaines personnes utilisent Dapper, un Micro-ORM pour Entity Framework, apparemment plus flexible. Y a-t-il des avantages à l'utiliser au lieu d'ADO.NET ?

Ces ORM (object-relational mappers) sont des outils pratiques et souvent puissants qui peuvent plus facilement faire correspondre les données de votre base de données existante à des classes et des objets spécifiques, ce qui peut les rendre plus faciles à utiliser (par opposition à l'itération dans un lecteur de données, à l'analyse de chacune de vos lignes et à la construction manuelle de chaque objet).

En ce qui concerne les performances, cela dépend en fin de compte de ce que vous allez faire avec vos requêtes. ADO.NET sera généralement le plus rapide, car il s'agit d'une connexion de base à la base de données, mais dans certains scénarios, Dapper peut même le battre. Entity Framework, bien que très utile, est généralement à la traîne en termes de performances, simplement parce qu'il s'agit d'un ORM très vaste.

Encore une fois, cela dépend en fin de compte de ce que vous faites, mais toutes les options sont viables.

Answer 2

.NET Core 2.0 possède DataSet, DataTable et SQlDataAdapter. Voir ma réponse à https://blogs.msdn.microsoft.com/devfish/2017/05/15/exploring-datatable-and-sqldbadapter-in-asp-net-core-2-0/ .

Le code ci-dessous fonctionne bien

public static DataTable ExecuteDataTableSqlDA(SqlConnection conn, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
 {
 System.Data.DataTable dt = new DataTable();
 System.Data.SqlClient.SqlDataAdapter da = new SqlDataAdapter(cmdText, conn);
 da.Fill(dt);
 return dt;
 }

Answer 3

Comme Joe Healy l'a mentionné dans son réponse dans DotNet Core 2.0, il est possible d'utiliser toutes les fonctionnalités de System.Data.

Ajouter des pépites :

• Microsoft.Extensions.Configuration
• Microsoft.Extensions.Configuration.Json -- pour lire la chaîne de connexion à partir de json
• System.Data.Common
• System.Data.SqlClient

exemple de config.json :

{
  "connectionString": "your-db-connection-settings"
}

Voici un exemple d'application complète en console.

class Program
{
    static void Main(string[] args)
    {
        var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("config.json", false)
            .Build();

        var connectionString = configuration.GetSection("connectionString").Value;

        if(string.IsNullOrEmpty(connectionString))
            throw new ArgumentException("No connection string in config.json");

        using (var conn = new SqlConnection(connectionString))
        {
            var sql = "SELECT * FROM ExampleTable";
            using (var cmd = new SqlCommand(sql, conn))
            {
                using (var adapter = new SqlDataAdapter(cmd))
                {
                    var resultTable = new DataTable();
                    adapter.Fill(resultTable);
                }
            }
        }
    }
}

Answer 4

Il est important de noter que .NET Core ne dispose pas de DataSet, DataTable et des objets connexes avant la version 2.0. Mais avant la version 2.0, il possède toutes les fonctionnalités de base comme Connection, Command, Parameter, DataReader et autres objets connexes.

Vous pouvez utiliser les appels suivants pour simplifier la connectivité à SQL Server par le biais de SQL Server Database Provider.

public class BaseDataAccess
{
    protected string ConnectionString { get; set; }

    public BaseDataAccess()
    {
    }

    public BaseDataAccess(string connectionString)
    {
        this.ConnectionString = connectionString;
    }

    private SqlConnection GetConnection()
    {
        SqlConnection connection = new SqlConnection(this.ConnectionString);
        if (connection.State != ConnectionState.Open)
            connection.Open();
        return connection;
    }

    protected DbCommand GetCommand(DbConnection connection, string commandText, CommandType commandType)
    {
        SqlCommand command = new SqlCommand(commandText, connection as SqlConnection);
        command.CommandType = commandType;
        return command;
    }

    protected SqlParameter GetParameter(string parameter, object value)
    {
        SqlParameter parameterObject = new SqlParameter(parameter, value != null ? value : DBNull.Value);
        parameterObject.Direction = ParameterDirection.Input;
        return parameterObject;
    }

    protected SqlParameter GetParameterOut(string parameter, SqlDbType type, object value = null, ParameterDirection parameterDirection = ParameterDirection.InputOutput)
    {
        SqlParameter parameterObject = new SqlParameter(parameter, type); ;

        if (type == SqlDbType.NVarChar || type == SqlDbType.VarChar || type == SqlDbType.NText || type == SqlDbType.Text)
        {
            parameterObject.Size = -1;
        }

        parameterObject.Direction = parameterDirection;

        if (value != null)
        {
            parameterObject.Value = value;
        }
        else
        {
            parameterObject.Value = DBNull.Value;
        }

        return parameterObject;
    }

    protected int ExecuteNonQuery(string procedureName, List<DbParameter> parameters, CommandType commandType = CommandType.StoredProcedure)
    {
        int returnValue = -1;

        try
        {
            using (SqlConnection connection = this.GetConnection())
            {
                DbCommand cmd = this.GetCommand(connection, procedureName, commandType);

                if (parameters != null && parameters.Count > 0)
                {
                    cmd.Parameters.AddRange(parameters.ToArray());
                }

                returnValue = cmd.ExecuteNonQuery();
            }
        }
        catch (Exception ex)
        {
            //LogException("Failed to ExecuteNonQuery for " + procedureName, ex, parameters);
            throw;
        }

        return returnValue;
    }

    protected object ExecuteScalar(string procedureName, List<SqlParameter> parameters)
    {
        object returnValue = null;

        try
        {
            using (DbConnection connection = this.GetConnection())
            {
                DbCommand cmd = this.GetCommand(connection, procedureName, CommandType.StoredProcedure);

                if (parameters != null && parameters.Count > 0)
                {
                    cmd.Parameters.AddRange(parameters.ToArray());
                }

                returnValue = cmd.ExecuteScalar();
            }
        }
        catch (Exception ex)
        {
            //LogException("Failed to ExecuteScalar for " + procedureName, ex, parameters);
            throw;
        }

        return returnValue;
    }

    protected DbDataReader GetDataReader(string procedureName, List<DbParameter> parameters, CommandType commandType = CommandType.StoredProcedure)
    {
        DbDataReader ds;

        try
        {
            DbConnection connection = this.GetConnection();
            {
                DbCommand cmd = this.GetCommand(connection, procedureName, commandType);
                if (parameters != null && parameters.Count > 0)
                {
                    cmd.Parameters.AddRange(parameters.ToArray());
                }

                ds = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }
        }
        catch (Exception ex)
        {
            //LogException("Failed to GetDataReader for " + procedureName, ex, parameters);
            throw;
        }

        return ds;
    }
 }

Veuillez consulter l'article suivant pour plus de détails et d'exemples : http://www.ijz.today/2016/09/net-core-10-connecting-sql-server.html

Answer 5

Dans ADO.NET Core je n'utilise PAS System.Data.SqlClient mais j'utilise Microsoft.Data.SqlClient . Jusqu'à présent, je pouvais utiliser tous mes codes précédents !