C# INakedObjectAdapter.GetDomainObject方法代码示例

 public void Reset(INakedObjectAdapter inObjectAdapter) {
     try {
         var collection = (IList) property.GetValue(inObjectAdapter.GetDomainObject(), null);
         collection.Clear();
         property.SetValue(inObjectAdapter.GetDomainObject(), collection, null);
     }
     catch (Exception e) {
         throw new ReflectionException(string.Format("Failed to get/set property {0} in {1}", property.Name, inObjectAdapter.Spec.FullName), e);
     }
 }

 public void Reset(INakedObjectAdapter inObjectAdapter) {
     try {
         var collection = (IList) property.GetValue(inObjectAdapter.GetDomainObject(), null);
         collection.Clear();
         property.SetValue(inObjectAdapter.GetDomainObject(), collection, null);
     }
     catch (Exception e) {
         throw new ReflectionException(Log.LogAndReturn($"Failed to get/set property {property.Name} in {inObjectAdapter.Spec.FullName}"), e);
     }
 }

        public override string GetTitleWithMask(string mask, INakedObjectAdapter nakedObjectAdapter, INakedObjectManager nakedObjectManager) {
            if (maskDelegate != null) {
                return (string) maskDelegate(nakedObjectAdapter.GetDomainObject(), new object[] {mask});
            }

            if (maskMethod != null) {
                return (string) maskMethod.Invoke(nakedObjectAdapter.GetDomainObject(), new object[] {mask});
            }

            return GetTitle(nakedObjectAdapter, nakedObjectManager);
        }

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

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

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

        public void Invoke(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter[] parameters, bool queryOnly, IIdentifier identifier, ISession session, ILifecycleManager lifecycleManager) {
            IAuditor auditor = GetAuditor(nakedObjectAdapter, lifecycleManager);

            IPrincipal byPrincipal = session.Principal;
            string memberName = identifier.MemberName;
            if (nakedObjectAdapter.Spec is IServiceSpec) {
                string serviceName = nakedObjectAdapter.Spec.GetTitle(nakedObjectAdapter);
                auditor.ActionInvoked(byPrincipal, memberName, serviceName, queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray());
            }
            else {
                auditor.ActionInvoked(byPrincipal, memberName, nakedObjectAdapter.GetDomainObject(), queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray());
            }
        }

 public object[] GetChoices(INakedObjectAdapter inObjectAdapter, IDictionary<string, INakedObjectAdapter> parameterNameValues) {
     INakedObjectAdapter[] parms = FacetUtils.MatchParameters(parameterNames, parameterNameValues);
     try {
         object options = methodDelegate(inObjectAdapter.GetDomainObject(), parms.Select(p => p.GetDomainObject()).ToArray());
         var enumerable = options as IEnumerable;
         if (enumerable != null) {
             return enumerable.Cast<object>().ToArray();
         }
         throw new NakedObjectDomainException(Log.LogAndReturn($"Must return IEnumerable from choices method: {method.Name}"));
     }
     catch (ArgumentException ae) {
         throw new InvokeException(Log.LogAndReturn($"Choices exception: {method.Name} has mismatched (ie type of parameter does not match type of property) parameter types"), ae);
     }
 }