1. Populate the data structures, load FKs, etc. every time somebody asks for the data.  This defeats the whole purpose of trying to build the data up once to be used multiple times.  We could try to 'cache' the built up data, but when the entity gets re-loaded from the DB, we'd need to know about that so we could clear the cache.  But we don't have a Dev Force event that fires early enough to know we need to clear our cached values.
2. Mark all our initialization data with [DataContract] so it gets serialized to the server and back.  This seemed like it might work but then we'd be wasting a lot of bandwidth sending data to the server and back - and sometimes our initialization data can be quite large.
3. Find some way to defer our validations during an EntityManager.Merge(...) call and then run the validations manually after the merge.  This seems doable but then it's just one more hoop we have to jump through and then who knows what could be the next thing to break.

        /// <summary>
        /// Merges this <see cref="EntityCacheState"/> into an <see cref="EntityManager"/>.  This method will
        /// defer validation until after all entities have been merged and initialized.
        /// </summary>
        /// <param name="cacheState">The data to merge</param>
        /// <param name="em">EntityManager to merge data into</param>
        /// <param name="restoreStrategy">The restore strategy to use</param>
        /// <returns>An collection of original entityKeys and the EntityAspects that they were merged into</returns>
        /// <remarks>
        /// <b>Merge</b> is functionally equivalent to the
        /// <see cref="CacheStateManager.RestoreCacheState(EntityCacheState, RestoreStrategy)" />
        /// method in <see cref="T:IdeaBlade.EntityModel.CacheStateManager" />.
        /// </remarks>
        public static IEnumerable<Tuple<EntityKey, EntityAspect>> SafeMerge(
            this EntityCacheState cacheState,
            EntityManager em,
            RestoreStrategy restoreStrategy)
        {
            //This will keep track of the entities that were affected by the Merge and had previous 
            //  validation errors.  DevForce will clear those validation errors and then try to validate
            //  the updated entity.  Since that will be too early for our liking (we want entity initialization to have
            //  occurred), we will have validations disabled.  Once the Merge is complete, we'll manually validate
            //  these entities to get the same behavior Dev Force would otherwise have.
            var toValidate = new List<Entity>();
 
            //An event handler that will add the entity to our list if the entity has errors
            //  (we don't use an anonymous method so we can unsubscribe after the Merge)
            EventHandler<EntityChangingEventArgs> entityChanging
                = (sender, eventArgs) =>
                      {
                          if (eventArgs.EntityAspect.ValidationErrors.Any())
                              toValidate.Add((Entity) eventArgs.Entity);
                      };
 
            //Watch for entity changes (this will be fired before DevForce clears out the validation errors)
            em.EntityChanging += entityChanging;
 
            //Disable validation
            //HACK: This is only thread-safe on the client.  Need to revisit when executed on the server
            em.VerifierEngine.Enabled = false;
 
            //Perform the merge as usual
            var results = cacheState.Merge(em, restoreStrategy);
 
            //Re-enable validation
            em.VerifierEngine.Enabled = true;
 
            //We don't care about this event any longer
            em.EntityChanging -= entityChanging;
 
            //Go through all the entities that we need to validate and validate them
            foreach (var entity in toValidate)
                entity.EntityAspect.VerifierEngine.Execute(entity);
 
            return results;
        }