Comment faire pour exécuter des procédures stockées dans Entity Framework Core?

De soutien pour la procédure stockée dans EF7 est résolu maintenant, cela contribue également à la cartographie des multiples résultats.

Vérifiez ici pour la correction de détails

Et vous pouvez l'appeler comme cela en c#

var userType = dbContext.Set().FromSql("dbo.SomeSproc @Id = {0}, @Name = {1}", 45, "Ada");

Pour exécuter les procédures stockées, utilisez FromSql méthode qui exécute les PREMIÈRES requêtes SQL

par exemple

    var products= context.Products
        .FromSql("EXECUTE dbo.GetProducts")
        .ToList();

À utiliser avec les paramètres

    var productCategory= "Electronics";

    var product = context.Products
        .FromSql("EXECUTE dbo.GetProductByCategory {0}", productCategory)
        .ToList();

ou

    var productCategory= new SqlParameter("productCategory", "Electronics");

    var product = context.Product
        .FromSql("EXECUTE dbo.GetProductByName  @productCategory", productCategory)
        .ToList();

Il y a certaines limites à exécuter des PREMIÈRES requêtes SQL ou des procédures stockées. Vous ne pouvez pas l'utiliser pour les INSERT/UPDATE/DELETE. si vous souhaitez exécuter des instructions INSERT, UPDATE, DELETE requêtes, utilisez le ExecuteSqlCommand

    var categoryName = "Electronics";
    dataContext.Database
               .ExecuteSqlCommand("dbo.InsertCategory @p0", categoryName);

Le soutien pour la procédure stockée en EF de Base est semblable aux versions antérieures de EF premier Code.

Vous avez besoin pour créer votre classe DbContext par inherting la classe DbContext de EF. Les procédures stockées sont en cours d'exécution à l'aide de la DbContext.

Première étape est d'écrire une méthode qui créer un DbCommand de la DbContext.

public static DbCommand LoadStoredProc(
  this DbContext context, string storedProcName)
{
  var cmd = context.Database.GetDbConnection().CreateCommand();
  cmd.CommandText = storedProcName;
  cmd.CommandType = System.Data.CommandType.StoredProcedure;
  return cmd;
}

Pour passer des paramètres à la procédure stockée utiliser la méthode suivante.

public static DbCommand WithSqlParam(
  this DbCommand cmd, string paramName, object paramValue)
{
  if (string.IsNullOrEmpty(cmd.CommandText))
    throw new InvalidOperationException(
      "Call LoadStoredProc before using this method");
  var param = cmd.CreateParameter();
  param.ParameterName = paramName;
  param.Value = paramValue;
  cmd.Parameters.Add(param);
  return cmd;
}

Enfin pour la cartographie le résultat dans une liste d'objets personnalisés, utilisez le MapToList méthode.

private static List<T> MapToList<T>(this DbDataReader dr)
{
  var objList = new List<T>();
  var props = typeof(T).GetRuntimeProperties();

  var colMapping = dr.GetColumnSchema()
    .Where(x => props.Any(y => y.Name.ToLower() == x.ColumnName.ToLower()))
    .ToDictionary(key => key.ColumnName.ToLower());

  if (dr.HasRows)
  {
    while (dr.Read())
    {
      T obj = Activator.CreateInstance<T>();
      foreach (var prop in props)
      {
        var val = 
          dr.GetValue(colMapping[prop.Name.ToLower()].ColumnOrdinal.Value);
          prop.SetValue(obj, val == DBNull.Value ? null : val);
      }
      objList.Add(obj);
    }
  }
  return objList;
}

Nous sommes maintenant prêts pour exécuter la stockées procedute avec le ExecuteStoredProc méthode et des cartes à la une Liste dont le type qui est transmis en tant que T.

public static async Task<List<T>> ExecuteStoredProc<T>(this DbCommand command)
{
  using (command)
  {
    if (command.Connection.State == System.Data.ConnectionState.Closed)
    command.Connection.Open();
    try
    {
      using (var reader = await command.ExecuteReaderAsync())
      {
        return reader.MapToList<T>();
      }
    }
    catch(Exception e)
    {
      throw (e);
    }
    finally
    {
      command.Connection.Close();
    }
  }
}

Par exemple, pour exécuter une procédure stockée appelée “StoredProcedureName” avec deux paramètres appelés “firstparamname” et “secondparamname” c'est la mise en œuvre.

List<MyType> myTypeList = new List<MyType>();
using(var context = new MyDbContext())
{
  myTypeList = context.LoadStoredProc("StoredProcedureName")
  .WithSqlParam("firstparamname", firstParamValue)
  .WithSqlParam("secondparamname", secondParamValue).
  .ExecureStoredProc<MyType>();
}

J'ai essayé toutes les autres solutions, mais n'a pas fonctionné pour moi. Mais j'ai une bonne solution et il peut être utile pour quelqu'un ici.

Pour appeler une procédure stockée et obtenir le résultat dans une liste de modèle EF de Base, nous avons à suivre 3 étapes.

L'étape 1.
Vous avez besoin d'ajouter une nouvelle catégorie à l'instar de votre classe d'entité. Ce qui devrait avoir des propriétés avec toutes les colonnes dans votre SP. Par exemple, si votre SP est de retour en deux colonnes appelé Id et Name alors votre nouvelle classe doit être quelque chose comme

public class MySPModel
{
    public int Id {get; set;}
    public string Name {get; set;}
}

L'étape 2.

Puis vous devez ajouter un DbQuery bien dans votre classe DBContext pour votre SP.

public partial class Sonar_Health_AppointmentsContext : DbContext
{
        public virtual DbSet<Booking> Booking { get; set; } //your existing DbSets
        ...

        public virtual DbQuery<MySPModel> MySP { get; set; } //your new DbQuery
        ...
}

L'étape 3.

De maintenant, vous serez en mesure de les appeler et obtenir le résultat de votre SP de votre DBContext.

var result = await _context.Query<MySPModel>().AsNoTracking().FromSql(string.Format("EXEC {0} {1}", functionName, parameter)).ToListAsync();

Je suis à l'aide d'un générique UnitOfWork & Référentiel. Donc ma fonction à exécuter la SP est

///<summary>
///Execute function. Be extra care when using this function as there is a risk for SQL injection
///</summary>
public async Task<IEnumerable<T>> ExecuteFuntion<T>(string functionName, string parameter) where T : class
{
    return await _context.Query<T>().AsNoTracking().FromSql(string.Format("EXEC {0} {1}", functionName, parameter)).ToListAsync();
}

Espère que ce sera utile à quelqu'un !!!

J'ai eu beaucoup de mal avec le ExecuteSqlCommand et ExecuteSqlCommandAsync, DANS les paramètres ont été facile, mais les paramètres ont été très difficiles.

J'ai dû revenir à l'utilisation DbCommand comme

DbCommand cmd = _context.Database.GetDbConnection().CreateCommand();

cmd.CommandText = "dbo.sp_DoSomething";
cmd.CommandType = CommandType.StoredProcedure;

cmd.Parameters.Add(new SqlParameter("@firstName", SqlDbType.VarChar) { Value = "Steve" });
cmd.Parameters.Add(new SqlParameter("@lastName", SqlDbType.VarChar) { Value = "Smith" });

cmd.Parameters.Add(new SqlParameter("@id", SqlDbType.BigInt) { Direction = ParameterDirection.Output });

Je l'ai écrit plus à ce sujet dans ce post.

Rien à faire... lors de la création de dbcontext pour une première approche de code initialiser
espace de noms ci-dessous l'API fluent zone de liste du ps et de l'utiliser à un autre endroit où vous voulez.

public partial class JobScheduleSmsEntities : DbContext
{
    public JobScheduleSmsEntities()
        : base("name=JobScheduleSmsEntities")
    {
        Database.SetInitializer<JobScheduleSmsEntities>(new CreateDatabaseIfNotExists<JobScheduleSmsEntities>());
    }

    public virtual DbSet<Customer> Customers { get; set; }
    public virtual DbSet<ReachargeDetail> ReachargeDetails { get; set; }
    public virtual DbSet<RoleMaster> RoleMasters { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        //modelBuilder.Types().Configure(t => t.MapToStoredProcedures());

        //modelBuilder.Entity<RoleMaster>()
        //    .HasMany(e => e.Customers)
        //    .WithRequired(e => e.RoleMaster)
        //    .HasForeignKey(e => e.RoleID)
        //    .WillCascadeOnDelete(false);
    }
    public virtual List<Sp_CustomerDetails02> Sp_CustomerDetails()
    {
        //return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction<Sp_CustomerDetails02>("Sp_CustomerDetails");
        // this.Database.SqlQuery<Sp_CustomerDetails02>("Sp_CustomerDetails");
        using (JobScheduleSmsEntities db = new JobScheduleSmsEntities())
        {
           return db.Database.SqlQuery<Sp_CustomerDetails02>("Sp_CustomerDetails").ToList();

        }

    }

}

}

public partial class Sp_CustomerDetails02
{
    public long? ID { get; set; }
    public string Name { get; set; }
    public string CustomerID { get; set; }
    public long? CustID { get; set; }
    public long? Customer_ID { get; set; }
    public decimal? Amount { get; set; }
    public DateTime? StartDate { get; set; }
    public DateTime? EndDate { get; set; }
    public int? CountDay { get; set; }
    public int? EndDateCountDay { get; set; }
    public DateTime? RenewDate { get; set; }
    public bool? IsSMS { get; set; }
    public bool? IsActive { get; set; }
    public string Contact { get; set; }
}