C# INakedObject.GetAsEnumerable方法代码示例

 private void MakeCollectionPersistent(INakedObject collection, IPersistedObjectAdder persistor) {
     if (collection.ResolveState.IsPersistent() || collection.Specification.Persistable == Persistable.TRANSIENT) {
         return;
     }
     Log.Info("persist " + collection);
     if (collection.ResolveState.IsTransient()) {
         collection.ResolveState.Handle(Events.StartResolvingEvent);
         collection.ResolveState.Handle(Events.EndResolvingEvent);
     }
     persistor.MadePersistent(collection);
     collection.GetAsEnumerable().ForEach(no => MakePersistent(no, persistor));
 }

        public virtual void MakePersistent(INakedObject nakedObject, IPersistedObjectAdder persistor) {
            if (nakedObject.Specification.IsCollection) {
                Log.Info("Persist " + nakedObject);

                nakedObject.GetAsEnumerable().ForEach(no => Persist(no, persistor));

                if (nakedObject.ResolveState.IsGhost()) {
                    nakedObject.ResolveState.Handle(Events.StartResolvingEvent);
                    nakedObject.ResolveState.Handle(Events.EndResolvingEvent);
                }
            }
            else {
                if (nakedObject.ResolveState.IsPersistent()) {
                    throw new NotPersistableException("can't make object persistent as it is already persistent: " + nakedObject);
                }
                if (nakedObject.Specification.Persistable == Persistable.TRANSIENT) {
                    throw new NotPersistableException("can't make object persistent as it is not persistable: " + nakedObject);
                }
                Persist(nakedObject, persistor);
            }
        }

        public virtual void AddInternalCollection(INakedObject collection, string fieldId, bool ensurePersistent) {
            InitCollection(fieldId);

            foreach (INakedObject element in collection.GetAsEnumerable()) {
                IOid elementOid = element.Oid;
                if (elementOid == null) {
                    throw new Exception("Element is not persistent " + element);
                }

                AddElement(fieldId, elementOid);
            }
        }

        internal INakedObject FilterCollection(INakedObject nakedObject, ObjectAndControlData controlData) {
            var form = controlData.Form;
            if (form != null && nakedObject != null && nakedObject.Specification.IsCollection && nakedObject.Oid is CollectionMemento) {
                nakedObject = Page(nakedObject, nakedObject.GetAsQueryable().Count(), controlData, false);
                var map = nakedObject.GetAsEnumerable().ToDictionary(FrameworkHelper.GetObjectId, y => y.Object);
                var selected = map.Where(kvp => form.Keys.Cast<string>().Contains(kvp.Key) && form[kvp.Key].Contains("true")).Select(kvp => kvp.Value).ToArray();
                return CloneAndPopulateCollection(nakedObject, selected, false);
            }

            return nakedObject;
        }

 internal void SetPagingValues(ObjectAndControlData controlData, INakedObject nakedObject) {
     if (nakedObject.Specification.IsCollection) {
         int sink1, sink2;
         CurrentlyPaging(controlData, nakedObject.GetAsEnumerable().Count(), out sink1, out sink2);
     }
 }

 private bool IsObjectCompleteAndSaved(INakedObject fieldTarget) {
     if (fieldTarget.Specification.IsCollection) {         
         if (fieldTarget.GetAsEnumerable().Any(no => !IsReferenceValidToPersist(no))) {
             ModelState.AddModelError("", MvcUi.CollectionIncomplete);
             return false;
         }
     }
     else {
         if (!IsReferenceValidToPersist(fieldTarget)) {
             ModelState.AddModelError("", MvcUi.ObjectIncomplete);
             return false;
         }
     }
  
     return true;
 }

        // Adds <code>nof:feature=&quot;collection&quot;</code> attribute, the
        // <code>nof:type=&quote;...&quot;</code> and the
        // <code>nof:size=&quote;...&quot;</code> for the supplied element.

        public static void SetNofCollection(XElement element,
                                            string prefix,
                                            string fullyQualifiedClassName,
                                            INakedObject collection) {
            SetAttribute(element, "feature", NofMetamodelFeatureCollection);
            SetAttribute(element, "type", prefix + ":" + fullyQualifiedClassName);
            SetAttribute(element, "size", "" + collection.GetAsEnumerable().Count());
        }

 private void SetResolveStateForDerivedCollections(INakedObject adapterFor) {
     bool isDerived = !IsPersisted;
     if (isDerived && !adapterFor.ResolveState.IsResolved()) {
         if (adapterFor.GetAsEnumerable().Any()) {
             adapterFor.ResolveState.Handle(Events.StartResolvingEvent);
             adapterFor.ResolveState.Handle(Events.EndResolvingEvent);
         }
     }
 }

 public TestCollection(INakedObject collection, ITestObjectFactory factory) {
     this.collection = collection;
     wrappedCollection = collection.GetAsEnumerable().Select(factory.CreateTestObject);
 }

        private static string CollectionTable(this HtmlHelper html,
                                              INakedObject collectionNakedObject,
                                              Func<INakedObject, string> linkFunc,
                                              Func<INakedObjectAssociation, bool> filter,
                                              Func<INakedObjectAssociation, int> order,
                                              bool isStandalone,
                                              bool withSelection,
                                              bool withTitle,
                                              bool defaultChecked = false) {
            var table = new TagBuilder("table");
            table.AddCssClass(CollectionItemTypeName(collectionNakedObject));
            table.InnerHtml += Environment.NewLine;

            string innerHtml = "";

            INakedObject[] collection = collectionNakedObject.GetAsEnumerable().ToArray();
            INakedObjectSpecification collectionSpec = collectionNakedObject.GetTypeOfFacetFromSpec().ValueSpec;
            INakedObjectAssociation[] collectionAssocs = CollectionAssociations(collection, collectionSpec, filter, order);

            int index = 0;
            foreach (INakedObject item in collection) {
                var row = new TagBuilder("tr");

                if (withSelection) {
                    var cbTag = new TagBuilder("td");
                    int i = index++;
                    string id = "checkbox" + i;
                    string label = GetLabelTag(true, (i + 1).ToString(CultureInfo.InvariantCulture), () => id);
                    cbTag.InnerHtml += (label + html.CheckBox(FrameworkHelper.GetObjectId(item), defaultChecked, new {id, @class = IdHelper.CheckboxClass}));
                    row.InnerHtml += cbTag.ToString();
                }

                if (withTitle) {
                    var itemTag = new TagBuilder("td");
                    itemTag.InnerHtml += linkFunc(item);
                    row.InnerHtml += itemTag.ToString();
                }

               string[] collectionValues = collectionAssocs.Select(a => html.GetViewField(new PropertyContext(item, a, false), a.Description, true, true)).ToArray();

                foreach (string s in collectionValues) {
                    row.InnerHtml += new TagBuilder("td") {InnerHtml = s};
                }
                innerHtml += (row + Environment.NewLine);
            }

            var headers = collectionAssocs.Select(a => a.Name).ToArray();
            html.AddHeader(headers, table, isStandalone, withSelection, withTitle, defaultChecked);
            table.InnerHtml += innerHtml;

            return table + html.AddFooter(collectionNakedObject);
        }