Detaching a Query in Linq to Sql

Question

For my application I want to be able (if possible) to execute a LINQ to SQL query outside of it's context.

The reason this would be nice for me is that I would store the IQueryable in objects in the cache. When I later need them they would be executed and the cached object would be updated with the items from the query.

The reason I want to be able to do this unorthodox thing is because of how the CMS I use is built.

Have anyone done anything like this before?

Edit, Further Explanation: In the CMS I work with (EPiServer) I have built and attached a Custom Page Provider. Which lets me make Pages of any datasource. In it I am responsible with creating PageData for the CMS. The PageData consists of Properties which I also populate in my Provider.

My method that builds PageData gets called when it does a listing aswell as getting a specific page. When it does a listing it uses only a small amount of the properties needed in the PageData so I'd like to instead of setting a result set to a property, I'd like to set an query. In that way, the queries to the database will only be executed when needed.

The PageData object is after my creation Cached. But when it's not cached I don't want to make 7 queries against the database for just a listing.

Answer 1

Is this for performance purposes?

Caching the results of LINQ queries
http://petemontgomery.wordpress.com/2008/08/07/caching-the-results-of-linq-queries/

Answer 2

Would this work?

var myIQueryableObject = (query).ToList().AsQueryable();

Answer 3

Do you mean you want to attach a query (an IQueryable) to a new datacontext instance? Or a completely different datacontext?

If so, you could take the query, replace all references to the DC instance in the query's expression tree (query.expression) using something like this:
http://huagati.blogspot.com/2009/10/code-sample-search-and-replace-in-linq.html

...and then create a new query using IQueryProvider.CreateQuery. For the last step you can get hold of the IQueryProvider from a 'dummy query' against the new DC, e.g.:

IQueryable<Foo> dummyQuery = dc.Foos;
IQueryProvider prov = dummyQuery.Provider;

---

Update:

After the clarification of the question, I think what you're maybe looking for is having your queries wrapped in iterator functions.

E.g.:

public IEnumerable<SomeEntity> SomeEntityQuery()
{
    //run the query
    List<SomeEntity> result = null;
    using (SomeDataContext dc = new SomeDataContext())
    {
        result = (from se in dc.SomeEntity where ... select se).ToList();
    }

    //and return the query results
    foreach (SomeEntity se in result)
    {
        yield return se;
    }
}

...and then:

//the query will not run when this assignment takes place...
IEnumerable<SomeEntity> someEntityList = SomeEntityQuery();

//but when we start enumerating the results, the SomeEntityQuery method
// will execute the query and then begin returning the results...
foreach (SomeEntity se in someEntityList)
{

}