I am a developer from Enlighten Designs and have just recently released a fairly well trafficked site that uses EntitySpaces
 (to a degree, I might go into that in another post) for it's DAL.  Since 90% of the database is only updated at most once a 
day at a scheduled time and the fact that site does get hit quite hard we cache alot of reference data from tables
 (such as a country list). While I have gotten the impression before from reading the forums that Mike seems to be against caching 
actual ES objects we tried it anyway. Basically we just call LoadAll on a few collections and dump them into the cache, grabbing it 
back out of the cache at a later dateand use FindByPrimaryKey. Unfortunately we came across a fun Thread Saftey issue.

 Code:

1    protected esEntity FindByPrimaryKey(object primaryKeyValue)
2    {
3        if (base.Table != null)
4        {
5            this.AssignPrimaryKeys();
6            DataRow row = base.Table.Rows.Find(primaryKeyValue);
7            this.RemovePrimaryKeys();
8            if (row != null)
9            {
10               return this.entities[row];
11           }
12       }
13       return null;
14   }

If two threads are in the above method; it is possible for the following situatio to arise: thread #2 just finishes line 5 and is about to 
execute line 6 while thread #1 is slightly ahead and completes line 7.  Meaning thread #2 is attempting a Rows.Find on a table with
no primary  keys assigned. Normally this wouldn't be an issue but since we have multiple threads playing with the exact same collection
object we start getting some interesting results.  We have a temp fix which is as below, but as you can see it's certainly not optimal
and are currently pondering dropping the esEntityCollection object in favor of a simple Dictionary<int, esEntity>
 (what I wouldn't give for a esEntityCollection.ToDictionary() method right now) 

 Code:

1    protected esEntity FindByPrimaryKey2(object primaryKeyValue)
2    {
3        lock(this) {
4           return FindByPrimaryKey(primaryKeyValue);
5        }
6    }
 
 

Code:

        public static implicit operator List(EmployeeCollection coll)
        {
            List list = new List();

            foreach (Employee emp in coll)
            {
                list.Add(emp);
            }

            return list;
        }	

Code:

        public static implicit operator Dictionary<int, Employee>(EmployeeCollection coll)
        {
            Dictionary<int, Employee> dictionary = new Dictionary<int, Employee>();

            foreach (Employee emp in coll)
            {
                dictionary[emp.EmployeeID.Value] = emp;
            }

            return dictionary;
        }	

Code:

EmployeeCollection coll = new EmployeeCollection();
coll.LoadAll();

Dictionary<int, Employee> dictionary = coll;

//In the MetaDataClass?
public struct PrimaryKey { int employeeID, int cloneID };

//The EsEntity would then need a new method to get the PK
public static implicit operator PrimaryKey(Employee emp)
{
  PrimaryKey pk = new PrimaryKey();
  pk.employeeID = emp.EmployeeID;
  pk.cloneID = emp.CloneID;
  return pk;
}

//DictionaryMethod
public static implicit operator Dictionary<PrimaryKey, Employee>(EmployeeCollection coll)
{
  Dictionary<PrimaryKey, Employee> dictionary = new Dictionary<PrimaryKey, Employee>

  foreach (Employee emp in coll)
  {
    dictionary[emp] = emp;
  }

  return dictionary
}

Code:

EmployeeCollection coll = new EmployeeCollection();
coll.LoadAll();

// Creates the internal dictionary?
coll.EnableCaching = true;

// key is a concatenation of the primarykeys (calls static method)
string key = Employee.CreatePrimaryKeyToken(employeeId, cloneID);

// Works no matter how many keys are in the PK
Employee emp = coll.GetCachedObject(key);

Code:

public static implicit operator Dictionary<string, Employee>(EmployeeCollection coll)
{
  Dictionary<string, Employee> dictionary = new Dictionary<string, Employee>

  foreach (Employee emp in coll)
  {
    string token = Employee.CreatePrimaryKeyToken(emp.EmployeeId, emp.CloneID);
    dictionary[token] = emp;
  }

  return dictionary
}