Requête SQL brute sans DbSet-Entity Framework Core

vous pouvez exécuter du sql brut dans EF Core-Ajoutez cette classe à votre projet. Cela vous permettra d'exécuter du SQL brut et d'obtenir les résultats bruts sans avoir à définir un POCO et un DBSet. Voir https://github.com/aspnet/EntityFramework/issues/1862#issuecomment-220787464 pour l'exemple original.

using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Internal;
using Microsoft.EntityFrameworkCore.Storage;
using System.Threading;
using System.Threading.Tasks;

namespace Microsoft.EntityFrameworkCore
{
    public static class RDFacadeExtensions
    {
        public static RelationalDataReader ExecuteSqlQuery(this DatabaseFacade databaseFacade, string sql, params object[] parameters)
        {
            var concurrencyDetector = databaseFacade.GetService<IConcurrencyDetector>();

            using (concurrencyDetector.EnterCriticalSection())
            {
                var rawSqlCommand = databaseFacade
                    .GetService<IRawSqlCommandBuilder>()
                    .Build(sql, parameters);

                return rawSqlCommand
                    .RelationalCommand
                    .ExecuteReader(
                        databaseFacade.GetService<IRelationalConnection>(),
                        parameterValues: rawSqlCommand.ParameterValues);
            }
        }

        public static async Task<RelationalDataReader> ExecuteSqlQueryAsync(this DatabaseFacade databaseFacade, 
                                                             string sql, 
                                                             CancellationToken cancellationToken = default(CancellationToken),
                                                             params object[] parameters)
        {

            var concurrencyDetector = databaseFacade.GetService<IConcurrencyDetector>();

            using (concurrencyDetector.EnterCriticalSection())
            {
                var rawSqlCommand = databaseFacade
                    .GetService<IRawSqlCommandBuilder>()
                    .Build(sql, parameters);

                return await rawSqlCommand
                    .RelationalCommand
                    .ExecuteReaderAsync(
                        databaseFacade.GetService<IRelationalConnection>(),
                        parameterValues: rawSqlCommand.ParameterValues,
                        cancellationToken: cancellationToken);
            }
        }
    }
}

Voici un exemple de comment l'utiliser:

// Execute a query.
using(var dr = await db.Database.ExecuteSqlQueryAsync("SELECT ID, Credits, LoginDate FROM SamplePlayer WHERE " +
                                                          "Name IN ('Electro', 'Nitro')"))
{
    // Output rows.
    var reader = dr.DbDataReader;
    while (reader.Read())
    {
        Console.Write("{0}\t{1}\t{2} \n", reader[0], reader[1], reader[2]);
    }
}

en me basant sur les autres réponses j'ai écrit cet helper qui accomplit la tâche, y compris l'exemple d'utilisation:

public static class Helper
{
    public static List<T> RawSqlQuery<T>(string query, Func<DbDataReader, T> map)
    {
        using (var context = new DbContext())
        {
            using (var command = context.Database.GetDbConnection().CreateCommand())
            {
                command.CommandText = query;
                command.CommandType = CommandType.Text;

                context.Database.OpenConnection();

                using (var result = command.ExecuteReader())
                {
                    var entities = new List<T>();

                    while (result.Read())
                    {
                        entities.Add(map(result));
                    }

                    return entities;
                }
            }
        }
    }

Utilisation:

public class TopUser
{
    public string Name { get; set; }

    public int Count { get; set; }
}

var result = Helper.RawSqlQuery(
    "SELECT TOP 10 Name, COUNT(*) FROM Users U"
    + " INNER JOIN Signups S ON U.UserId = S.UserId"
    + " GROUP BY U.Name ORDER BY COUNT(*) DESC",
    x => new TopUser { Name = (string)x[0], Count = (int)x[1] });

result.ForEach(x => Console.WriteLine($"{x.Name,-25}{x.Count}"));

je prévois de m'en débarrasser dès que le support intégré sera ajouté. Selon un déclaration par Arthur Vickers de L'équipe de base de L'EF il s'agit d'une priorité élevée pour post 2.0. La question est suivie ici.

si vous utilisez EF Core 2.1 Release Candidate 1 Disponible depuis le 7 mai 2018, vous pouvez profiter de la nouvelle fonctionnalité proposée qui est le type de requête.

qu'est-Ce que type de requête?

en plus des types d'entités, un modèle de base de L'EE peut contenir des types de requête, qui peuvent être utilisés pour effectuer des requêtes de base de données sur des données n'est pas associé aux types d'entités.

Quand utiliser le type de requête?

Siégeant en tant que type de retour pour les ad hoc FromSql() requêtes.

Cartographie de vues de base de données.

Cartographie des tables qui n'ont pas de clé primaire.

Cartographie de requêtes définies dans le modèle.

ainsi, vous n'avez plus besoin de faire tous les piratages ou les solutions de rechange proposés pour répondre à votre question. Il suffit de suivre ces étapes:

vous avez d'abord défini une nouvelle propriété de type DbQuery<T> où T est le type de la classe qui portera les valeurs de la colonne de votre requête SQL. Donc, dans votre DbContext vous aurez ceci:

public DbQuery<SomeModel> SomeModels { get; set; }

d'autre part utiliser FromSql méthode comme vous le faites avec DbSet<T>:

var result = context.SomeModels.FromSql("SQL_SCRIPT").ToList();

pour l'instant, jusqu'à ce Qu'il y ait quelque chose de nouveau de EFCore j'utiliserais une commande et la carte manuellement

  using (var command = this.DbContext.Database.GetDbConnection().CreateCommand())
        {
            command.CommandText = "SELECT ... WHERE ...> @p1)";
            command.CommandType = CommandType.Text;
            var parameter = new SqlParameter("@p1",...);

            this.DbContext.Database.OpenConnection();

            using (var result = command.ExecuteReader())
            {
                while (result.Read())
                {
                   .... // Map to your entity
                }
            }
        }

essayez de SqlParameter pour éviter L'Injection de Sql.

       dbData.Product.FromSql("SQL SCRIPT");

FromSql ne fonctionne pas avec une requête complète. Exemple si vous voulez inclure une clause où elle sera ignorée.

Quelques Liens:

exécuter des requêtes SQL brutes en utilisant Entity Framework Core

requêtes SQL brutes

Core 2.1, vous pouvez faire quelque chose comme ceci:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
       modelBuilder.Query<Ranks>();
}

et puis vous définir Procédure SQL, de la forme:

public async Task<List<Ranks>> GetRanks(string value1, Nullable<decimal> value2)
{
    SqlParameter value1Input = new SqlParameter("@Param1", value1?? (object)DBNull.Value);
    SqlParameter value2Input = new SqlParameter("@Param2", value2?? (object)DBNull.Value);

    List<Ranks> getRanks = await this.Query<Ranks>().FromSql("STORED_PROCEDURE @Param1, @Param2", value1Input, value2Input).ToListAsync();

    return getRanks;
}

de cette façon, le modèle de classement ne sera pas créé dans votre base de données.

maintenant dans votre controller / action vous pouvez appeler:

List<Ranks> gettingRanks = _DbContext.GetRanks(value1,value2).Result.ToListAsync();

de cette façon, vous pouvez appeler les procédures brutes SQL.