¿Cómo editar objeto en Entity Framework?




 DataContext.ApplyCurrentValues () necesita entitySetName, ¿qué es? 

 Creo que ese código sería el mismo: 


```
    public void Edit(Products p)
    {
        DataContext.ApplyCurrentValues("Products", p);
        DataContext.SaveChanges();
    }

```
  ¿Es correcto?
vea este artículo <http://msdn.microsoft.com/en-us/library/bb738695.aspx> y <http://msdn.microsoft.com/en-us/library/bb386870.aspx> muestra acerca de la actualización con EF.   
 Y esta pregunta SO sobre ApplyCurrentValues: [ApplyCurrentValues en EF 4](https://stackoverflow.com/questions/2272325/applycurrentvalues-in-ef-4) para ver cómo trabajar con AppliCurrentValues.
*Nota: la respuesta se proporcionó en un comentario en la pregunta original. Solo le estoy agregando un poco aquí, para hacerlo más visible y claro.* 





 Entity Framework obviamente asigna clases de C # a tablas de bases de datos a través de propiedades que representan las distintas columnas en cada tabla. Ahora, si el tipo de datos de una de estas propiedades no es compatible con el tipo de datos de su columna correspondiente en la base de datos, obtendrá una `System.InvalidCastException` cuando intente recuperar algo de esa tabla, incluso si la propiedad no coincide no está directamente involucrada en la búsqueda 

 En la pregunta, la consulta fue: 


```
User user = context.Users.First(i => i.UserId == id);

```
  No importa que tanto `id` como su propiedad correspondiente `UserId` sean válidas y compatibles entre sí aquí, porque lo que se está buscando es una instancia de toda la clase de `User` . 

 Aparentemente, el tipo de alguna otra propiedad en el `User` es incompatible con el tipo una columna con el mismo nombre en la tabla de `user` en la base de datos, por lo que el intento de mapearlo arroja la excepción anterior. Básicamente hay varias cosas que puedes hacer. 

* usando `SqlBulkCopy.WriteToServer` que no funciona muy bien junto con EF, sin embargo, existen varios intentos para crear extensiones
* utilizando un procedimiento almacenado que tomará un registro grande y lo dividirá de acuerdo con alguna lógica
* utilizando parámetros de procedimiento almacenado escritos en la tabla y realice una llamada al procedimiento almacenado (y varias `insert ... select` dentro del procedimiento almacenado)

 En general, prefiero la tercera opción. 

 Marque esta pregunta [Entity Framework Stored Procedure Tabla Valor Parámetro](https://stackoverflow.com/questions/8157345/entity-framework-stored-procedure-table-value-parameter) Tu pregunta es muy amplia, ya que existen varias formas de hacerlo.  
Pero te pido que me pases tu nivel de experiencia así se lo que te puedo recomendar, para que empieces te aconsejo que uses Textboxes, ComboBoxes, y Labels.  
Y para almacenar dichos datos en una base de datos, podes utilizar el Access para crearla, y desde VB utilizar un DataControl para enlazar la base de datos a tu programa. Contestame lo que te pregunte que te doy más ejemplos. ¿Dale?. El código de EF Core es exactamente el mismo. 


```
DbContext.Database.BeginTransaction(IsolationLevel.Snapshot);

```
  La única diferencia es que en EF Core el [método con nivel de aislamiento](https://docs.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.relationaldatabasefacadeextensions.begintransaction?view=efcore-2.1) (como muchos otros) es un método de *extensión* , definido en la clase [RelationalDatabaseFacadeExtensions](https://docs.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.relationaldatabasefacadeextensions?view=efcore-2.1) , y lo más importante, ubicado en [Microsoft.EntityFrameworkCore.Relational](https://www.nuget.org/packages/Microsoft.EntityFrameworkCore.Relational/) ensamblado. 

 Entonces, si ha `using Microsoft.EntityFrameworkCore;` y no lo vea, agregue referencia al ensamblado / paquete `Microsoft.EntityFrameworkCore.Relational.dll` . Aquí está la solución. Puede utilizar el siguiente código: 


```
context.Table.Where(x => x.Field1 > 0).Update(y => new Table { Field2 = y.Field2 + 1 });

```
  Espero que ayude. No he entendido la pregunta. No sé si te refieres a que si, por ejemplo, en un registro nuevo pusieras el código de un producto que ya está en un registro previo, no "rellene" ese registro y las cantidades se las sume al registro que ya está, o si por el contrario, que en un campo al que para el ejemplo llamaremos TotalProducto, te vaya "arrastrando" la suma de las cantidades de ese producto. Si no lo entiendo mal, lo que quieres es que un cuadro de Texto que tienes en el Formulario, muestre su valor en el Informe. Si eso es así >>

1.-Abre tu informe en Vista de diseño

2.- Añade un control Text Box

3.- En las Propiedades >> Pestaña Datos >> Origen del Control >>

![](//blob.todoexpertos.com/uploads/md/2eebcc982e45daad3d38c57ebecabe19.jpg)

Cambia FFrasFiltroGral por el Nombre de tu Formulario y

DesdeFecha por el Nombre del control, que tengas en el Formulario.

Si lo haces con el asistente, irás a lo seguro. Saludos >> JTJ Aun no he tenido la experiencia de hacer lo que me planteas, sin embargo todo apunta a que debe existir un objeto del tipo OLE, que windows debe poder poner al servicio del programador (en realidad a si funciona windows), igualmente si me comentas que ya encontraste una solución pero en VB, esto asienta mi teoría, bien lo que tienes que hacer es exactamente lo que hacer visual basic, seleccionas un contenedor del tipo OLE, lo incluyes en tu ventana o pantalla, y este te solicitara que indiques cual es al control ole, que deberá integrar, es posible que cuando estés leyendo mi respuesta, simplemente te preguntes "y bueno como manejo un objeto ole", personalmente yo encontré la respuesta en la demo que incluye power builder en su instalación.  
Allí encontraras todas las posibilidades de utilización de este lenguaje,   
De todas formas, en esta respuesta me permito incluirte una respuesta que di hace un tiempo atrás, referente al manejo de objetos ole, es posible que la misma pueda servirte.  
****************************  
aqui la respuesta  
****************************  
Relativamente es sencillo trabajar con este tipo de objetos.  
Antes que todo tienes que estar seguro de tener registrados los objetos que vas a trabajar, los cuales pueden ser tipo OLE, ACTIVEX, OCX, esto es relativamente sencillo, simplemente existen 2 caminos manual o automático, si es automático es por medio de un instalador.  
Un ejemplo puede ser que estés incluyendo un objeto de un fabricante de scanners en una aplicación que sirve para cobrar por medio de códigos de barra.  
Generalment el fabricante tiene un programa que maneja el scanner y este posee una utilidad y un objeto adicional, el cual esta incluydi en la instalación.  
El otro es manual y este se hace por medio de un programa que esta incluido en windows el cual es REGSVR32.EXE, este tiene su propia ayuda (en realidad este paso no tiene mayor problema)  
Una vez ya tengas registrado los objetos que vas a incluir o utilizar en tu programa los pasos son a seguir para poder utilizarlos son los siguientes.  
*- incluir en tu ventana un objeto contenedor ole, el cual inplantas, tal y como lo haces con cualquier objeto, desde la paleta de objetos.  
*- al momento de inlcuirlo, este abrira una ventana en la cual se encuentran todos los objetos ole, ocx, activex, disponibles, localiza el objeto que necesitas e incluyelo.  
*- una vez incluido este ya esta disponible para ser usado.  
Para poder ver todos los atributos del objeto externo, utiliza el BROWSER, el cual lo puedes encontrar en el editor gráfico, en la opción TOOLS-->BROWSER.  
Este posee una pestaña nominada OLE, en ella se encuentran todos los objetos externos, y divididos por tipo  
Si haces doble click en cualquier categoría, despliega el contenido de esta, simplemente localiza el objeto que estas utilizando y haciendo encima de el doble click, despliega las funciones, propiedades, métodos, eventos. Etc.  
Para poder invocar las características de un objeto externo por medio de un contenedor OLE,   
simplemente incluyes la palabra object.  
Por ejemplo  
Para modificar una propiedad sera  
<objeto ole>.objet.<propiedad> = <valor>  
para interrogar el valor de una propiedad  
<variable> = <objeto ole>.object.>propiedad>  
para invocar una funcion o metodo   
<objeto ole>.object.<funcion o metodo>()  
Y así sucesivamente.  
Hay una cosa que no puedes manejar con los objetos ole, y es el incluir scripts dentro de los eventos de ole, estos no están disponibles por power builder. Por lo que no podrás manejarlos, unidamente verlos, (por lo menos hasta la version 8.x esto no es posible)  
Como todos los objetos, el contenedor ole posee sus propios eventos, propiedades y métodos. Estos son totalmente independientes de los que contiene el objeto externo.  
Ya se que esto a lo mejor es muy poco como para poder iniciar tu incursión con objetos ole, sin embargo tienes programas fuentes, incluidos en la demo del power builder (si no la has instalado hazlo) en la cual muestra como manejarlos y ademas te puedes echar un paseo por los fuentes, y hasta re-utilizarlos. El autor de este artículo está algo equivocado: en .NET 4.5, la propiedad [AsynchronousProcessing](http://msdn.microsoft.com/en-us/library/system.data.sqlclient.sqlconnectionstringbuilder.asynchronousprocessing.aspx) se ignora porque ya no es necesaria. Puede comenzar a [llamar a los métodos Async](http://msdn.microsoft.com/en-us/library/hh211418.aspx) de SqlClient sin cadenas de conexión especiales. 

 Si las operaciones se ejecutarán de forma asíncrona, depende del proveedor de la base de datos. Por ejemplo, la implementación predeterminada de [DbCommand.ExecuteDbDataReaderAsync en](http://msdn.microsoft.com/en-us/library/system.data.common.dbcommand.executedbdatareaderasync.aspx) realidad se ejecuta de forma síncrona y bloquea el hilo de llamada. SqlCommand anula este método y se ejecuta de forma asíncrona. 

 Desafortunadamente, NpgsqlCommand no anula este método, por lo que solo le queda la ejecución síncrona. Creo que esto te servirá.  
For x:=0 to Numer\_Datos do begin  
 With TEdit.Create(Form1) do begin  
 Parent:=Form1;  
 Text:=DATO;  
 end;  
end;  
Esto te servirá para crear los edits.  
Después tendrás que ingeniártelas para colocarlos con el left y el top según te convenga.  
También te sugiero que crees un array  
(Edits:Array[0..1024] of TEdit) para poderlos eliminar, en caso de tener que refrescar la pantalla.  
Josep