C# INakedObject.TitleString方法代码示例

 public static string PropertyTitle(this INakedObjectFeature feature, INakedObject nakedObject) {
     if (nakedObject == null) {
         return "";
     }
     string text = null;
     var regex = feature.GetFacet<IRegExFacet>();
     if (regex != null) {
         text = regex.Format(nakedObject.TitleString());
     }
     var mask = feature.GetFacet<IMaskFacet>();
     if (mask != null) {
         var title = feature.Specification.GetFacet<ITitleFacet>();
         text = title.GetTitleWithMask(mask.Value, nakedObject);
     }
     if (text == null) {
         text = nakedObject.TitleString();
     }
     return text;
 }

        public Place ObjectToElement(INakedObject nakedObject) {
            Log.Debug("objectToElement(" + DoLog("object", nakedObject) + ")");

            INakedObjectSpecification nos = nakedObject.Specification;

            Log.Debug("objectToElement(NO): create element and nof:title");
            XElement element = Schema.CreateElement(XmlDocument, nos.ShortName, nos.FullName, nos.SingularName, nos.PluralName);
            NofMetaModel.AppendNofTitle(element, nakedObject.TitleString());

            Log.Debug("objectToElement(NO): create XS element for NOF class");
            XElement xsElement = Schema.CreateXsElementForNofClass(XsdDocument, element, topLevelElementWritten);

            // hack: every element in the XSD schema apart from first needs minimum cardinality setting.
            topLevelElementWritten = true;

            var place = new Place(nakedObject, element);

            NofMetaModel.SetAttributesForClass(element, OidOrHashCode(nakedObject));

            INakedObjectAssociation[] fields = nos.Properties;
            Log.Debug("objectToElement(NO): processing fields");

            var seenFields = new List<string>();

            foreach (INakedObjectAssociation field in fields) {
                string fieldName = field.Id;

                Log.Debug("objectToElement(NO): " + DoLog("field", fieldName));

                // Skip field if we have seen the name already
                // This is a workaround for getLastActivity(). This method exists
                // in AbstractNakedObject, but is not (at some level) being picked up
                // by the dot-net reflector as a property. On the other hand it does
                // exist as a field in the meta model (NakedObjectSpecification).
                //
                // Now, to re-expose the lastactivity field for .Net, a deriveLastActivity()
                // has been added to BusinessObject. This caused another field ofthe
                // same name, ultimately breaking the XSD.

                if (seenFields.Contains(fieldName)) {
                    Log.Debug("objectToElement(NO): " + DoLog("field", fieldName) + " SKIPPED");
                    continue;
                }
                seenFields.Add(fieldName);

                XNamespace ns = Schema.GetUri();

                var xmlFieldElement = new XElement(ns + fieldName);

                XElement xsdFieldElement;

                if (field.Specification.IsParseable) {
                    Log.Debug("objectToElement(NO): " + DoLog("field", fieldName) + " is value");

                    INakedObjectSpecification fieldNos = field.Specification;
                    // skip fields of type XmlValue
                    if (fieldNos != null &&
                        fieldNos.FullName != null &&
                        fieldNos.FullName.EndsWith("XmlValue")) {
                        continue;
                    }

                    var oneToOneAssociation = ((IOneToOneAssociation) field);
                    XElement xmlValueElement = xmlFieldElement; // more meaningful locally scoped name

                    try {
                        INakedObject value = oneToOneAssociation.GetNakedObject(nakedObject);

                        // a null value would be a programming error, but we protect
                        // against it anyway
                        if (value == null) {
                            continue;
                        }

                        INakedObjectSpecification valueNos = value.Specification;

                        // XML
                        NofMetaModel.SetAttributesForValue(xmlValueElement, valueNos.ShortName);

                        bool notEmpty = (value.TitleString().Length > 0);
                        if (notEmpty) {
                            string valueStr = value.TitleString();
                            xmlValueElement.Add(new XText(valueStr));
                        }
                        else {
                            NofMetaModel.SetIsEmptyAttribute(xmlValueElement, true);
                        }
                    }
                    catch (Exception) {
                        Log.Warn("objectToElement(NO): " + DoLog("field", fieldName) + ": getField() threw exception - skipping XML generation");
                    }

                    // XSD
                    xsdFieldElement = Schema.CreateXsElementForNofValue(xsElement, xmlValueElement);
                }
                else if (field is IOneToOneAssociation) {
                    Log.Debug("objectToElement(NO): " + DoLog("field", fieldName) + " is IOneToOneAssociation");

                    var oneToOneAssociation = ((IOneToOneAssociation) field);

//.........这里部分代码省略.........

 private static string DoLog(string label, INakedObject nakedObject) {
     return DoLog(label, (nakedObject == null ? "(null)" : nakedObject.TitleString() + "[" + OidOrHashCode(nakedObject) + "]"));
 }

 private object GetCompletionData(INakedObject nakedObject, INakedObjectSpecification spec) {
     string label = nakedObject.TitleString();
     string value = nakedObject.TitleString();
     string link = spec.IsParseable ? label : FrameworkHelper.GetObjectId(nakedObject);
     string src = GetIconSrc(nakedObject);
     string alt = GetIconAlt(nakedObject);
     return new {label, value, link, src, alt};
 }

 public DataUpdateException(INakedObject nakedObject, IVersion updated)
     : this(string.Format(Resources.NakedObjects.DataUpdateMessage, nakedObject.Version.User, nakedObject.TitleString(), DateTime.Now.ToLongTimeString(), Environment.NewLine, Environment.NewLine, nakedObject.Version, updated), nakedObject.Oid) {}

 public static string GetServiceLabel(INakedObject nakedObject) {
     return nakedObject.TitleString();
 }

 public static void CheckCanAssociate(this IResolveStateMachine stateMachine, INakedObject associate) {
     if (stateMachine.IsPersistent() && associate != null && associate.ResolveState.IsTransient()) {
         throw new TransientReferenceException(string.Format(Resources.NakedObjects.TransientErrorMessage, associate.TitleString()));
     }
 }

 private static string GetDisplayTitle(IFacetHolder holder, INakedObject nakedObject) {
     var mask = holder.GetFacet<IMaskFacet>();
     string title = mask != null ? nakedObject.Specification.GetFacet<ITitleFacet>().GetTitleWithMask(mask.Value, nakedObject) : nakedObject.TitleString();
     return string.IsNullOrWhiteSpace(title) && !nakedObject.Specification.IsParseable ? nakedObject.Specification.UntitledName : title;
 }

 private static string GetMaskedValue(INakedObject valueNakedObject, IMaskFacet mask) {
     if (valueNakedObject != null) {
         return mask != null ? valueNakedObject.Specification.GetFacet<ITitleFacet>().GetTitleWithMask(mask.Value, valueNakedObject) : valueNakedObject.TitleString();
     }
     return null;
 }

        private static bool GetSelectedForChoice(INakedObject choice, INakedObject existingNakedObject) {
            IEnumerable<INakedObject> existingNakedObjects;

            if (existingNakedObject == null) {
                existingNakedObjects = new INakedObject[] {};
            }
            else if (existingNakedObject.Specification.IsParseable || !existingNakedObject.Specification.IsCollection) {
                // isParseable to catch strings 
                existingNakedObjects = new[] {existingNakedObject};
            }
            else {
                existingNakedObjects = existingNakedObject.GetCollectionFacetFromSpec().AsEnumerable(existingNakedObject);
            }

            var enumFacet = choice.Specification.GetFacet<IEnumValueFacet>();

            if (enumFacet != null) {
                return existingNakedObjects.Any(no =>  no != null && enumFacet.IntegralValue(choice) == enumFacet.IntegralValue(no));
            }

            if (choice.Specification.IsParseable) {
                return existingNakedObjects.Any(no => choice.TitleString() == no.TitleString());
            }
            return existingNakedObjects.Any(no => choice == no);
        }

        private static string GetTextForChoice(INakedObject choice) {
            var enumFacet = choice.Specification.GetFacet<IEnumValueFacet>();

            if (enumFacet != null) {
                choice.TitleString();
            }

            return choice.TitleString();
        }

        private static string GetValueForChoice(INakedObject choice) {
            var enumFacet = choice.Specification.GetFacet<IEnumValueFacet>();

            if (enumFacet != null) {
                return enumFacet.IntegralValue(choice);
            }
            if (choice.Specification.IsParseable) {
                return choice.TitleString();
            }
            return FrameworkHelper.GetObjectId(choice);
        }