Anonymous type scoping issue

Question

What is the proper way to create a variable that will house a list of anonymous objects that are generated through a LINQ query while keeping the variable declaration outside of a try/catch and the assignment being handled inside of a try/catch?

At the moment I'm declaring the variable as IEnumberable<object>, but this causes some issues down the road when I'm trying to use it later...

i.e.

var variableDeclaration;
try{
    ...
    assignment
    ...
}catch...

EDIT:

If it's relevant (don't think it is) the list of objects is being returned as a Json result from an MVC3 action. I'm trying to reduce the time that some using statements are open with the DB as I'm having some performance issues that I'm trying to clear up a bit. In doing some of my testing I came across this issue and can't seem to find info on it.

EDIT 2:

If I could request the avoidance of focusing on LINQ. While LINQ is used the question is more specific to the scoping issues associated with Anonymous objects. Not the fact that LINQ is used (in this case) to generate them.

Also, a couple of answers have mentioned the use of dynamic while this will compile it doesn't allow for the usages that I'm needing later on the method. If what I'm wanting to do isn't possible then at the moment the answer appears to be to create a new class with the definition that I'm needing and to use that.

Answer 1

It's possible to get around this by creating a generic Cast method as outlined by Jon Skeet here. It will work and give you the intellisense you want. But, at this point, what's wrong with creating a custom type for your linq method?

public class MyClass
{
    public int MyInt { get; set; }
}

IEnumerable<MyClass> myClass = 
    //Some Linq query that returns a collection of MyClass

Answer 2

Well, if you're using LINQ, the query is not evaluated unless materialized...

So, you might be able to:

var myQuery = //blah
try
{
    myQuery = myQuery.ToList();  //or other materializing call
}
catch
{
}

Answer 3

Could you perhaps get away with using dynamic ??

     dynamic variableDeclaration;
     try
     {
         variableDeclaration = SomeList.Where(This => This == That);
     }
     catch { }

Not sure what this will affect further in your code block, but just a thought :)

Answer 4

If you are declaring the variable ahead of using it like a try/catch you can't use [var] as it is intendend. Instead you have to type the the variable.

var x = 0;
try{
   x = SomethingReturningAnInt();
}

or

int x;
try{
   x = SomethingReturningAnInt();
}

However in your case you don't really "know" what the method returns

var x = ...;
try{
   x = Something();
}
catch{}

won't work

Option you have when you don't know the type in advance is use of dynamic:

dynamic x;
try{
   x = Something();
}
catch{}

(But that feels like going back to VB4)