web-dev-qa-db-fra.com

en utilisant une procédure stockée dans un cadre d'entité

J'utilise asp.net mvc 5 et C # avec Entity Framework ... J'ai des classes de modèle et de domaine pour la fonction ... maintenant, je dois utiliser une procédure stockée ... ce qui me fait mal au mouvement. 

Je suis le code première base de données existante et j'ai stocké la procédure écrite là. Ma question est la suivante: comment appeler cette procédure stockée dans mon application Web? 

Procédure stockée:

ALTER PROCEDURE [dbo].[GetFunctionByID](
    @FunctionId INT
)
AS
BEGIN
    SELECT * 
    FROM Functions As Fun
    WHERE Function_ID = @FunctionId
END

Classe de domaine:

 public class Functions
 {
    public Functions()
    {
    }

    public int Function_ID { get; set; }
    public string Title { get; set; }
    public int Hierarchy_level { get; set; }
}

Modèle de fonction:

[Table("Functions")]
public class App_Functions
{
    public App_Functions()
    {
    }

    [Key]
    public int Function_ID { get; set; }

    [StringLength(50)]
    [Required]
    public string Title { get; set; }

    public int Hierarchy_level { get; set; }
    //public virtual ICollection<App_Controllers> App_Controllers { get; set; }*/
}

BaseContext:

public class BaseContext<TContext> : DbContext where TContext : DbContext
{
    static BaseContext()
    {
        Database.SetInitializer<TContext>(null);
    }

    protected BaseContext()
        : base("name = ApplicationDbConnection")
    { }
}

Contexte de la fonction:

public class FunctionsContext : BaseContext<FunctionsContext>
{
    public DbSet<App_Functions> Functions { get; set; }
}
asp.net-mvcentity-frameworkstored-proceduresrepository-pattern
34
Toxic

Vous devez créer une classe de modèle contenant toutes les propriétés de procédure stockée telles que ci-dessous . De plus, la classe de modèle Entity Framework nécessitant une clé primaire, vous pouvez créer une fausse clé à l'aide de Guid.

public class GetFunctionByID
{
    [Key]
    public Guid? GetFunctionByID { get; set; }

    // All the other properties.
}

puis enregistrez la classe de modèle GetFunctionByID dans votre DbContext.

public class FunctionsContext : BaseContext<FunctionsContext>
{
    public DbSet<App_Functions> Functions { get; set; }
    public DbSet<GetFunctionByID> GetFunctionByIds {get;set;}
}

Lorsque vous appelez votre procédure stockée, voyez ci-dessous: 

var functionId = yourIdParameter;
var result =  db.Database.SqlQuery<GetFunctionByID>("GetFunctionByID @FunctionId", new SqlParameter("@FunctionId", functionId)).ToList());
40
Lin

Vous pouvez appeler une procédure stockée à l'aide de SqlQuery (voir ici )

// Prepare the query
var query = context.Functions.SqlQuery(
    "EXEC [dbo].[GetFunctionByID] @p1", 
    new SqlParameter("p1", 200));

// add NoTracking() if required

// Fetch the results
var result = query.ToList();
10
qujck

Après avoir importé une procédure stockée, vous pouvez créer un objet de procédure stockée en transmettant le paramètre comme fonction.

using (var entity = new FunctionsContext())
{
   var DBdata = entity.GetFunctionByID(5).ToList<Functions>();
}

ou vous pouvez aussi utiliser SqlQuery

using (var entity = new FunctionsContext())
{
    var Parameter = new SqlParameter {
                     ParameterName = "FunctionId",
                     Value = 5
            };

    var DBdata = entity.Database.SqlQuery<Course>("exec GetFunctionByID @FunctionId ", Parameter).ToList<Functions>();
}
9
user2854731

Simple. Instanciez simplement votre entité, définissez-la sur un objet et transmettez-la à votre vue dans votre contrôleur.

 enter image description here

Entité

VehicleInfoEntities db = new VehicleInfoEntities ();

Procédure stockée 

(dbo.prcGetMakes ()} _ 

ou

vous pouvez ajouter tous les paramètres de votre procédure stockée entre crochets ()

(dbo.prcGetMakes ("BMW")} _ 

Manette

public class HomeController : Controller
{
    VehicleInfoEntities db = new VehicleInfoEntities();

    public ActionResult Index()
    {
        var makes = db.prcGetMakes(null);

        return View(makes);
    }
}
0
Jason Ebersey

// Ajoute des locataires au contexte afin que nous puissions renvoyer la procédure! AddTenentsToContext (Context);

    // ACT
    // Get the results by calling the stored procedure from the context extention method 
    var results = Context.ExecuteStoredProcedure(procedure);

    // ASSERT
    Assert.AreEqual(expectedCount, results.Count);
}
0
gsgsgs

Passager sans âme a un projet qui vous permet d’appeler un proc stocké depuis un cadre de travail comme celui-ci ....

using (testentities te = new testentities())
{
    //-------------------------------------------------------------
    // Simple stored proc
    //-------------------------------------------------------------
    var parms1 = new testone() { inparm = "abcd" };
    var results1 = te.CallStoredProc<testone>(te.testoneproc, parms1);
    var r1 = results1.ToList<TestOneResultSet>();
}

... et je travaille sur un framework de procédures stockées ( ici ) que vous pouvez appeler comme dans l'une de mes méthodes de test ci-dessous ...

[TestClass]
public class TenantDataBasedTests : BaseIntegrationTest
{
    [TestMethod]
    public void GetTenantForName_ReturnsOneRecord()
    {
        // ARRANGE
        const int expectedCount = 1;
        const string expectedName = "Me";

        // Build the paraemeters object
        var parameters = new GetTenantForTenantNameParameters
        {
            TenantName = expectedName
        };

        // get an instance of the stored procedure passing the parameters
        var procedure = new GetTenantForTenantNameProcedure(parameters);

        // Initialise the procedure name and schema from procedure attributes
        procedure.InitializeFromAttributes();

        // Add some tenants to context so we have something for the procedure to return!
        AddTenentsToContext(Context);

        // ACT
        // Get the results by calling the stored procedure from the context extention method 
        var results = Context.ExecuteStoredProcedure(procedure);

        // ASSERT
        Assert.AreEqual(expectedCount, results.Count);
    }
}

internal class GetTenantForTenantNameParameters
{
    [Name("TenantName")]
    [Size(100)]
    [ParameterDbType(SqlDbType.VarChar)]
    public string TenantName { get; set; }
}

[Schema("app")]
[Name("Tenant_GetForTenantName")]
internal class GetTenantForTenantNameProcedure
    : StoredProcedureBase<TenantResultRow, GetTenantForTenantNameParameters>
{
    public GetTenantForTenantNameProcedure(
        GetTenantForTenantNameParameters parameters)
        : base(parameters)
    {
    }
}

Si l'une ou l'autre de ces deux approches est-elle bonne?

0
Dib