C# OpenXmlPart.IsInVersion方法代码示例

        /// <summary>
        /// Validate the specified part.
        /// </summary>
        /// <param name="part">The OpenXmlPart to be validated.</param>
        internal void ValidatePart(OpenXmlPart part)
        {
            // if the part is not defined in the specified version, then do not validate the content.
            if ( ! part.IsInVersion(this.ValidationSettings.FileFormat))
            {
                return;
            }

            /*******************
             * DOM traverse is not performance bottleneck.
             * Is this the good way that we separate the schema validtion and the semantics validation?
             *******************/

            try
            {
                // Must be called before the call to PartRootElement { get; }
                bool partRootElementLoaded = part.IsRootElementLoaded;

                // schema validation
                this.ValidationContext.Part = part;
                this.ValidationContext.Element = part.PartRootElement;

                var lastErrorCount = this.ValidationResult.Errors.Count;

                if (part.PartRootElement != null)
                {
                    this.SchemaValidator.Validate(this.ValidationContext);

                    this.ValidationContext.Element = part.PartRootElement;
                    this.SemanticValidator.ClearConstraintState(SemanticValidationLevel.PartOnly);
                    this.SemanticValidator.Validate(this.ValidationContext);
                }

                if (!partRootElementLoaded &&
                    this.ValidationResult.Errors.Count == lastErrorCount)
                {
                    // No new errors in this part. Release the DOM to GC memary.
                    part.SetPartRootElementToNull();
                }
            }
            catch (System.Xml.XmlException e)
            {
                ValidationErrorInfo errorInfo = new ValidationErrorInfo();
                errorInfo.ErrorType = ValidationErrorType.Schema;
                errorInfo.Id = "ExceptionError";
                errorInfo.Part = part;
                errorInfo.Path = new XmlPath(part);
                errorInfo.Description = string.Format(System.Globalization.CultureInfo.CurrentUICulture,
                    ValidationResources.ExceptionError, e.Message);
                this.ValidationResult.AddError(errorInfo);
            }
        }

        /// <summary>
        /// Validates the specified content in the OpenXmlPart.
        /// </summary>
        /// <param name="openXmlPart">The target OpenXmlPart.</param>
        /// <returns>A set of validation erros.</returns>
        /// <exception cref="ArgumentNullException">Thrown when the "openXmlPart" parameter is null.</exception>
        /// <exception cref="InvalidOperationException">Throw when the specified part is not a defined part in the specified FileFormat version.</exception>
        public IEnumerable<ValidationErrorInfo> Validate(OpenXmlPart openXmlPart)
        {
            if (openXmlPart == null)
            {
                throw new ArgumentNullException("openXmlPart");
            }

            var openXmlPackage = openXmlPart.OpenXmlPackage;
            if (openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.ProcessMode != MarkupCompatibilityProcessMode.NoProcess &&
                openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.TargetFileFormatVersions != this.FileFormat)
            {
                string exceptionMessage = string.Format(System.Globalization.CultureInfo.CurrentUICulture,
                    ExceptionMessages.DocumentFileFormatVersionMismatch,
                    openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.TargetFileFormatVersions, this.FileFormat);

                throw new InvalidOperationException(exceptionMessage);
            }

            if (!openXmlPart.IsInVersion(this.FileFormat))
            {
                if (openXmlPart is ExtendedPart)
                {
                    throw new InvalidOperationException(ExceptionMessages.PartNotInVersion);
                }
                else
                {
                    string strMessage;

                    // All Office 2007 and 2010 parts are allowed in Office 2013.

                    switch (this.FileFormat)
                    {
                        case FileFormatVersions.Office2007:
                            strMessage = ExceptionMessages.PartIsNotInOffice2007;
                            break;

                        case FileFormatVersions.Office2010:
                            strMessage = ExceptionMessages.PartIsNotInOffice2010;
                            break;

                        case FileFormatVersions.Office2013: // Falls through...
                        default:
                            strMessage = ExceptionMessages.PartIsNotInOffice2013;
                            break;
                    }

                    throw new InvalidOperationException(strMessage);
                }
            }

            // Do NOT use "yield return" in this method, as "yield return" are deferred executed.
            // Otherwise, the null check is not performed when the method is called, but rather, when the returned enumerator is moved for the first time. 
            // That means that the exception isn't thrown until possibly far, far away from the actual site of the error, which is potentially confusing.

            OpenXmlPackage package = openXmlPart.OpenXmlPackage;
            Debug.Assert(package != null);

            ValidationResult validationResult = null;
            switch (DocumentTypeDetector.GetDocumentType(package))
            {
                case OpenXmlDocumentType.Spreadsheet:
                    validationResult = this.SpreadsheetDocumentValidator.Validate(openXmlPart);
                    break;

                case OpenXmlDocumentType.Wordprocessing:
                    validationResult = this.WordprocessingDocumentValidator.Validate(openXmlPart);
                    break;

                case OpenXmlDocumentType.Presentation:
                    validationResult = this.PresentationDocumentValidator.Validate(openXmlPart);
                    break;

                default:
                    throw new System.IO.InvalidDataException(ExceptionMessages.UnknownPackage);
            }

            return this.YieldResult(validationResult);
        }