C# IEditableRoot.SetValueByPropertyName方法代码示例

        /// <summary>
        /// Gets the value.
        /// </summary>
        /// <param name="field">The field.</param>
        /// <param name="editableRoot">The editable root.</param>
        /// <returns></returns>
        public object GetValue(DetailsSaveFieldModel field, IEditableRoot editableRoot)
        {
            if (field.Settings == null)
                return null;

            var fileFieldOptions = field.Settings.ToObject<FileFieldOptions>();
            if (fileFieldOptions == null)
                return null;

            IFileProcess fileEdit = editableRoot.GetValueByPropertyName(field.SystemName);
            if (fileEdit == null)
                return null;

            fileEdit.FileName = fileFieldOptions.FileName;
            fileEdit.OriginalFileName = fileFieldOptions.OriginalFileName;

            if (!fileFieldOptions.Locked)
            {
                fileEdit.LockedDate = null;
            }
            else if (!fileEdit.Locked.HasValue || !fileEdit.Locked.Value)
            {
                fileEdit.LockedDate = DateTime.Now;
            }
            fileEdit.Locked = fileFieldOptions.Locked;
            fileEdit.LockedByAccountId = fileFieldOptions.LockedByAccountId;
            fileEdit.LockedByAccountName = fileFieldOptions.LockedByAccountName;

            if (fileFieldOptions.AuditLog != null)
            {
                fileEdit.FileChangeInfo = new AuditLogInfo
                {
                    LogType = fileFieldOptions.AuditLog.LogType,
                    ProcessName = fileFieldOptions.AuditLog.ProcessName,
                    ItemId = fileFieldOptions.AuditLog.ItemId,
                    FieldName = fileFieldOptions.AuditLog.FieldName,
                    OldValue = fileFieldOptions.AuditLog.OldValue,
                    NewValue = fileFieldOptions.AuditLog.NewValue,
                    DateUpdated = fileFieldOptions.AuditLog.DateUpdated,
                    User = fileFieldOptions.AuditLog.User
                };
            }

            var newModel = ((IBusinessBase)fileEdit).Save();

            if (fileFieldOptions.FileId == 0)
            {
                editableRoot.SetValueByPropertyName(string.Format("{0}Id", field.SystemName), ((IDynamicObject)newModel).Id);
            }

            return newModel;
        }

        /// <summary>
        /// Updates the specified source.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="destination">The destination.</param>
        public void Update(IDynamicObject source, IEditableRoot destination)
        {
            var filterList = new List<ColumnFilter>();

            foreach (var filterBuilder in _filterBuilders)
            {
                ColumnFilter filter;
                if (!filterBuilder.TryGetFilter(source, out filter))
                    return;
                filterList.Add(filter);
            }

            var itemIds = RuntimeDatabase.FindItems(_referencedProcess, filterList);
            if (itemIds.Count <= 0)
                return;

            if (_allowMultiple)
            {
                var crList = (ICrossRefItemList)destination.GetValueByPropertyName(_property.Name);

                if (crList == null)
                    return;

                foreach (var id in itemIds.Where(id => !crList.Contains(id)))
                {
                    crList.Assign(id);
                }
            }
            else
            {
                destination.SetValueByPropertyName(_property.Name, itemIds[0]);
            }
        }

        /// <summary>
        /// Updates the specified item.
        /// </summary>
        /// <param name="dataContext">
        /// The data context.
        /// </param>
        /// <param name="item">
        /// The destination item.
        /// </param>
        public void Update(IDataContext dataContext, IEditableRoot item)
        {
            if (item == null)
                throw new ArgumentNullException("item");

            try
            {
                var checklist = (ChecklistEdit)item.GetValueByPropertyName(FieldName);
                if (checklist == null || checklist.AnswerProcessList == null)
                {
                    checklist = CreateNewChecklist();
                    item.SetValueByPropertyName(FieldName, checklist);
                }

                if (ValueExpression != null)
                {
                    var items = ValueExpression(dataContext) as IEnumerable;

                    if (items != null)
                    {
                        var enumerator = items.GetEnumerator();

                        while (enumerator.MoveNext())
                        {
                            InsertOrUpdateChildren(dataContext, checklist);
                        }
                    }
                }
                else
                {
                    InsertOrUpdateChildren(dataContext, checklist);
                }
            }
            catch (Exception ex)
            {
                var message = new StringBuilder();
                message.AppendFormat(CultureInfo.InvariantCulture, "Could not update the field \"{0}\" in process \"{1}\".", DisplayName, item.ProcessDisplayName);

                throw new InvalidOperationException(message.ToString(), ex);
            }
        }

        /// <summary>
        /// Updates the field value.
        /// </summary>
        /// <param name="destination">
        /// The destination.
        /// </param>
        public void Update(IEditableRoot destination)
        {
            if (destination == null)
                throw new ArgumentNullException("destination");

            destination.SetValueByPropertyName(FieldName, NewValue);
        }

        /// <summary>
        /// Updates the specified source.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="destination">The destination.</param>
        /// <exception cref="System.ArgumentNullException">
        /// source
        /// or
        /// destination
        /// </exception>
        public void Update(IDynamicObject source, IEditableRoot destination)
        {
            if (source == null)
                throw new ArgumentNullException("source");

            if (destination == null)
                throw new ArgumentNullException("destination");

            if (IsLocalizable)
            {
                foreach (var localizationInfo in _property.DeclaringType.GetCustomAttributes<LocalizationInfoAttribute>())
                {
                    var cultureName = localizationInfo.CultureName;
                    var fieldName = LocalizationUtils.GetLocalizedFieldName(_property.Name, cultureName);

                    destination.SetValueByPropertyName(fieldName, GetValue(source, cultureName));
                }
            }
            else
            {
                destination.SetValueByPropertyName(_property.Name, GetValue(source, DefaultCultureName));
            }

            if (_property.Name == Constants.IdColumnName)
                destination.DisableIdGeneration = true;
        }

        private void ExecuteUnlink(IEditableRoot source, IEditableRoot destination)
        {
            var currentId = destination.GetValueByPropertyName(Property.Name) as int?;
            if (currentId == null)
                return;

            var item = GetSourceItem(CreateLinkedItemFilter(currentId.Value), CreateSourceDataFilter(source));
            if (item == null)
                return;

            var ancestor = item.GetAncestorByProcessName(ReferencedProcessName);
            if (ancestor == null || ancestor.Id != currentId)
                return;

            destination.SetValueByPropertyName(Property.Name, null);
        }

        private static void UpdateModelDefaultValues(IEditableRoot model)
        {
            using (new BypassPropertyCheckContext())
            {
                foreach (var prop in model.GetAllPropertiesByFieldType(ColumnTypes.SampleType))
                {
                    var value = model.GetValueByPropertyName(prop.Name);
                    if (string.IsNullOrWhiteSpace(value))
                    {
                        model.SetValueByPropertyName(prop.Name, SampleTypes.Number.ToString());
                    }
                }

                //ELMTSUP 2512
                //foreach (var prop in model.GetAllPropertiesByFieldType(ColumnTypes.SamplingTechnique))
                //{
                //    var value = model.GetValueByPropertyName(prop.Name);
                    //if (string.IsNullOrWhiteSpace(value))
                    //{
                    //    model.SetValueByPropertyName(prop.Name, SampleSizeTypes.Fixed.ToString());
                    //}
                //}
            }
        }

        private void ExecuteLink(IEditableRoot source, IEditableRoot destination)
        {
            var infoItem = GetSourceItem(CreateSourceDataFilter(source));
            if (infoItem == null)
                return;

            var ancestor = infoItem.GetAncestorByProcessName(ReferencedProcessName);
            if (ancestor == null)
                return;

            if (destination.GetValueByPropertyName(Property.Name) == ancestor.Id)
                return;

            destination.SetValueByPropertyName(Property.Name, ancestor.Id);

            if (FieldUpdaters.Count == 0)
                return;

            var criteria = new DetailCriteria(infoItem.Id) { AllowLazyLoading = true };
            var editItem = DynamicTypeManager.GetEditableRoot<IEditableRoot>(SourceDataProcessName, criteria);
            if (editItem == null || editItem.Id <= 0)
                return;

            var sourceData = new DataTriggerSourceData();
            sourceData.SourceItems[DataTriggerFieldMappingExpressionNames.SourceDataProcess] = editItem;

            UpdateFieldValues(sourceData, editItem);
            ((ISavable)editItem).Save();
        }

        private void UpdateInternal(IDataContext dataContext, IEditableRoot item)
        {
            try
            {
                if (ValueExpression != null)
                {
                    item.SetValueByPropertyName(Property.Name, TypeConverter.Convert<int?>(ValueExpression(dataContext)));
                }
                else
                {
                    var filters = new List<ColumnFilter>();

                    foreach (var fieldMapping in ChildMappings.Where(m => m.IsKey))
                    {
                        ColumnFilter filter;
                        if (!fieldMapping.TryCreateFilter(dataContext, out filter))
                            return;

                        filters.Add(filter);
                    }

                    var itemIds = RuntimeDatabase.FindItems(ReferencedProcessName, filters);
                    if (itemIds.Count > 0)
                    {
                        UpdateChild(dataContext, itemIds[0]);
                        item.SetValueByPropertyName(Property.Name, itemIds[0]);
                    }
                    else
                    {
                        var child = CreateChild(dataContext);
                        item.SetValueByPropertyName(Property.Name, child.Id);
                    }
                }
            }
            catch (Exception ex)
            {
                var message = new StringBuilder();
                message.AppendFormat(
                    CultureInfo.InvariantCulture,
                    "Could not update the field \"{0}\" in process \"{1}\".",
                    DisplayName,
                    item.ProcessDisplayName);

                throw new InvalidOperationException(message.ToString(), ex);
            }
        }

        /// <summary>
        /// Updates destination field.
        /// </summary>
        /// <param name="destination">The destination item.</param>
        public void Update(IEditableRoot destination)
        {
            if (destination == null)
                throw new ArgumentNullException("destination");

            if (FieldName == Constants.CurrentStateColumnName)
            {
                UpdateCurrentState(destination);
            }
            else
            {
                if (AllowLocalizedData)
                {
                    foreach (var localization in SupportedLocalizations)
                    {
                        var cultureName = localization.CultureName;
                        destination.SetValueByPropertyName(LocalizationUtils.GetLocalizedFieldName(FieldName, cultureName), GetValue(cultureName));
                    }
                }
                else
                {
                    destination.SetValueByPropertyName(FieldName, GetValue(DefaultCultureName));
                }
            }
        }

        /// <summary>
        /// Updates the specified item.
        /// </summary>
        /// <param name="dataContext">
        /// The data context.
        /// </param>
        /// <param name="item">
        /// The destination item.
        /// </param>
        public void Update(IDataContext dataContext, IEditableRoot item)
        {
            if (item == null)
                throw new ArgumentNullException("item");

            try
            {
                switch (Property.Name)
                {
                    case Constants.IdColumnName:
                        UpdateIdField(dataContext, item);
                        break;

                    case Constants.CurrentStateColumnName:
                        UpdateCurrentState(dataContext, item);
                        break;

                    default:
                        {
                            if (AllowLocalizedData)
                            {
                                foreach (var localization in SupportedLocalizations)
                                {
                                    object value;

                                    using (new CultureContext(localization.CultureName))
                                    {
                                        value = GetValue(dataContext);
                                        if (IsKey && value == null)
                                            throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "The key field \"{0}\" is null.", FieldName));
                                    }

                                    item.SetValueByPropertyName(LocalizationUtils.GetLocalizedFieldName(Property.Name, localization.CultureName), value);
                                }
                            }
                            else
                            {
                                var value = GetValue(dataContext);
                                if (IsKey && value == null)
                                    throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "The key field \"{0}\" is null.", FieldName));

                                item.SetValueByPropertyName(Property.Name, value);
                            }
                        }

                        break;
                }
            }
            catch (Exception ex)
            {
                var message = new StringBuilder();
                message.AppendFormat(
                    CultureInfo.InvariantCulture,
                    "Could not update the field \"{0}\" in process \"{1}\".",
                    DisplayName,
                    item.ProcessDisplayName);

                throw new InvalidOperationException(message.ToString(), ex);
            }
        }

        /// <summary>
        /// Copies the answer data.
        /// </summary>
        /// <param name="answerFieldValues">
        /// The answer field values.
        /// </param>
        /// <param name="answerItem">
        /// The answer item.
        /// </param>
        /// <exception cref="ArgumentNullException">
        /// The <paramref name="answerFieldValues"/> parameter is null.
        /// </exception>
        /// <exception cref="ArgumentNullException">
        /// The <paramref name="answerItem"/> parameter is null.
        /// </exception>
        public static void CopyAnswerData(ICollection<ChecklistAnswerFieldValue> answerFieldValues, IEditableRoot answerItem)
        {
            if (answerFieldValues == null)
                throw new ArgumentNullException("answerFieldValues");

            if (answerItem == null)
                throw new ArgumentNullException("answerItem");

            using (new ThreadLocalBypassPropertyCheckContext())
            {
                foreach (var fieldValue in answerFieldValues.Where(f => f.Value != null))
                {
                    var answerProperty = answerItem.GetPropertyByName(fieldValue.FieldName);
                    var answerValue = answerItem.GetValueByPropertyName(fieldValue.FieldName);

                    if (fieldValue.Value is ICrossRefItemList && answerValue is ICrossRefItemList)
                    {
                        var qList = (ICrossRefItemList)fieldValue.Value;
                        var aList = (ICrossRefItemList)answerValue;

                        aList.Clear();
                        foreach (var crItem in qList.Cast<ICrossRefItemInfo>())
                        {
#if !SILVERLIGHT
                            aList.Assign(crItem.Id);
#else
                            aList.Assign(crItem.Id, (o, e) => { });
#endif
                        }

                        continue;
                    }

                    if (answerProperty.PropertyType.IsInstanceOfType(fieldValue.Value))
                    {
                        answerItem.SetValueByPropertyName(fieldValue.FieldName, fieldValue.Value);
                    }
                    else
                    {
                        throw new VeyronException(
                            string.Format(
                                CultureInfo.InvariantCulture,
                                "Cannot assign value of type \"{0}\" to property \"{1}\".",
                                fieldValue.Value.GetType().AssemblyQualifiedName,
                                fieldValue.FieldName));
                    }
                }
            }
        }