We Keep Coding

Entity Framework Check virtual Lists after disposing of ObjectContext

My scenario is I have an object FOO which has a virtual List<bar> property on it. This is being auto generated by EF.
After I load FOO I dispose of the data context, I am turning FOO into a business object through a DTO. For example
var newFOO = FOO_Dto.change(FOO);
Inside of FOO_Dto.change I want to check if the virtual list property is empty/null. I understand that closing the ObjectContext and checking the navigation property will throw an error. In My Data Layer there are times when I return FOO with the list and FOO without the list.
My Question is how do I check the Navigation Property to see if the list has been populated or not and avoid the ObjectContext error that is currently generating
Thank you very much!!
EDIT
From the comments section, I purposely want the context closed before I check to see if I loaded the List<Bar> property.

No, you can't, other than the ugly way of trying and catching the exception. You can only determine whether a collection is loaded by getting the owner's DbEntityEntry, which you can only obtain through a context instance.
But if you know up front that the collection may be addressed outside the scope of the context, you need to load it while the context is alive, OR not load it and prevent lazy loading. You should never allow lazy loading to occur outside the lifespan of a context.
In most cases this means you'll have to turn off lazy loading and eagerly load all data required by a consuming method.
The more I work with EF in a disconnected fashion the less I allow lazy loading. I'm close to considering lazy loading an anti-pattern.

Check if property can be lazy loaded/is available without having to catch an exception

Basically I want to enable my foreign key properties to be loaded when needed even though the original context has been disposed.
I thought about editing the properties getters:
if (Author==null)
{
//load the author userprofile in a new dbcontext
Author = loadedAuthor;
}
return Author;
(Author is a foreign key property in the entity).
However every time I even attempt to check if the property is null it throws the following exception:
The ObjectContext instance has been disposed and can no longer be used
for operations that require a connection.
Is there no way to check if the property is "locally available" without having to catch an exception?

There is a property called AuthorReference that has a IsLoaded property. You can use that to check if your Author reference is loaded.

How do you check the state of a POCO that is attached to the EF Context?

What is the way to check the State of an entity which is a POCO (not derived from EntityObject) and that is attached to the EF context?
Thanks!

If you are using the DbContext and c is your entity reference
var state = Context.Entry(c).State;
if you are using ObjectContext.
//if x is your entity reference
var state = context.ObjectStateManager.GetObjectStateEntry(x);

if you are employing an identifier field and using DBContext, you may check using the following, assuming that the Id of entity is entityId;
if(Context.Entities.Local.Any(q => q.Id == entityId))
{
// already attached to the context
}
refer to this:
The Local property of DbSet provides simple access to the entities of
the set that are currently being tracked by the context and have not
been marked as Deleted. Accessing the Local property never causes a
query to be sent to the database.

winforms An entity object cannot be referenced by multiple instances of IEntityChangeTracker

I am getting this error when trying to add multiple properties.
public NewPropertyHelper(DataLayer.IAccrualRepository Repository) {
this.SaveAction = Properties => {
foreach (Property P in Properties)
{
Repository.Properties.AddObject(P);
Repository.SaveChanges();
}
};
}

From what I can gather, the line
Repository.Properties.AddObject(P);
is attempting to add the object P to the current repository, and since you got it from a different repository you'd need to remove it (or detach it) from the other repository first.
EDIT: So I am assuming that somewhere in Repository, there is a wrapped DataContext (or maybe Repository inherits your DataContext. When you get an object from a DataContext, the object is constantly references by a change tracker, which keeps track of what needs to be sent back to the database if you update that object. Because you don't want to double-count any objects, EF prevents you from attaching that object to more than one data context at a time. Before you can attach the object to a new data context, you need to detach it from the DataContext that is already tracking it.
To do that, you need to call the Detach method on the object and any objects that it references that are also tracked by EF. A good example of how to do that is here: http://www.codeproject.com/KB/linq/linq-to-sql-detach.aspx

Error Using ADO.NET Entity Framework

I want to convert a list to EntityCollection.
List<T> x = methodcall();
EntityCOllection<T> y = new EntityCollection<T>();
foreach(T t in x)
y.Add(t);
I get this error.
The object could not be added to the
EntityCollection or EntityReference.
An object that is attached to an
ObjectContext cannot be added to an
EntityCollection or EntityReference
that is not associated with a source
object.
Anyone know about this error?

It sounds like x is the result of an ObjectContext query. Each ObjectContext tracks the entities it reads from the database to enable update scenarios. It tracks the entities to know when (or if) they are modified, and which properties are modified.
The terminology is that the entities are attached to the ObjectContext. In your case, the entities in x are still attached to the ObjectContext that materialized them, so you can't add them to another EntityCollection at the same time.
You may be able to do that if you first Detach them, but if you do that, the first ObjectContext stops tracking them. If you never want to update those items again, it's not a problem, but if you later need to update them, you will have to Attach them again.

Basically all entity objects are controlled by an object context which serves as change tracker. The idea here is that the entities themselves are dumb to their environment, but the object context knows what's going on.
This is an inversion of the DataSet model where the tables track their own changes.
So objects are added to an object context and its entity collections directly. Here you've created an EntityCollection that's not associated with an object context and therefore can't have other objects added to them. They must first be attached to the object context.
Really what you probably want is to return IQueryable instead of IList. That would allow you to execute queries against the results of methodcall().