C# INakedObjectAdapter类代码示例

        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;
            }
        }