tag stored procedimiento parametros net framework ejecutar con asp almacenado agregar asp.net-mvc entity-framework stored-procedures repository-pattern

asp.net-mvc - procedimiento - entity framework stored procedure



utilizando el procedimiento almacenado en el marco de la entidad (6)

// ¡Agregue algunos inquilinos al contexto para que tengamos algo para devolver el procedimiento! AddTenentsToContext (Contexto);

// 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); }

Estoy usando asp.net mvc 5 y C # con Entity Framework ... Tengo clases de modelo y dominio para la función ... ahora necesito usar el procedimiento almacenado .... que estoy luchando en el movimiento.

Estoy siguiendo el código de la primera base de datos existente y he almacenado el procedimiento escrito allí. Mi pregunta es cómo puedo llamar a ese procedimiento almacenado en mi aplicación web.

Procedimiento almacenado:

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

Clase de dominio:

public class Functions { public Functions() { } public int Function_ID { get; set; } public string Title { get; set; } public int Hierarchy_level { get; set; } }

Modelo de función:

[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") { } }

Contexto de la función:

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


Debe crear una clase de modelo que contenga todas las propiedades de procedimiento almacenado como se muestra a continuación. Además, dado que la clase de modelo de Entity Framework necesita una clave principal, puede crear una clave falsa utilizando Guid.

public class GetFunctionByID { [Key] public Guid? GetFunctionByID { get; set; } // All the other properties. }

luego registre la clase del modelo GetFunctionByID en su DbContext .

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

Cuando llame a su procedimiento almacenado, simplemente vea a continuación:

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


Después de importar el procedimiento almacenado, puede crear el objeto del procedimiento almacenado pasar el parámetro como función

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

o también puedes usar 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>(); }


Puede llamar a un procedimiento almacenado utilizando SqlQuery (Consulte here )

// 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();


Sencillo. Simplemente crea una instancia de tu entidad, configúrala en un objeto y pásala a tu vista en tu controlador.

Entidad

VehicleInfoEntities db = new VehicleInfoEntities ();

Procedimiento almacenado

dbo.prcGetMakes ()

o

puede agregar cualquier parámetro en su procedimiento almacenado dentro de los corchetes ()

dbo.prcGetMakes ("BMW")

Controlador

public class HomeController : Controller { VehicleInfoEntities db = new VehicleInfoEntities(); public ActionResult Index() { var makes = db.prcGetMakes(null); return View(makes); } }


El pasajero sin mente tiene un proyecto que le permite llamar a un proceso almacenado desde el trabajo de marco de entidad como este ....

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>(); }

... y estoy trabajando en un marco de procedimientos almacenados ( aquí ) al que puedes llamar como en uno de mis métodos de prueba que se muestran a continuación ...

[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 alguno de esos dos enfoques es bueno?