Estou migrando algumas coisas de um servidor mysql para um servidor sql, mas não consigo descobrir como fazer esse código funcionar:

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

Quando entra no segundo foreach (var page in pages), lança uma exceção dizendo:

O LINQ to Entities não reconhece o método 'System.String ToString ()' e esse método não pode ser convertido em uma expressão de armazenamento.

Alguém sabe por que isso acontece?

Apenas salve a string em uma variável temporária e use-a na sua expressão:

var strItem = item.Key.ToString();

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

O problema surge porque, na ToString()verdade, não é executado, ele é transformado em um MethodGroup e, em seguida, analisado e traduzido para SQL. Como não há ToString()equivalente, a expressão falha.

Nota:

Verifique também a resposta de Alex sobre a SqlFunctionsclasse auxiliar que foi adicionada mais tarde. Em muitos casos, pode eliminar a necessidade da variável temporária.

Como outros responderam, isso é interrompido porque .ToString falha ao converter para SQL relevante no caminho para o banco de dados.

No entanto, a Microsoft fornece a classe SqlFunctions que é uma coleção de métodos que podem ser usados ​​em situações como essa.

Para este caso, o que você está procurando aqui é SqlFunctions.StringConvert :

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

Bom quando a solução com variáveis ​​temporárias não é desejável por qualquer motivo.

Semelhante ao SqlFunctions, você também tem o EntityFunctions (com EF6 obsoleto pelo DbFunctions ) que fornece um conjunto diferente de funções que também são independentes de fonte de dados (não limitadas a, por exemplo, SQL).

O problema é que você está chamando o ToString em uma consulta LINQ to Entities. Isso significa que o analisador está tentando converter a chamada ToString em seu SQL equivalente (o que não é possível ... daí a exceção).

Tudo o que você precisa fazer é mover a chamada ToString para uma linha separada:

var keyString = item.Key.ToString();

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

Teve um problema semelhante. Resolvido, chamando ToList () na coleção de entidades e consultando a lista. Se a coleção for pequena, essa é uma opção.

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

Espero que isto ajude.

Altere assim e deve funcionar:

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

O motivo pelo qual a exceção não é lançada na linha em que a consulta LINQ é declarada, mas na linha do foreaché o recurso de execução adiada, ou seja, a consulta LINQ não é executada até que você tente acessar o resultado. E isso acontece no foreache não antes.

Transmitir tabela para Enumerable, então você chama métodos LINQ usando o ToString()método dentro:

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

Mas tenha cuidado ao chamar métodos AsEnumerableou ToListporque você solicitará todos os dados de todas as entidades antes desse método. No meu caso acima, li todas as table_namelinhas por uma solicitação.

A atualização para o Entity Framework Versão 6.2.0 funcionou para mim.

Eu estava anteriormente na versão 6.0.0.

Espero que isto ajude,

No MVC, suponha que você esteja pesquisando registros com base em seus requisitos ou informações. Está funcionando corretamente.

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

Se você realmente deseja digitar ToStringdentro de sua consulta, pode escrever um visitante da árvore de expressão que reescreva a chamada ToStringcom uma chamada para a StringConvertfunção apropriada :

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

        }
    }
}

Eu recebi o mesmo erro neste 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);

Depois de passar muito tempo depurando, descobri que o erro aparecia na expressão lógica.

A primeira linha search.Contains(log.Id.ToString())funciona bem, mas a última linha que lida com um objeto DateTime fez com que falhasse miseravelmente:

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

Remova a linha problemática e o problema resolvido.

Eu não entendo completamente o porquê, mas parece que ToString () é uma expressão LINQ para strings, mas não para Entidades. O LINQ for Entities lida com consultas de banco de dados como SQL e SQL não tem noção de ToString (). Como tal, não podemos lançar ToString () em uma cláusula .Where ().

Mas como funciona a primeira linha? Em vez de ToString (), o SQL tem CASTe CONVERT, portanto, o meu melhor palpite até agora é que o linq for entity use isso em alguns casos simples. Os objetos DateTime nem sempre são tão simples ...

Basta transformar a consulta LINQ to Entity em uma consulta LINQ to Objects (por exemplo, chamar ToArray) sempre que precisar usar uma chamada de método na sua consulta LINQ.