Est ADO.NET dans .NET de Base possible?

L'existant SqlConnection et d'autres connexions existe encore au sein de la System.Data.SqlClient espace de noms et doit fonctionner comme prévu à l'aide du plein cadre ou .NET de Base.

Vous aurez juste besoin d'ajouter les références appropriées, et à l'aide des déclarations de l'inclure comme par la System.Data.SqlClient espace de noms comme on le voit ci-dessous dans votre project.json fichier :

et ensuite appeler par l'intermédiaire de la syntaxe que vous vous êtes habitué :

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

Donc, tant que vous avez une chaîne de connexion valide pour se connecter à votre base de données existante, vous devriez être bien.

Concernant l'Utilisation de l'ORM

J'ai aussi constaté que certaines personnes sont à l'aide de Dapper, un Micro-ORM
remplacement d'Entity Framework, apparenty plus souple. C'est là
les avantages de l'utiliser à la place ADO.NET?

Ces Orm (object-relational mappeurs) sont à portée de main et, souvent, des outils puissants qui peuvent plus facilement le plan de votre base de données existante de données spécifiques à des classes et des objets, ce qui peut les rendre plus faciles à utiliser (par opposition à une itération à travers un lecteur de données, l'analyse de chacune de vos lignes et la construction de chaque objet manuellement).

Autant que la performance va, il dépend finalement de ce que vous allez faire avec vos requêtes. ADO.NET sera généralement le plus rapide comme un bare-bones de connexion à la base de données, toutefois, dans certains scénarios Dapper peut battre ça. Entity Framework, bien que très utile, généralement derrière des performances, tout simplement parce qu'il est tel un grand ORM.

De nouveau - il en fin de compte dépend de ce que vous faites, mais tous sont des options viables.

Il est important de noter que .NET de Base n'a pas DataSet, DataTable et objets connexes avant la version 2.0. Mais avant 2.0, on a tous des fonctionnalités de base comme Connexion, de Commande, Paramètre, l'objet DataReader et d'autres objets liés à l'.

Vous pouvez utiliser à la suite d'appels à simplifier la connectivité à SQL Server à l'aide de SQL Server Fournisseur de Base de données.

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 vous référer à l'article suivant pour plus de détails et d'exemples:
http://www.ijz.today/2016/09/net-core-10-connecting-sql-server.html

Dans ADO.NET de Base, je n'utilise PAS le Système.Les données.SqlClient mais j'utilise Microsoft.Les données.SqlClient.
Jusqu'à maintenant, je pourrais utiliser mon précédent codage!.