Calling custom (formatting) method on LINQ to Entities

I'm using EF 4.1 and I'm trying to enumerate a company list for a grid. I have two options in the current project: select all companies from the DbContext (Entities) and load them into an object from a non-anonymous type (let's say EmpresaGrid) or select all companies into anonymous type objects with the same structure like Empresa (which is the entity I'm selecting from).

The first option (creating a model class for that) would require a little more work, but can be, eventually, more readable. Still, I'm not sure about that. The second option is what I'm using right now.

So, first question: it's better to create a model class only for displaying data or use 开发者_开发技巧anonymous type? Doing a direct select is out of question: a SELECT * is too big and that might make everything damn slow (I guess). So selection into another type creates a custom query with only the needed fields.

Using the second option (anonymous type), I have this code (simplified version):

public static IEnumerable<object> Grid()
{
    Entities db = new Entities();

    var empresas = db.Empresas
        .Select(e => new
        {
            Cgc = e.Cgc, // PK
            (...)
            Address = new
            {
                AddressLine = e.EnderecoSede.AddressLine,
                (...)
            }
        },
        Contato = e.Contato,
        (...)
    })
    .ToList();

    return empresas;
}

The anonymous type I'm creating has around 40 lines of code, so it's kinda big, but it recreates part of the Empresa class struct (since the grid is waiting for a Empresa object). Anyway, I have a problem with the data format. For example, I would like to format the Cgc property using a custom string format. I have a public method for this, FormataCgc. This method receives a string and returns it formatted using some internal conditions.

So, my problem is how to that. For example, I have tried this:

var empresas = db.Empresas
    .Select(e => new
    {
        Cgc = FormataCgc(e.Cgc),
    }

But that doesn't work because FormataCgc cannot be translated into SQL (and I don't want to convert it). I also tried this:

var empresas = db.Empresas
    .Select(e => new
    {
        (...)
    }
    .ToList();

foreach (var e in empresas) {
    e.Cgc = FormataCgc(e.Cgc);
}

But it cannot be done since anonymous types have only read-only properties.

So, my second question is: how exactly can I do that? I need to change the data after selecting it, but using anonymous types? I've done a little research, and the best thing I've found was this: Calling a custom method in LINQ query. In that solution, Ladislav suggested doing a second select from the IEnumerable, but since the grid is excepting Empresa I cannot do that (I need to change or add properties, not encapsulate them).

I'm not sure if I was clear enough, but feel free to ask any questions. Also, the grid I'm currently using is a Telerik ASP.NET MVC Grid, which receives a IEnumerable (where T is a class) as model data and them iterates each object, doing its magic.

---

Since you're already converting this into an IEnumerable<T>, you can do the custom formatting as you stream the results in the client. Do your db.Select, and then convert to the appropriate format afterwards, ie:

var empresas = db.Empresas
    .Select(e => new
    {
        (...)
    })
    .ToList();

foreach (var e in empresas) {
    yield return new {
       Cgc = FormataCgc(e.Cgc),
       // Copy other properties here, as needed...
    };
}

That being said, I'd personally recommend making a custom class, and not return an anonymous type. Your conversion would then be:

foreach (var e in empresas) {
    yield return new YourClass(FormataCgc(e.Cgc), ...); // Construct as needed
}

This will dramatically improve the usability of this method, as you will have proper, named access to your properties from the caller of the method.

---

I think the solution to both of your questions is to create a model class. Sure it is a little bit more work up front, but it will allow you greater flexibility in the long run. Your custom model class can then handle the formatting for you.

public class EmpresaGridModel
{
    public string Cgc { get; set; }

    public string CgcFormatted 
    {
        return FormataCgc(this.Cgc);
    }

    //properties for the other fields will have to be created as well obviously
}

Your telerik grid can then bind directly to the CgcFormatted property