public static bool TryParseDublinCoreExtension(XElement parentElement, out DublinCoreExtension extension)
        {
            extension = null;

            if (parentElement == null)
            {
                return(false);
            }

            foreach (var ns in DublinCoreExtensionConstants.RecognizedNamespaces)
            {
                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "title"), out var parsedTitle))
                {
                    extension       = extension ?? new DublinCoreExtension();
                    extension.Title = parsedTitle;
                }

                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "creator"), out var parsedCreator))
                {
                    extension         = extension ?? new DublinCoreExtension();
                    extension.Creator = parsedCreator;
                }

                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "subject"), out var parsedSubject))
                {
                    extension         = extension ?? new DublinCoreExtension();
                    extension.Subject = parsedSubject;
                }

                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "description"), out var parsedDescription))
                {
                    extension             = extension ?? new DublinCoreExtension();
                    extension.Description = parsedDescription;
                }

                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "publisher"), out var parsedPublisher))
                {
                    extension           = extension ?? new DublinCoreExtension();
                    extension.Publisher = parsedPublisher;
                }

                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "contributor"), out var parsedContributor))
                {
                    extension             = extension ?? new DublinCoreExtension();
                    extension.Contributor = parsedContributor;
                }

                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "type"), out var parsedType))
                {
                    extension      = extension ?? new DublinCoreExtension();
                    extension.Type = parsedType;
                }

                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "format"), out var parsedFormat))
                {
                    extension        = extension ?? new DublinCoreExtension();
                    extension.Format = parsedFormat;
                }

                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "identifier"), out var parsedIdentifier))
                {
                    extension            = extension ?? new DublinCoreExtension();
                    extension.Identifier = parsedIdentifier;
                }

                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "source"), out var parsedSource))
                {
                    extension        = extension ?? new DublinCoreExtension();
                    extension.Source = parsedSource;
                }

                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "language"), out var parsedLanguage))
                {
                    extension          = extension ?? new DublinCoreExtension();
                    extension.Language = parsedLanguage;
                }

                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "relation"), out var parsedRelation))
                {
                    extension          = extension ?? new DublinCoreExtension();
                    extension.Relation = parsedRelation;
                }

                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "coverage"), out var parsedCoverage))
                {
                    extension          = extension ?? new DublinCoreExtension();
                    extension.Coverage = parsedCoverage;
                }

                if (TryParseDublinCoreTextElement(parentElement.Element(ns + "rights"), out var parsedRights))
                {
                    extension        = extension ?? new DublinCoreExtension();
                    extension.Rights = parsedRights;
                }

                if (TryParseDublinCoreTimestamp(parentElement.Element(ns + "date"), out var parsedDate))
                {
                    extension      = extension ?? new DublinCoreExtension();
                    extension.Date = parsedDate;
                }

                if (TryParseDublinCoreTimestamp(parentElement.Element(ns + "modified"), out var parsedModified))
                {
                    extension          = extension ?? new DublinCoreExtension();
                    extension.Modified = parsedModified;
                }
            }

            return(extension != null);
        }
        public static bool TryFormatDublinCoreExtension(DublinCoreExtension extensionToFormat, XNamespaceAliasSet namespaceAliases, out IList <XElement> elements)
        {
            elements = default;

            if (extensionToFormat == null)
            {
                return(false);
            }

            elements = new List <XElement>();

            if (TryFormatDublinCoreTextElement(extensionToFormat.Title, "title", namespaceAliases, out var titleElement))
            {
                elements.Add(titleElement);
            }

            if (TryFormatDublinCoreTextElement(extensionToFormat.Creator, "creator", namespaceAliases, out var creatorElement))
            {
                elements.Add(creatorElement);
            }

            if (TryFormatDublinCoreTextElement(extensionToFormat.Subject, "subject", namespaceAliases, out var subjectElement))
            {
                elements.Add(subjectElement);
            }

            if (TryFormatDublinCoreTextElement(extensionToFormat.Description, "description", namespaceAliases, out var descriptionElement))
            {
                elements.Add(descriptionElement);
            }

            if (TryFormatDublinCoreTextElement(extensionToFormat.Publisher, "publisher", namespaceAliases, out var publisherElement))
            {
                elements.Add(publisherElement);
            }

            if (TryFormatDublinCoreTextElement(extensionToFormat.Contributor, "contributor", namespaceAliases, out var contributorElement))
            {
                elements.Add(contributorElement);
            }

            if (TryFormatDublinCoreTextElement(extensionToFormat.Type, "type", namespaceAliases, out var typeElement))
            {
                elements.Add(typeElement);
            }

            if (TryFormatDublinCoreTextElement(extensionToFormat.Format, "format", namespaceAliases, out var formatElement))
            {
                elements.Add(formatElement);
            }

            if (TryFormatDublinCoreTextElement(extensionToFormat.Identifier, "identifier", namespaceAliases, out var identifierElement))
            {
                elements.Add(identifierElement);
            }

            if (TryFormatDublinCoreTextElement(extensionToFormat.Source, "source", namespaceAliases, out var sourceElement))
            {
                elements.Add(sourceElement);
            }

            if (TryFormatDublinCoreTextElement(extensionToFormat.Language, "language", namespaceAliases, out var languageElement))
            {
                elements.Add(languageElement);
            }

            if (TryFormatDublinCoreTextElement(extensionToFormat.Relation, "relation", namespaceAliases, out var relationElement))
            {
                elements.Add(relationElement);
            }

            if (TryFormatDublinCoreTextElement(extensionToFormat.Coverage, "coverage", namespaceAliases, out var coverageElement))
            {
                elements.Add(coverageElement);
            }

            if (TryFormatDublinCoreTextElement(extensionToFormat.Rights, "rights", namespaceAliases, out var rightsElement))
            {
                elements.Add(rightsElement);
            }

            if (TryFormatDublinCoreTimestamp(extensionToFormat.Date, "date", namespaceAliases, out var dateElement))
            {
                elements.Add(dateElement);
            }

            if (TryFormatDublinCoreTimestamp(extensionToFormat.Modified, "modified", namespaceAliases, out var modifiedElement))
            {
                elements.Add(modifiedElement);
            }

            if (!elements.Any())
            {
                return(false);
            }

            return(true);
        }