WPF 读取Docx文件并显示(附下载链接)

最新推荐文章于 2023-05-06 09:36:58 发布
最新推荐文章于 2023-05-06 09:36:58 发布
阅读量697 收藏
点赞数
文章标签： wordpress dom gwt stream wpf

在wpf中直接显示Docx文件 ，直接看看效果吧：

下面直接看代码，添加主要有两个类：

DocxReader类：

using System;
using System.IO;
using System.IO.Packaging;
using System.Xml;


namespace WpfEmbeddedDocx
{
    class DocxReader : IDisposable
    {
        protected const string
            MainDocumentRelationshipType =
                "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",


            // XML namespaces
            WordprocessingMLNamespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
            RelationshipsNamespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships",


            // Miscellaneous elements
            DocumentElement = "document",
            BodyElement = "body",


            // Block-Level elements
            ParagraphElement = "p",
            TableElement = "tbl",


            // Inline-Level elements
            SimpleFieldElement = "fldSimple",
            HyperlinkElement = "hyperlink",
            RunElement = "r",


            // Run content elements
            BreakElement = "br",
            TabCharacterElement = "tab",
            TextElement = "t",


            // Table elements
            TableRowElement = "tr",
            TableCellElement = "tc",


            // Properties elements
            ParagraphPropertiesElement = "pPr",
            RunPropertiesElement = "rPr";
        // Note: new members should also be added to nameTable in CreateNameTable method.


        protected virtual XmlNameTable CreateNameTable()
        {
            var nameTable = new NameTable();


            nameTable.Add(WordprocessingMLNamespace);
            nameTable.Add(RelationshipsNamespace);
            nameTable.Add(DocumentElement);
            nameTable.Add(BodyElement);
            nameTable.Add(ParagraphElement);
            nameTable.Add(TableElement);
            nameTable.Add(ParagraphPropertiesElement);
            nameTable.Add(SimpleFieldElement);
            nameTable.Add(HyperlinkElement);
            nameTable.Add(RunElement);
            nameTable.Add(BreakElement);
            nameTable.Add(TabCharacterElement);
            nameTable.Add(TextElement);
            nameTable.Add(RunPropertiesElement);
            nameTable.Add(TableRowElement);
            nameTable.Add(TableCellElement);


            return nameTable;
        }


        private readonly Package package;
        private readonly PackagePart mainDocumentPart;


        protected PackagePart MainDocumentPart
        {
            get { return this.mainDocumentPart; }
        }


        public DocxReader(Stream stream)
        {
            if (stream == null)
                throw new ArgumentNullException("stream");


            this.package = Package.Open(stream, FileMode.Open, FileAccess.Read);


            foreach (var relationship in this.package.GetRelationshipsByType(MainDocumentRelationshipType))
            {
                this.mainDocumentPart = package.GetPart(PackUriHelper.CreatePartUri(relationship.TargetUri));
                break;
            }
        }


        public void Read()
        {
            using (var mainDocumentStream = this.mainDocumentPart.GetStream(FileMode.Open, FileAccess.Read))
            using (var reader = XmlReader.Create(mainDocumentStream, new XmlReaderSettings()
            {
                NameTable = this.CreateNameTable(),
                IgnoreComments = true,
                IgnoreProcessingInstructions = true,
                IgnoreWhitespace = true
            }))
                this.ReadMainDocument(reader);
        }


        private static void ReadXmlSubtree(XmlReader reader, Action<XmlReader> action)
        {
            using (var subtreeReader = reader.ReadSubtree())
            {
                // Position on the first node.
                subtreeReader.Read();


                if (action != null)
                    action(subtreeReader);
            }
        }


        private void ReadMainDocument(XmlReader reader)
        {
            while (reader.Read())
                if (reader.NodeType == XmlNodeType.Element && reader.NamespaceURI == WordprocessingMLNamespace &&
                    reader.LocalName == DocumentElement)
                {
                    ReadXmlSubtree(reader, this.ReadDocument);
                    break;
                }
        }


        protected virtual void ReadDocument(XmlReader reader)
        {
            while (reader.Read())
                if (reader.NodeType == XmlNodeType.Element && reader.NamespaceURI == WordprocessingMLNamespace &&
                    reader.LocalName == BodyElement)
                {
                    ReadXmlSubtree(reader, this.ReadBody);
                    break;
                }
        }


        private void ReadBody(XmlReader reader)
        {
            while (reader.Read())
                this.ReadBlockLevelElement(reader);
        }


        private void ReadBlockLevelElement(XmlReader reader)
        {
            if (reader.NodeType == XmlNodeType.Element)
            {
                Action<XmlReader> action = null;


                if (reader.NamespaceURI == WordprocessingMLNamespace)
                    switch (reader.LocalName)
                    {
                        case ParagraphElement:
                            action = this.ReadParagraph;
                            break;


                        case TableElement:
                            action = this.ReadTable;
                            break;
                    }


                ReadXmlSubtree(reader, action);
            }
        }


        protected virtual void ReadParagraph(XmlReader reader)
        {
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element && reader.NamespaceURI == WordprocessingMLNamespace &&
                    reader.LocalName == ParagraphPropertiesElement)
                    ReadXmlSubtree(reader, this.ReadParagraphProperties);
                else
                    this.ReadInlineLevelElement(reader);
            }
        }


        protected virtual void ReadParagraphProperties(XmlReader reader)
        {
        }


        private void ReadInlineLevelElement(XmlReader reader)
        {
            if (reader.NodeType == XmlNodeType.Element)
            {
                Action<XmlReader> action = null;


                if (reader.NamespaceURI == WordprocessingMLNamespace)
                    switch (reader.LocalName)
                    {
                        case SimpleFieldElement:
                            action = this.ReadSimpleField;
                            break;


                        case HyperlinkElement:
                            action = this.ReadHyperlink;
                            break;


                        case RunElement:
                            action = this.ReadRun;
                            break;
                    }


                ReadXmlSubtree(reader, action);
            }
        }


        private void ReadSimpleField(XmlReader reader)
        {
            while (reader.Read())
                this.ReadInlineLevelElement(reader);
        }


        protected virtual void ReadHyperlink(XmlReader reader)
        {
            while (reader.Read())
                this.ReadInlineLevelElement(reader);
        }


        protected virtual void ReadRun(XmlReader reader)
        {
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element && reader.NamespaceURI == WordprocessingMLNamespace &&
                    reader.LocalName == RunPropertiesElement)
                    ReadXmlSubtree(reader, this.ReadRunProperties);
                else
                    this.ReadRunContentElement(reader);
            }
        }


        protected virtual void ReadRunProperties(XmlReader reader)
        {
        }


        private void ReadRunContentElement(XmlReader reader)
        {
            if (reader.NodeType == XmlNodeType.Element)
            {
                Action<XmlReader> action = null;


                if (reader.NamespaceURI == WordprocessingMLNamespace)
                    switch (reader.LocalName)
                    {
                        case BreakElement:
                            action = this.ReadBreak;
                            break;


                        case TabCharacterElement:
                            action = this.ReadTabCharacter;
                            break;


                        case TextElement:
                            action = this.ReadText;
                            break;
                    }


                ReadXmlSubtree(reader, action);
            }
        }


        protected virtual void ReadBreak(XmlReader reader)
        {
        }


        protected virtual void ReadTabCharacter(XmlReader reader)
        {
        }


        protected virtual void ReadText(XmlReader reader)
        {
        }


        protected virtual void ReadTable(XmlReader reader)
        {
            while (reader.Read())
                if (reader.NodeType == XmlNodeType.Element && reader.NamespaceURI == WordprocessingMLNamespace &&
                    reader.LocalName == TableRowElement)
                    ReadXmlSubtree(reader, this.ReadTableRow);
        }


        protected virtual void ReadTableRow(XmlReader reader)
        {
            while (reader.Read())
                if (reader.NodeType == XmlNodeType.Element && reader.NamespaceURI == WordprocessingMLNamespace &&
                    reader.LocalName == TableCellElement)
                    ReadXmlSubtree(reader, this.ReadTableCell);
        }


        protected virtual void ReadTableCell(XmlReader reader)
        {
            while (reader.Read())
                this.ReadBlockLevelElement(reader);
        }


        public void Dispose()
        {
            this.package.Close();
        }
    }
}

DocxToFlowDocumentConverter类：

using System;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Packaging;
using System.Windows;
using System.Windows.Documents;
using System.Windows.Markup;
using System.Windows.Media;
using System.Windows.Navigation;
using System.Xml;


namespace WpfEmbeddedDocx
{
    class DocxToFlowDocumentConverter : DocxReader
    {
        private const string


            // Run properties elements
            BoldElement = "b",
            ItalicElement = "i",
            UnderlineElement = "u",
            StrikeElement = "strike",
            DoubleStrikeElement = "dstrike",
            VerticalAlignmentElement = "vertAlign",
            ColorElement = "color",
            HighlightElement = "highlight",
            FontElement = "rFonts",
            FontSizeElement = "sz",
            RightToLeftTextElement = "rtl",


            // Paragraph properties elements
            AlignmentElement = "jc",
            PageBreakBeforeElement = "pageBreakBefore",
            SpacingElement = "spacing",
            IndentationElement = "ind",
            ShadingElement = "shd",


            // Attributes
            IdAttribute = "id",
            ValueAttribute = "val",
            ColorAttribute = "color",
            AsciiFontFamily = "ascii",
            SpacingAfterAttribute = "after",
            SpacingBeforeAttribute = "before",
            LeftIndentationAttribute = "left",
            RightIndentationAttribute = "right",
            HangingIndentationAttribute = "hanging",
            FirstLineIndentationAttribute = "firstLine",
            FillAttribute = "fill";


        private FlowDocument document;
        private TextElement current;
        private bool hasAnyHyperlink;


        public FlowDocument Document
        {
            get { return this.document; }
        }


        public DocxToFlowDocumentConverter(Stream stream)
            : base(stream)
        {
        }


        protected override XmlNameTable CreateNameTable()
        {
            var nameTable = base.CreateNameTable();


            nameTable.Add(BoldElement);
            nameTable.Add(ItalicElement);
            nameTable.Add(UnderlineElement);
            nameTable.Add(StrikeElement);
            nameTable.Add(DoubleStrikeElement);
            nameTable.Add(VerticalAlignmentElement);
            nameTable.Add(ColorElement);
            nameTable.Add(HighlightElement);
            nameTable.Add(FontElement);
            nameTable.Add(FontSizeElement);
            nameTable.Add(RightToLeftTextElement);
            nameTable.Add(AlignmentElement);
            nameTable.Add(PageBreakBeforeElement);
            nameTable.Add(SpacingElement);
            nameTable.Add(IndentationElement);
            nameTable.Add(ShadingElement);
            nameTable.Add(IdAttribute);
            nameTable.Add(ValueAttribute);
            nameTable.Add(ColorAttribute);
            nameTable.Add(AsciiFontFamily);
            nameTable.Add(SpacingAfterAttribute);
            nameTable.Add(SpacingBeforeAttribute);
            nameTable.Add(LeftIndentationAttribute);
            nameTable.Add(RightIndentationAttribute);
            nameTable.Add(HangingIndentationAttribute);
            nameTable.Add(FirstLineIndentationAttribute);
            nameTable.Add(FillAttribute);


            return nameTable;
        }


        protected override void ReadDocument(XmlReader reader)
        {
            this.document = new FlowDocument();
            this.document.BeginInit();
            this.document.ColumnWidth = double.NaN;


            base.ReadDocument(reader);


            if (this.hasAnyHyperlink)
                this.document.AddHandler(Hyperlink.RequestNavigateEvent,
                    new RequestNavigateEventHandler((sender, e) => Process.Start(e.Uri.ToString())));


            this.document.EndInit();
        }


        protected override void ReadParagraph(XmlReader reader)
        {
            using (this.SetCurrent(new Paragraph()))
                base.ReadParagraph(reader);
        }


        protected override void ReadTable(XmlReader reader)
        {
            // Skip table for now.
        }


        protected override void ReadParagraphProperties(XmlReader reader)
        {
            while (reader.Read())
                if (reader.NodeType == XmlNodeType.Element && reader.NamespaceURI == WordprocessingMLNamespace)
                {
                    var paragraph = (Paragraph)this.current;
                    switch (reader.LocalName)
                    {
                        case AlignmentElement:
                            var textAlignment = ConvertTextAlignment(GetValueAttribute(reader));
                            if (textAlignment.HasValue)
                                paragraph.TextAlignment = textAlignment.Value;
                            break;
                        case PageBreakBeforeElement:
                            paragraph.BreakPageBefore = GetOnOffValueAttribute(reader);
                            break;
                        case SpacingElement:
                            paragraph.Margin = GetSpacing(reader, paragraph.Margin);
                            break;
                        case IndentationElement:
                            SetParagraphIndent(reader, paragraph);
                            break;
                        case ShadingElement:
                            var background = GetShading(reader);
                            if (background != null)
                                paragraph.Background = background;
                            break;
                    }
                }
        }


        protected override void ReadHyperlink(XmlReader reader)
        {
            var id = reader[IdAttribute, RelationshipsNamespace];
            if (!string.IsNullOrEmpty(id))
            {
                var relationship = this.MainDocumentPart.GetRelationship(id);
                if (relationship.TargetMode == TargetMode.External)
                {
                    this.hasAnyHyperlink = true;


                    var hyperlink = new Hyperlink()
                    {
                        NavigateUri = relationship.TargetUri
                    };


                    using (this.SetCurrent(hyperlink))
                        base.ReadHyperlink(reader);
                    return;
                }
            }


            base.ReadHyperlink(reader);
        }


        protected override void ReadRun(XmlReader reader)
        {
            using (this.SetCurrent(new Span()))
                base.ReadRun(reader);
        }


        protected override void ReadRunProperties(XmlReader reader)
        {
            while (reader.Read())
                if (reader.NodeType == XmlNodeType.Element && reader.NamespaceURI == WordprocessingMLNamespace)
                {
                    var inline = (Inline)this.current;
                    switch (reader.LocalName)
                    {
                        case BoldElement:
                            inline.FontWeight = GetOnOffValueAttribute(reader) ? FontWeights.Bold : FontWeights.Normal;
                            break;
                        case ItalicElement:
                            inline.FontStyle = GetOnOffValueAttribute(reader) ? FontStyles.Italic : FontStyles.Normal;
                            break;
                        case UnderlineElement:
                            var underlineTextDecorations = GetUnderlineTextDecorations(reader, inline);
                            if (underlineTextDecorations != null)
                                inline.TextDecorations.Add(underlineTextDecorations);
                            break;
                        case StrikeElement:
                            if (GetOnOffValueAttribute(reader))
                                inline.TextDecorations.Add(TextDecorations.Strikethrough);
                            break;
                        case DoubleStrikeElement:
                            if (GetOnOffValueAttribute(reader))
                            {
                                inline.TextDecorations.Add(new TextDecoration()
                                {
                                    Location = TextDecorationLocation.Strikethrough,
                                    PenOffset = this.current.FontSize * 0.015
                                });
                                inline.TextDecorations.Add(new TextDecoration()
                                {
                                    Location = TextDecorationLocation.Strikethrough,
                                    PenOffset = this.current.FontSize * -0.015
                                });
                            }


                            break;
                        case VerticalAlignmentElement:
                            var baselineAlignment = GetBaselineAlignment(GetValueAttribute(reader));
                            if (baselineAlignment.HasValue)
                            {
                                inline.BaselineAlignment = baselineAlignment.Value;
                                if (baselineAlignment.Value == BaselineAlignment.Subscript ||
                                    baselineAlignment.Value == BaselineAlignment.Superscript)
                                    inline.FontSize *=
                                        0.65; //MS Word 2002 size: 65% http://en.wikipedia.org/wiki/Subscript_and_superscript
                            }


                            break;
                        case ColorElement:
                            var color = GetColor(GetValueAttribute(reader));
                            if (color.HasValue)
                                inline.Foreground = new SolidColorBrush(color.Value);
                            break;
                        case HighlightElement:
                            var highlight = GetHighlightColor(GetValueAttribute(reader));
                            if (highlight.HasValue)
                                inline.Background = new SolidColorBrush(highlight.Value);
                            break;
                        case FontElement:
                            var fontFamily = reader[AsciiFontFamily, WordprocessingMLNamespace];
                            if (!string.IsNullOrEmpty(fontFamily))
                                inline.FontFamily =
                                    (FontFamily)new FontFamilyConverter().ConvertFromString(fontFamily);
                            break;
                        case FontSizeElement:
                            var fontSize = reader[ValueAttribute, WordprocessingMLNamespace];
                            if (!string.IsNullOrEmpty(fontSize))
                                // Attribute Value / 2 = Points
                                // Points * (96 / 72) = Pixels
                                inline.FontSize = uint.Parse(fontSize) * 0.6666666666666667;
                            break;
                        case RightToLeftTextElement:
                            inline.FlowDirection = (GetOnOffValueAttribute(reader))
                                ? FlowDirection.RightToLeft
                                : FlowDirection.LeftToRight;
                            break;
                    }
                }
        }


        protected override void ReadBreak(XmlReader reader)
        {
            this.AddChild(new LineBreak());
        }


        protected override void ReadTabCharacter(XmlReader reader)
        {
            this.AddChild(new Run("\t"));
        }


        protected override void ReadText(XmlReader reader)
        {
            this.AddChild(new Run(reader.ReadString()));
        }


        private void AddChild(TextElement textElement)
        {
            ((IAddChild)this.current ?? this.document).AddChild(textElement);
        }


        private static bool GetOnOffValueAttribute(XmlReader reader)
        {
            var value = GetValueAttribute(reader);


            switch (value)
            {
                case null:
                case "1":
                case "on":
                case "true":
                    return true;
                default:
                    return false;
            }
        }


        private static string GetValueAttribute(XmlReader reader)
        {
            return reader[ValueAttribute, WordprocessingMLNamespace];
        }


        private static Color? GetColor(string colorString)
        {
            if (string.IsNullOrEmpty(colorString) || colorString == "auto")
                return null;


            return (Color)ColorConverter.ConvertFromString('#' + colorString);
        }


        private static Color? GetHighlightColor(string highlightString)
        {
            if (string.IsNullOrEmpty(highlightString) || highlightString == "auto")
                return null;


            return (Color)ColorConverter.ConvertFromString(highlightString);
        }


        private static BaselineAlignment? GetBaselineAlignment(string verticalAlignmentString)
        {
            switch (verticalAlignmentString)
            {
                case "baseline":
                    return BaselineAlignment.Baseline;
                case "subscript":
                    return BaselineAlignment.Subscript;
                case "superscript":
                    return BaselineAlignment.Superscript;
                default:
                    return null;
            }
        }


        private static double? ConvertTwipsToPixels(string twips)
        {
            if (string.IsNullOrEmpty(twips))
                return null;
            else
                return ConvertTwipsToPixels(double.Parse(twips, CultureInfo.InvariantCulture));
        }


        private static double ConvertTwipsToPixels(double twips)
        {
            return 96d / (72 * 20) * twips;
        }


        private static TextAlignment? ConvertTextAlignment(string value)
        {
            switch (value)
            {
                case "both":
                    return TextAlignment.Justify;
                case "left":
                    return TextAlignment.Left;
                case "right":
                    return TextAlignment.Right;
                case "center":
                    return TextAlignment.Center;
                default:
                    return null;
            }
        }


        private static Thickness GetSpacing(XmlReader reader, Thickness margin)
        {
            var after = ConvertTwipsToPixels(reader[SpacingAfterAttribute, WordprocessingMLNamespace]);
            if (after.HasValue)
                margin.Bottom = after.Value;


            var before = ConvertTwipsToPixels(reader[SpacingBeforeAttribute, WordprocessingMLNamespace]);
            if (before.HasValue)
                margin.Top = before.Value;


            return margin;
        }


        private static void SetParagraphIndent(XmlReader reader, Paragraph paragraph)
        {
            var margin = paragraph.Margin;


            var left = ConvertTwipsToPixels(reader[LeftIndentationAttribute, WordprocessingMLNamespace]);
            if (left.HasValue)
                margin.Left = left.Value;


            var right = ConvertTwipsToPixels(reader[RightIndentationAttribute, WordprocessingMLNamespace]);
            if (right.HasValue)
                margin.Right = right.Value;


            paragraph.Margin = margin;


            var firstLine = ConvertTwipsToPixels(reader[FirstLineIndentationAttribute, WordprocessingMLNamespace]);
            if (firstLine.HasValue)
                paragraph.TextIndent = firstLine.Value;


            var hanging = ConvertTwipsToPixels(reader[HangingIndentationAttribute, WordprocessingMLNamespace]);
            if (hanging.HasValue)
                paragraph.TextIndent -= hanging.Value;
        }


        private static Brush GetShading(XmlReader reader)
        {
            var color = GetColor(reader[FillAttribute, WordprocessingMLNamespace]);
            return color.HasValue ? new SolidColorBrush(color.Value) : null;
        }


        private static TextDecorationCollection GetUnderlineTextDecorations(XmlReader reader, Inline inline)
        {
            TextDecoration textDecoration;
            Brush brush;
            var color = GetColor(reader[ColorAttribute, WordprocessingMLNamespace]);


            if (color.HasValue)
                brush = new SolidColorBrush(color.Value);
            else
                brush = inline.Foreground;


            var textDecorations = new TextDecorationCollection()
            {
                (textDecoration = new TextDecoration()
                {
                    Location = TextDecorationLocation.Underline,
                    Pen = new Pen()
                    {
                        Brush = brush
                    }
                })
            };


            switch (GetValueAttribute(reader))
            {
                case "single":
                    break;
                case "double":
                    textDecoration.PenOffset = inline.FontSize * 0.05;
                    textDecoration = textDecoration.Clone();
                    textDecoration.PenOffset = inline.FontSize * -0.05;
                    textDecorations.Add(textDecoration);
                    break;
                case "dotted":
                    textDecoration.Pen.DashStyle = DashStyles.Dot;
                    break;
                case "dash":
                    textDecoration.Pen.DashStyle = DashStyles.Dash;
                    break;
                case "dotDash":
                    textDecoration.Pen.DashStyle = DashStyles.DashDot;
                    break;
                case "dotDotDash":
                    textDecoration.Pen.DashStyle = DashStyles.DashDotDot;
                    break;
                case "none":
                default:
                    // If underline type is none or unsupported then it will be ignored.
                    return null;
            }


            return textDecorations;
        }


        private IDisposable SetCurrent(TextElement current)
        {
            return new CurrentHandle(this, current);
        }
        private struct CurrentHandle : IDisposable
        {
            private readonly DocxToFlowDocumentConverter converter;
            private readonly TextElement previous;


            public CurrentHandle(DocxToFlowDocumentConverter converter, TextElement current)
            {
                this.converter = converter;
                this.converter.AddChild(current);
                this.previous = this.converter.current;
                this.converter.current = current;
            }


            public void Dispose()
            {
                this.converter.current = this.previous;
            }
        }
    }
}

，最后，在MainWindow.xaml代码：

<Window x:Class="WpfEmbeddedDocx.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WpfEmbeddedDocx"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        <DockPanel>
            <Menu DockPanel.Dock="Top">
                <MenuItem Header="_Open file..." Click="OnOpenFileClicked"/>
            </Menu>
            <FlowDocumentScrollViewer Name="FlowDocumentScrollViewer"></FlowDocumentScrollViewer>
        </DockPanel>
    </Grid>
</Window>

MainWindow.cs的代码：

using System.IO;
using System.Windows;
using System.Windows.Controls;
using Microsoft.Win32;


namespace WpfEmbeddedDocx
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }


        private void ReadDocx(string path)
        {
            using (var stream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
            {
                var flowDocumentConverter = new DocxToFlowDocumentConverter(stream);
                flowDocumentConverter.Read();
                FlowDocumentScrollViewer.Document = flowDocumentConverter.Document;
                this.Title = Path.GetFileName(path);
            }
        }


        private void OnOpenFileClicked(object sender, RoutedEventArgs e)
        {
            var openFileDialog = new OpenFileDialog()
            {
                DefaultExt = ".docx",
                Filter = "Word documents (.docx)|*.docx"
            };


            if (openFileDialog.ShowDialog() == true)
                this.ReadDocx(openFileDialog.FileName);
        }
    }
}

这样就能实现视频中的效果啦。。

下载链接：https://pan.baidu.com/s/1UO9GYYsUmoPWd49aVGR4rQ 

提取码：bybq 

原Git仓库代码地址：https://github.com/ArtMalykhin/wpf-embedded-docx

感谢作者无私分享

dotNET跨平台
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
WPF 将 docx 的 Word 文件转换为 FlowDocument 显示
lindexi
08-06 1114
本文告诉大家如何将 docx 的 Word 文档在 WPF 中显示内容 本文源代码请看 ArtMalykhin/wpf-embedded-docx 在 Office 文档解析 文档格式和协议 咱可以了解到 Word 文档只是一个压缩文件里面的文件使用 xml 表示 因此需要做的是将 xml 转 FlowDocument 在 WPF 界面显示，大概做到的效果就是丢失很多样式和特效，然后文本形式...
使用WPF在线预览和显示Word和PDF文件
一个专注于技术研究创新的程序员
07-01 5922
PDF和Word预览，可用于WPF和Winform。 原理是采用spire把word或者pdf文件转成xps文件，用documentViewer来呈现，并重新封装了显示的样子
WPF读取和显示word的方法
skysword2的博客
09-07 1万+
原文来自  http://www.cnblogs.com/lisweden/p/3544642.html 引言 在项目开发中，word的读取和显示会经常出现在客户的需求中。特别是一些有关法律规章制度、通知、红头文件等，都是用word发布的。 在WPF中，对显示WORD没有特定的控件，这对开发显示WORD的需求就增加了点困难。其实只要转换下思路，问题就可以迎刃而解了。 WORD转换为XP
WPF 结合DsoFramer嵌入Office, 操作word, excel内容，嵌入浏览器 预览html
04-11
C# WPF 结合DsoFramer嵌入Office应用程序, 操作word文档, excel文档，嵌入浏览器，用于预览html页面
WPF打开操作Office文档的解决办法
JH20040的博客
05-06 398
转载自：http://blog.csdn.net/soft2buy/article/details/6448448 　　　 http://code.msdn.microsoft.com/office/CSVSTOViewWordInWPF-db347436 最近在一个项目碰到一个问题，要用WPF打开并显示打印Office文档。包括Word, Excel,和PowerPoint文...
WPF 常见文件预览DEMO
05-22
这个"预览文件-文件类型 支持Word(.doc .docx)、Excel(.xls .xlsx)、PPT(.ppt .pptx)、PDF(.pdf)、Image"的DEMO展示了如何在WPF应用中实现对多种常见文件类型的预览。以下是对这个DEMO的详细解析： 1. **WPF基础** ...
C# WPF根据word模板生成word文档
10-22
在这个场景中，我们将使用它来读取Word模板并生成新的文档。 以下是实现这个功能的基本步骤： 1. 引用库：首先，在C#项目中添加对`Microsoft.Office.Interop.Word`的引用。这可以通过在解决方案资源管理器中右键...
ContentControlDemo_WPF_
10-01
程序可能通过读取.docx文件，查找特定的占位符，用用户提供的数据替换这些占位符，最终生成新的个性化文档。 【详细知识点】 1. **WPF（Windows Presentation Foundation）**：是.NET Framework的一部分，提供了一...
C# 文件信息读取 txt word execl ppt
05-06
- 读取docx文件中的文本： ```csharp using DocumentFormat.OpenXml.Packaging; string filePath = "path_to_your_file.docx"; using (WordprocessingDocument document = WordprocessingDocument.Open...
办公助理工具--文件目录的读取与保存程序
10-29
7. **文件过滤**：在某些情况下，用户可能只需要特定类型的文件（如只列出.txt或.docx文件）。这可以通过在`GetFiles()`方法中传入通配符参数实现。 8. **性能优化**：对于大型文件夹，遍历所有文件可能会消耗一定...
WPF中打开PPT word excel
08-17
WPF中实现打开PPT word excel等office文档
《WPF经典教程 》WORD完美珍藏版
06-14
本教程文字生动，代码详尽，都经过精心调试，附有图片说明，通俗易懂。适用于各类WPF程序员。 教程内容： (1) WPF体系结构.doc (2) WPF应用程序管理.doc (3) WPF窗体.doc (4).StackPanel、WrapPanel、DockPanel布局.doc (5).Grid、UniformGrid布局 .doc (6).Canvas、InkCanvas布局 .doc (7).WPF控件模型 .doc (8).WPF控件内容模型.doc (9) .Panel Decorator TextBlock内容模型.doc (10). 依赖项属性和路由事件.doc (11).键盘输入、鼠标输入、焦点处理.doc (12).WPF命令.doc (13) WPF资源.doc
界面控件DevExpress WPF富文本编辑器，让系统拥有Word功能（二）
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
05-06 1925
本文介绍DevExpress WPF控件中的富文本编辑器，该允许开发者将文字处理功能集成WPF项目中。
WPF嵌入WORD文档
weixin_30909575的博客
10-11 1003
　　最近项目中遇到要嵌入WORD文档 ，网上查找了些资料，发现VS是提供这个控件的。 　　DocumentViewer控件可插入WORD EXCEL PDF TXT等等，很强大的一个东西。 　　我的需求是嵌入word的文档，显示数据以及保持时将数据以及数据的样式以二进制的形式存入数据库。这就涉及3步，1读取WORD文档 2将数据存入数据库 3下次打开的时候需要从数据库的数据显示在嵌入的word...
Edraw Office Viewer component教程（三）：将MS Word、Excel、PowerPoint嵌入到WPF应用程序中
慧聚IT
05-12 4995
如何将Word、Excel、PowerPoint嵌入WPF应用程序？大部分人应该都记得可以将Excel图表嵌入到Word文档中的OLE技术，但该技术并不支持所有的Microsoft Office文档。它不支持表单中的多个MS Word实例。而Edraw office viewer component对于开发人员可以说是最简单的可以将Word文档、Excel工作表、PowerPoint演示文稿嵌
org/openxmlformats/schemas/wordprocessingml/x2006/main/FontsDocument问题分析及解决方法
热门推荐
wdkymys的博客
09-23 2万+
项目上需要实现一个功能，是word转为html。word有两种格式doc和docx。在实现的过程中，遇到一个比较棘手的问题，一直报 java.lang.NoClassDefFoundError: org/openxmlformats/schemas/wordprocessingml/x2006/main/FontsDocument$Factory这样的错误，根据错误提示可以判断出是jar包的问题...
wpf读取csv文件
最新发布
06-20
在WPF（Windows Presentation Foundation）中，读取CSV（Comma Separated Values）文件通常使用.NET框架提供的`System.IO`和`System.Data`命名空间中的类。以下是一个基本步骤的示例： 1. 引入所需命名空间： ```...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值