public object[] GetCompletions(INakedObjectAdapter inObjectAdapter, string autoCompleteParm) {
            try {
                object autoComplete = methodDelegate(inObjectAdapter.GetDomainObject(), new object[] { autoCompleteParm });

                //returning an IQueryable
                var queryable = autoComplete as IQueryable;
                if (queryable != null) {
                    return queryable.Take(PageSize).ToArray();
                }
                //returning an IEnumerable (of string only)
                var strings = autoComplete as IEnumerable<string>;
                if (strings != null) {
                    return strings.ToArray();
                }
                //return type is a single object
                if (!CollectionUtils.IsCollection(autoComplete.GetType())) {
                    return new object[] { autoComplete };
                }
                throw new NakedObjectDomainException("Must return IQueryable or a single object from autoComplete method: " + method.Name);
            }
            catch (ArgumentException ae) {
                string msg = string.Format("autoComplete exception: {0} has mismatched parameter type - must be string", method.Name);
                throw new InvokeException(msg, ae);
            }
        }

 public TestObject(ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectAdapter nakedObjectAdapter, ITestObjectFactory factory, ITransactionManager transactionManager)
     : base(factory) {
     this.lifecycleManager = lifecycleManager;
     this.persistor = persistor;
     this.transactionManager = transactionManager;
     NakedObject = nakedObjectAdapter;
 }

        private void Persist(INakedObjectAdapter nakedObjectAdapter) {
            if (nakedObjectAdapter.ResolveState.IsAggregated() || (nakedObjectAdapter.ResolveState.IsTransient() && nakedObjectAdapter.Spec.Persistable != PersistableType.Transient)) {
                IAssociationSpec[] fields = ((IObjectSpec) nakedObjectAdapter.Spec).Properties;
                if (!nakedObjectAdapter.Spec.IsEncodeable && fields.Length > 0) {
                    Log.Info("make persistent " + nakedObjectAdapter);
                    nakedObjectAdapter.Persisting();
                    if (!nakedObjectAdapter.Spec.ContainsFacet(typeof (IComplexTypeFacet))) {
                        manager.MadePersistent(nakedObjectAdapter);
                    }

                    foreach (IAssociationSpec field in fields) {
                        if (!field.IsPersisted) {
                            continue;
                        }
                        if (field is IOneToManyAssociationSpec) {
                            INakedObjectAdapter collection = field.GetNakedObject(nakedObjectAdapter);
                            if (collection == null) {
                                throw new NotPersistableException("Collection " + field.Name + " does not exist in " + nakedObjectAdapter.Spec.FullName);
                            }
                            MakePersistent(collection);
                        }
                        else {
                            INakedObjectAdapter fieldValue = field.GetNakedObject(nakedObjectAdapter);
                            if (fieldValue == null) {
                                continue;
                            }
                            Persist(fieldValue);
                        }
                    }
                    persistor.AddPersistedObject(nakedObjectAdapter);
                }
            }
        }

 public string HiddenReason(INakedObjectAdapter nakedObjectAdapter) {
     if (nakedObjectAdapter == null) {
         return null;
     }
     var isHidden = (bool) methodDelegate(nakedObjectAdapter.GetDomainObject(), new object[] {});
     return isHidden ? Resources.NakedObjects.Hidden : null;
 }

 public void ReplacePoco(INakedObjectAdapter nakedObjectAdapter, object newDomainObject) {
     Log.DebugFormat("ReplacePoco nakedObjectAdapter: {0} newDomainOject: {1}", nakedObjectAdapter, newDomainObject);
     RemoveAdapter(nakedObjectAdapter);
     identityMap.Replaced(nakedObjectAdapter.Object);
     nakedObjectAdapter.ReplacePoco(newDomainObject);
     identityMap.AddAdapter(nakedObjectAdapter);
 }

 public void MakePersistent(INakedObjectAdapter nakedObjectAdapter) {
     if (nakedObjectAdapter.Spec.IsCollection) {
         MakeCollectionPersistent(nakedObjectAdapter);
     }
     else {
         MakeObjectPersistent(nakedObjectAdapter);
     }
 }

 public void InitProperty(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter value) {
     try {
         property.SetValue(nakedObjectAdapter.GetDomainObject(), value.GetDomainObject(), null);
     }
     catch (TargetInvocationException e) {
         InvokeUtils.InvocationException("Exception executing " + property, e);
     }
 }

 public string InvalidReason(INakedObjectAdapter target, INakedObjectAdapter[] proposedArguments) {
     if (methodDelegate != null) {
         return (string)methodDelegate(target.GetDomainObject(), proposedArguments.Select(no => no.GetDomainObject()).ToArray());
     }
     //Fall back (e.g. if method has > 6 params) on reflection...
     Log.WarnFormat("Invoking validate method via reflection as no delegate {0}.{1}", target, method);
     return (string)InvokeUtils.Invoke(method, target, proposedArguments);
 }

 /// <summary>
 ///     Whether the provided argument exceeds the <see cref="SingleIntValueFacetAbstract.Value" /> maximum length}.
 /// </summary>
 public virtual bool Exceeds(INakedObjectAdapter nakedObjectAdapter) {
     var str = nakedObjectAdapter.GetDomainObject() as string;
     if (str == null) {
         return false;
     }
     int maxLength = Value;
     return maxLength != 0 && str.Length > maxLength;
 }

 public override void SetProperty(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter value, ITransactionManager transactionManager, ISession session, ILifecycleManager lifecycleManager) {
     try {
         property.SetValue(nakedObjectAdapter.GetDomainObject(), value.GetDomainObject(), null);
     }
     catch (TargetInvocationException e) {
         InvokeUtils.InvocationException("Exception executing " + property, e);
     }
 }

        public override bool IsEditView(INakedObjectAdapter nakedObjectAdapter) {
            var target = nakedObjectAdapter.GetDomainObject<IViewModelSwitchable>();

            if (target != null) {
                return target.IsEditView();
            }

            throw new NakedObjectSystemException(nakedObjectAdapter.Object == null ? "Null domain object" : "Wrong type of domain object: " + nakedObjectAdapter.Object.GetType().FullName);
        }

 public override void Invoke(INakedObjectAdapter nakedObjectAdapter, ISession session, ILifecycleManager lifecycleManager, IMetamodelManager metamodelManager) {
     profileManager.Begin(session, associatedEvent, "", nakedObjectAdapter, lifecycleManager);
     try {
         underlyingFacet.Invoke(nakedObjectAdapter, session, lifecycleManager, metamodelManager);
     }
     finally {
         profileManager.End(session, associatedEvent, "", nakedObjectAdapter, lifecycleManager);
     }
 }

 public void MakeObjectPersistent(INakedObjectAdapter nakedObjectAdapter) {
     if (nakedObjectAdapter.ResolveState.IsAggregated() ||
         nakedObjectAdapter.ResolveState.IsPersistent() ||
         nakedObjectAdapter.Spec.Persistable == PersistableType.Transient ||
         nakedObjectAdapter.Spec is IServiceSpec) {
         return;
     }
     persistor.AddPersistedObject(nakedObjectAdapter);
 }

        protected ObjectFacade(INakedObjectAdapter nakedObject, IFrameworkFacade frameworkFacade, INakedObjectsFramework framework) {
            FacadeUtils.AssertNotNull(nakedObject, "NakedObject is null");
            FacadeUtils.AssertNotNull(frameworkFacade, "FrameworkFacade is null");
            FacadeUtils.AssertNotNull(framework, "framework is null");

            WrappedNakedObject = nakedObject;
            this.framework = framework;
            FrameworkFacade = frameworkFacade;
        }

        public override void Init(INakedObjectAdapter collection, INakedObjectAdapter[] initData) {
            Array newCollection = Array.CreateInstance(collection.GetDomainObject().GetType().GetElementType(), initData.Length);
            collection.ReplacePoco(newCollection);

            int i = 0;
            foreach (INakedObjectAdapter nakedObject in initData) {
                AsCollection(collection)[i++] = nakedObject.Object;
            }
        }

 public object GetProperty(INakedObjectAdapter nakedObjectAdapter) {
     try {
         return propertyMethod.GetValue(nakedObjectAdapter.GetDomainObject(), null);
     }
     catch (TargetInvocationException e) {
         InvokeUtils.InvocationException("Exception executing " + propertyMethod, e);
         return null;
     }
 }

        public override void Init(INakedObjectAdapter collection, INakedObjectAdapter[] initData) {
            IList wrappedCollection = AsCollection(collection);

            List<object> toAdd = initData.Select(no => no.Object).Where(obj => !wrappedCollection.Contains(obj)).ToList();
            toAdd.ForEach(obj => wrappedCollection.Add(obj));

            List<object> toRemove = wrappedCollection.Cast<object>().Where(o => !initData.Select(x => x.Object).Contains(o)).ToList();
            toRemove.ForEach(wrappedCollection.Remove);
        }

 public override INakedObjectAdapter Invoke(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter[] parameters, int resultPage, ILifecycleManager lifecycleManager, IMetamodelManager manager, ISession session, INakedObjectManager nakedObjectManager, IMessageBroker messageBroker, ITransactionManager transactionManager) {
     profileManager.Begin(session, ProfileEvent.ActionInvocation, identifier.MemberName, nakedObjectAdapter, lifecycleManager);
     try {
         return underlyingFacet.Invoke(nakedObjectAdapter, parameters, resultPage, lifecycleManager, manager, session, nakedObjectManager, messageBroker, transactionManager);
     }
     finally {
         profileManager.End(session, ProfileEvent.ActionInvocation, identifier.MemberName, nakedObjectAdapter, lifecycleManager);
     }
 }

 private IEnumerable PageInternal(int page, int size, INakedObjectAdapter collection, INakedObjectManager manager) {
     int firstIndex = (page - 1)*size;
     for (int index = firstIndex; index < firstIndex + size; index++) {
         if (index >= AsEnumerable(collection, manager).Count()) {
             yield break;
         }
         yield return AsCollection(collection)[index];
     }
 }

        public bool IsEditable(ISession session, ILifecycleManager lifecycleManager, INakedObjectAdapter target, IIdentifier identifier) {
            object authorizer = GetAuthorizer(target, lifecycleManager);
            Type authType = authorizer.GetType();

            if ((typeof(INamespaceAuthorizer)).IsAssignableFrom(authType)) {
                var nameAuth = (INamespaceAuthorizer) authorizer;
                return nameAuth.IsEditable(session.Principal, target.Object, identifier.MemberName);
            }
            return isEditableDelegates[authType](authorizer, session.Principal, target.GetDomainObject(), identifier.MemberName);
        }