Estoy migrando algunas cosas de un servidor mysql a un servidor sql, pero no puedo entender cómo hacer que este código funcione:

using (var context = new Context())
{
    ...

    foreach (var item in collection)
    {
        IQueryable<entity> pages = from p in context.pages
                                   where  p.Serial == item.Key.ToString()
                                   select p;
        foreach (var page in pages)
        {
            DataManager.AddPageToDocument(page, item.Value);
        }
    }

    Console.WriteLine("Done!");
    Console.Read();
}

Cuando entra en el segundo foreach (var page in pages), lanza una excepción que dice:

LINQ to Entities no reconoce el método 'System.String ToString ()', y este método no se puede traducir a una expresión de tienda.

Alguien sabe por qué pasa esto?

Simplemente guarde la cadena en una variable temporal y luego úsela en su expresión:

var strItem = item.Key.ToString();

IQueryable<entity> pages = from p in context.pages
                           where  p.Serial == strItem
                           select p;

El problema surge porque ToString()no se ejecuta realmente, se convierte en un MethodGroup y luego se analiza y traduce a SQL. Como no hay ToString()equivalente, la expresión falla.

Nota:

Asegúrese de consultar también la respuesta de Alex con respecto a la SqlFunctionsclase auxiliar que se agregó más tarde. En muchos casos, puede eliminar la necesidad de la variable temporal.

Como otros han respondido, esto se rompe porque .ToString no puede traducirse a SQL relevante en el camino hacia la base de datos.

Sin embargo, Microsoft proporciona la clase SqlFunctions que es una colección de métodos que se pueden usar en situaciones como esta.

Para este caso, lo que está buscando aquí es SqlFunctions.StringConvert :

from p in context.pages
where  p.Serial == SqlFunctions.StringConvert((double)item.Key.Id)
select p;

Bueno cuando la solución con variables temporales no es deseable por alguna razón.

Similar a SqlFunctions, también tiene las EntityFunctions (con EF6 obsoleto por DbFunctions ) que proporciona un conjunto diferente de funciones que también son independientes del origen de datos (no limitado a, por ejemplo, SQL).

El problema es que está llamando a ToString en una consulta LINQ to Entities. Eso significa que el analizador está tratando de convertir la llamada ToString en su SQL equivalente (que no es posible ... de ahí la excepción).

Todo lo que tiene que hacer es mover la llamada ToString a una línea separada:

var keyString = item.Key.ToString();

var pages = from p in context.entities
            where p.Serial == keyString
            select p;

Tuve un problema similar Lo resolvió llamando a ToList () en la colección de entidades y consultando la lista. Si la colección es pequeña, esta es una opción.

IQueryable<entity> pages = context.pages.ToList().Where(p=>p.serial == item.Key.ToString())

Espero que esto ayude.

Cámbialo así y debería funcionar:

var key = item.Key.ToString();
IQueryable<entity> pages = from p in context.pages
                           where  p.Serial == key
                           select p;

La razón por la cual la excepción no se arroja en la línea se declara la consulta LINQ sino en la línea de la foreachfunción de ejecución diferida, es decir, la consulta LINQ no se ejecuta hasta que intente acceder al resultado. Y esto sucede en el foreachy no antes.

Transmitir tabla a Enumerable, luego llama a los métodos LINQ con el uso del ToString()método dentro:

    var example = contex.table_name.AsEnumerable()
.Select(x => new {Date = x.date.ToString("M/d/yyyy")...)

Pero tenga cuidado, cuando llame AsEnumerableo ToListmétodos porque solicitará todos los datos de todas las entidades antes de este método. En mi caso anterior, leí todas las table_namefilas por una solicitud.

La actualización a Entity Framework Versión 6.2.0 funcionó para mí.

Anteriormente estaba en la versión 6.0.0.

Espero que esto ayude,

En MVC, suponga que está buscando registros según sus requisitos o información. Funciona correctamente

[HttpPost]
[ActionName("Index")]
public ActionResult SearchRecord(FormCollection formcollection)
{       
    EmployeeContext employeeContext = new EmployeeContext();

    string searchby=formcollection["SearchBy"];
    string value=formcollection["Value"];

    if (formcollection["SearchBy"] == "Gender")
    {
        List<MvcApplication1.Models.Employee> emplist = employeeContext.Employees.Where(x => x.Gender == value).ToList();
        return View("Index", emplist);
    }
    else
    {
        List<MvcApplication1.Models.Employee> emplist = employeeContext.Employees.Where(x => x.Name == value).ToList();
        return View("Index", emplist);
    }         
}

Si realmente desea escribir ToStringdentro de su consulta, puede escribir un visitante del árbol de expresiones que reescriba la llamada ToStringcon una llamada a la StringConvertfunción adecuada :

using System.Linq;
using System.Data.Entity.SqlServer;
using System.Linq.Expressions;
using static System.Linq.Expressions.Expression;
using System;

namespace ToStringRewriting {
    class ToStringRewriter : ExpressionVisitor {
        static MethodInfo stringConvertMethodInfo = typeof(SqlFunctions).GetMethods()
                 .Single(x => x.Name == "StringConvert" && x.GetParameters()[0].ParameterType == typeof(decimal?));

        protected override Expression VisitMethodCall(MethodCallExpression node) {
            var method = node.Method;
            if (method.Name=="ToString") {
                if (node.Object.GetType() == typeof(string)) { return node.Object; }
                node = Call(stringConvertMethodInfo, Convert(node.Object, typeof(decimal?));
            }
            return base.VisitMethodCall(node);
        }
    }
    class Person {
        string Name { get; set; }
        long SocialSecurityNumber { get; set; }
    }
    class Program {
        void Main() {
            Expression<Func<Person, Boolean>> expr = x => x.ToString().Length > 1;
            var rewriter = new ToStringRewriter();
            var finalExpression = rewriter.Visit(expr);
            var dcx = new MyDataContext();
            var query = dcx.Persons.Where(finalExpression);

        }
    }
}

Recibí el mismo error en este caso:

var result = Db.SystemLog
.Where(log =>
    eventTypeValues.Contains(log.EventType)
    && (
        search.Contains(log.Id.ToString())
        || log.Message.Contains(search)
        || log.PayLoad.Contains(search)
        || log.Timestamp.ToString(CultureInfo.CurrentUICulture).Contains(search)
    )
)
.OrderByDescending(log => log.Id)
.Select(r => r);

Después de pasar demasiado tiempo depurando, descubrí que el error apareció en la expresión lógica.

La primera línea search.Contains(log.Id.ToString())funciona bien, pero la última línea que trata con un objeto DateTime hizo que fallara miserablemente:

|| log.Timestamp.ToString(CultureInfo.CurrentUICulture).Contains(search)

Elimine la línea problemática y el problema resuelto.

No entiendo completamente por qué, pero parece que ToString () es una expresión LINQ para cadenas, pero no para Entidades. LINQ for Entities trata consultas de bases de datos como SQL, y SQL no tiene noción de ToString (). Como tal, no podemos lanzar ToString () en una cláusula .Where ().

¿Pero cómo funciona la primera línea? En lugar de ToString (), SQL tiene CASTy CONVERT, así que mi mejor suposición hasta ahora es que linq para entidades usa eso en algunos casos simples. Los objetos DateTime no siempre son tan simples ...

Simplemente convierta la consulta LINQ to Entity en una consulta LINQ to Objects (por ejemplo, llame a ToArray) cada vez que necesite usar una llamada a un método en su consulta LINQ.