PM> Install-Package Spire.Doc

using Spire.Doc;
using Spire.Doc.Documents;
using System.Text;
using System.IO;

namespace ExtractTextfromWord
{
    class ExtractText
    {
        static void Main(string[] args)
        {
            //创建Document对象
            Document document = new Document();

            //加载Word文档 
            document.LoadFromFile("示例.docx");

            //创建StringBuilder实例
            StringBuilder sb = new StringBuilder();

            //遍历文档中所有节
            foreach (Section section in document.Sections)
            {
                //遍历每一节中的段落
                foreach (Paragraph paragraph in section.Paragraphs)
                {
                    //获取段落文本并保存到StringBuilder实例中
                    sb.AppendLine(paragraph.Text);
                }
            }

            //将提取的文本写入txt文档
            File.WriteAllText("提取文本.txt", sb.ToString());
        }
    }
}

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;

namespace ExtractImage
{
    class Program
    {
        static void Main(string[] args)
        {
            //加载Word文档
            Document document = new Document("示例.docx");
            int index = 0;

            //遍历文档中所有节
            foreach (Section section in document.Sections)
            {
                //遍历每一节中所有段落
                foreach (Paragraph paragraph in section.Paragraphs)
                {
                    //遍历每个段落中的子对象
                    foreach (DocumentObject docObject in paragraph.ChildObjects)
                    {
                        //如果子对象为图片, 则将图片保存到指定路径
                        if (docObject.DocumentObjectType == DocumentObjectType.Picture)
                        {
                            DocPicture picture = docObject as DocPicture;
                            picture.Image.Save(string.Format("提取图片\\图_{0}.png", index), System.Drawing.Imaging.ImageFormat.Png);
                            index++;
                        }
                    }
                }
            }
        }
    }
}

pip install Spire.XLS

from spire.xls import Workbook, ExcelVersion

# 创建Workbook类的实例
workbook = Workbook()

# 载入XLS文件
workbook.LoadFromFile("示例1.xls")

# 将XLS文件保存为XLSX文件
workbook.SaveToFile("output/XLS转XLSX.xlsx", ExcelVersion.Version2016)
workbook.Dispose()

from spire.xls import Workbook, ExcelVersion

# 创建Workbook类的实例
workbook = Workbook()

# 载入XLSX文件
workbook.LoadFromFile("示例2.xlsx")

# 将XLSX文件保存为XLS文件
workbook.SaveToFile("output/XLSX转XLS.xls", ExcelVersion.Version97to2003)
workbook.Dispose()

pip install Spire.Presentation

from spire.presentation import *

# 定义输入文件路径，即要拆分的PPT模板文件
inputFile = "signature/InputTemplate.pptx"

# 定义输出文件夹路径，用于存放拆分后的PPT文件
outputFolder = "signature/output"

# 创建一个Presentation对象，用于操作PPT文件
ppt = Presentation()

# 从指定路径加载PPT文件到Presentation对象中
ppt.LoadFromFile(inputFile)

# 遍历PPT文件中的每一张幻灯片
for i, slide in enumerate(ppt.Slides):
   
    # 创建一个新的Presentation对象，用于存储拆分后的幻灯片
    newppt = Presentation()
   
    # 移除新Presentation对象中的默认空白幻灯片
    newppt.Slides.RemoveAt(0)
    
    # 将当前遍历到的幻灯片添加到新的Presentation对象中
    newppt.Slides.AppendBySlide(slide)

    # 生成拆分后的文件名，包括输出文件夹路径和序号
    result = outputFolder + "//" + "SplitPPT-" + str(i) + ".pptx"
   
    # 将新的Presentation对象保存为PPTX格式的文件
    newppt.SaveToFile(result, FileFormat.Pptx2010)
   
    # 释放newppt对象的资源
    newppt.Dispose()

# 释放原始ppt对象的资源
ppt.Dispose()

from spire.presentation import *

# 定义输入文件路径，即要处理的PPT模板文件
inputFile = "signature/InputTemplate.pptx"

# 定义输出文件夹路径，用于存放分割后的PPT文件
outputFolder = "signature/output1"

# 创建一个空的Presentation对象，用于加载和操作PPT文件
ppt = Presentation()

# 从指定路径加载PPT模板文件到Presentation对象中
ppt.LoadFromFile(inputFile)

# 创建一个新的Presentation对象，用于存储分割后的第一部分幻灯片
ppt1 = Presentation()

# 移除新Presentation对象中的默认空白幻灯片
ppt1.Slides.RemoveAt(0)

# 循环两次，将原Presentation对象的前两个幻灯片添加到新的Presentation对象中
for i in range(2):
   ppt1.Slides.AppendBySlide(ppt.Slides[i])

# 拼接输出文件的完整路径，并保存第一部分幻灯片到该路径下的SplitPPT1.pptx文件中
result = outputFolder + "//" + "SplitPPT1.pptx"
ppt1.SaveToFile(result, FileFormat.Pptx2010)

# 创建一个新的Presentation对象，用于存储分割后的第二部分幻灯片
ppt2 = Presentation()

# 移除新Presentation对象中的默认空白幻灯片
ppt2.Slides.RemoveAt(0)

# 将原Presentation对象的第三个幻灯片添加到新的Presentation对象中
ppt2.Slides.AppendBySlide(ppt.Slides[2])

# 拼接输出文件的完整路径，并保存第二部分幻灯片到该路径下的SplitPPT2.pptx文件中
result = outputFolder + "//" + "SplitPPT2.pptx"
ppt2.SaveToFile(result, FileFormat.Pptx2010)

# 释放所有Presentation对象占用的资源
ppt.Dispose()
ppt1.Dispose()
ppt2.Dispose()

PM> Install-Package Spire.XLS

using Spire.Xls;
using System.Linq;

namespace RearrangeRows
{
    internal class Program
    {
         static void Main(string[] args)      
         {
            // 创建一个Workbook对象
            Workbook workbook = new Workbook();

            // 从指定路径加载Excel文件
            workbook.LoadFromFile(@"../../data1/摘要.xlsx");

            // 获取第一个工作表
            Worksheet worksheet = workbook.Worksheets[0];

            // 定义新的行顺序数组
            int[] newRowOrder = new int[] { 0,1,2,3,6,4,5};

            // 添加一个新的工作表，命名为"temp"
            Worksheet newSheet = workbook.Worksheets.Add("temp");

            // 将原工作表的内容复制到新工作表中
            newSheet.CopyFrom(worksheet);

            // 遍历新的行顺序数组
            for (int i = 0; i < newRowOrder.Count(); i++)
            {
                // 将原工作表的行复制到新工作表的新位置
                newSheet.Rows[newRowOrder[i]].Copy(worksheet.Rows[i], true, true);

                // 将原工作表的行高设置为新工作表对应行的行高
                worksheet.Rows[i].RowHeight = newSheet.Rows[newRowOrder[i]].RowHeight;
            }

            // 删除临时工作表
            workbook.Worksheets.Remove(newSheet);

            // 将修改后的工作簿保存到指定路径，使用2016版本的Excel格式
            workbook.SaveToFile(@"../../output/MoveRow.xlsx", FileFormat.Version2016);
         }
    }
}

using Spire.Xls;
using System.Linq;

namespace RearrangeColumns
{
    internal class Program
    {
         static void Main(string[] args)       
         {
            // 创建一个Workbook对象
            Workbook workbook = new Workbook();

            // 从指定路径加载Excel文件
            workbook.LoadFromFile(@"../../data1/资产.xlsx");

            // 获取第一个工作表
            Worksheet worksheet = workbook.Worksheets[0];

            // 定义新的列顺序
            int[] newColumnOrder = new int[] { 0,1,3,2 };

            // 添加一个新的工作表，命名为"temp"
            Worksheet newSheet = workbook.Worksheets.Add("temp");

            // 将原工作表的内容复制到新工作表中
            newSheet.CopyFrom(worksheet);

            // 遍历新的列顺序数组
            for (int i = 0; i < newColumnOrder.Count(); i++)
            {
                // 将原工作表的列复制到新工作表的新位置
                newSheet.Columns[newColumnOrder[i]].Copy(worksheet.Columns[i], true, true);

                // 将原工作表的列宽设置为新工作表对应列的列宽
                worksheet.Columns[i].ColumnWidth = newSheet.Columns[newColumnOrder[i]].ColumnWidth;
            }

            // 删除临时工作表
            workbook.Worksheets.Remove(newSheet);

            // 将修改后的工作簿保存到指定路径，使用2016版本的Excel格式
            workbook.SaveToFile(@"../../output/MoveColumn.xlsx", FileFormat.Version2016); 
         }
    }
}

PM> Install-Package Spire.Doc

using Spire.Doc;
using System.IO;
using System.Text;

namespace FindHyperlink
{
    internal class Program
    {
         static void Main(string[] args)      
         {
            // 创建一个Document对象
            Document doc = new Document();
           
            // 从指定路径加载一个Word文档
            doc.LoadFromFile(@"hyperlink.docx");
          
            // 创建一个Field类型的列表，用于存储超链接
            List hyperlinks = new List();
           
            // 遍历文档的所有节
            foreach (Section section in doc.Sections)
            {
                // 遍历每个节的子对象
                foreach (DocumentObject sec in section.Body.ChildObjects)
                {
                    // 判断子对象是否为段落类型
                    if (sec.DocumentObjectType == DocumentObjectType.Paragraph)
                    {
                        // 遍历段落的子对象
                        foreach (DocumentObject para in (sec as Paragraph).ChildObjects)
                        {
                            // 判断子对象是否为Field类型
                            if (para.DocumentObjectType == DocumentObjectType.Field)
                            {
                                // 将子对象转换为Field类型
                                Field field = para as Field;

                                // 判断字段是否为超链接类型
                                if (field.Type == FieldType.FieldHyperlink)
                                {
                                    // 将超链接对象添加到列表中
                                    hyperlinks.Add(field);
                                }
                            }
                        }
                    }
                }
            }
            // 创建一个StringBuilder对象，用于拼接超链接信息
            StringBuilder sb = new StringBuilder();
          
            // 遍历超链接列表
            foreach (Field hyperlink in hyperlinks)
            {
                // 添加超链接显示文本到StringBuilder中
                sb.AppendLine("超链接的文本：" + hyperlink.FieldText);
              
                // 添加超链接地址URL到StringBuilder中
                sb.AppendLine("超链接的链接：" + hyperlink.Code);
             
                // 添加空行分隔不同的超链接信息
                sb.AppendLine();
            }

            // 将StringBuilder中的内容写入到指定的文件中
            File.WriteAllText(@"Hyper_Result.txt", sb.ToString());

            // 关闭文档对象
            doc.Close();    
         }
    }
}

using Spire.Doc.Documents;
using Spire.Doc;
using System.Text;
using System.IO;

namespace CountWordsAndCharactersForParagraph
{
    internal class Program
    {
         static void Main(string[] args)       
 	     {
            // 创建一个Document对象
            Document doc = new Document();

            // 从指定路径加载一个Word文档
            doc.LoadFromFile(@"../../data/hyperlink.docx");

            // 遍历文档的所有节
            foreach (Section section in doc.Sections)
            {
                // 遍历每个节的子对象
                foreach (DocumentObject sec in section.Body.ChildObjects)
                {
                    // 判断子对象是否为段落类型
                    if (sec.DocumentObjectType == DocumentObjectType.Paragraph)
                    {
                        // 遍历段落的子对象
                        foreach (DocumentObject para in (sec as Paragraph).ChildObjects)
                        {
                            // 判断子对象是否为Field类型
                            if (para.DocumentObjectType == DocumentObjectType.Field)
                            {
                                // 将子对象转换为Field类型
                                Field field = para as Field;

                                // 判断字段是否为超链接类型
                                if (field.Type == FieldType.FieldHyperlink)
                                {
                                    // 判断超链接文本是否为"Spire.Doc for .NET"
                                    if (field.FieldText.Equals("Spire.Doc for .NET"))
                                    {
                                        // 修改超链接的目标地址
                                        field.Code = "HYPERLINK \"" + "https://www.e-iceblue.com/Introduce/word-for-net-introduce.html" + "\"";

                                        // 设置超链接字体大小为15
                                        field.CharacterFormat.FontSize = 15;

                                        // 设置超链接字体颜色为红色
                                        field.CharacterFormat.TextColor = Color.Red;

                                        // 设置超链接字体为斜体
                                        field.CharacterFormat.Italic = true;

                                        // 设置超链接字体为粗体
                                        field.CharacterFormat.Bold = true;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // 将修改后的文档保存到指定路径，格式为Docx
            doc.SaveToFile(@"EditHyperlinks.docx", FileFormat.Docx); 
 	     }
    }
}

pip install Spire.Presentation

from spire.presentation import *
from spire.presentation.common import *

# 创建 Presentation 类的对象
pres = Presentation()

# 加载一个 PowerPoint 演示文稿
pres.LoadFromFile("示例.pptx")

# 获取第二张幻灯片
slide = pres.Slides[0]

# 获取演示文稿中的视频
videos = pres.Videos

# 遍历幻灯片上的形状
for shape in slide.Shapes:
    # 检查形状是否为视频
    if isinstance(shape, IVideo):
        video = shape if isinstance(shape, IVideo) else None
        # 将新视频附加到视频集合中
        videoData = videos.AppendByStream(Stream("Ocean2.mp4"))
        # 用新视频替换形状中的视频
        video.EmbeddedVideoData = videoData
        # 在演示文稿中嵌入一张图片
        imageData = pres.Images.AppendStream(Stream("Ocean2.png"))
        # 将新图片设置为视频的预览
        video.PictureFill.Picture.EmbedImage = imageData

# 保存演示文稿
pres.SaveToFile("output/替换视频.pptx", FileFormat.Pptx2016)
pres.Dispose()

from spire.presentation import *
from spire.presentation.common import *

# 创建 Presentation 类的对象
pres = Presentation()

# 加载一个 PowerPoint 演示文稿文件
pres.LoadFromFile("示例.pptx")

# 从演示文稿中获取音频
audios = pres.WavAudios

# 获取包含音频的幻灯片
slide = pres.Slides[0]

# 遍历幻灯片中的每个形状
for shape in slide.Shapes:
    # 检查形状是否为音频形状
    if isinstance(shape, IAudio):
        audio = shape if isinstance(shape, IAudio) else None
        # 加载音频文件
        stream = Stream("Wave2.wav")
        # 替换形状中的音频
        audioData = audios.Append(stream)
        audio.Data = audioData

# 保存演示文稿
pres.SaveToFile("output/替换音频.pptx", FileFormat.Pptx2016)
pres.Dispose()

pip install Spire.Doc

from spire.doc import *
from spire.doc.common import *

# 创建一个 Document 类的对象
document = Document()
# 加载包含批注的 Word 文档
document.LoadFromFile("批注.docx")

# 创建一个列表来存储提取的批注数据
comments = []

# 遍历文档中的批注
for i in range(document.Comments.Count):
    ccomment = document.Comments.get_Item(i)
    comment_text = ""

    # 遍历批注正文中的段落
    for j in range(comment.Body.Paragraphs.Count):
        paragraph = comment.Body.Paragraphs.get_Item(j)
        comment_text += paragraph.Text + "\n"

    # 获取批注作者
    comment_author = comment.Format.Author

    # 将批注数据添加到列表中
    comments.append({
        "作者": comment_author,
        "内容": comment_text
    })

# 将批注数据写入文件
with open("批注.txt", "w", encoding="utf-8") as file:
    for i, comment in enumerate(comments, start=1):
        file.write(f"批注{i}:\n  作者: {comment['作者']}\n  批注内容: {comment['内容']}\n")

document.Close()

from spire.doc import *
from spire.doc.common import *

# 创建一个 Document 类的对象
document = Document()
# 加载包含批注的 Word 文档
document.LoadFromFile("图片批注.docx")

# 创建一个列表来存储提取的图片数据
images = []

# 遍历文档中的批注
for i in range(document.Comments.Count):
    comment = document.Comments.get_Item(i)
    # 遍历批注正文中的段落
    for j in range(comment.Body.Paragraphs.Count):
        paragraph = comment.Body.Paragraphs.get_Item(j)
        # 遍历段落中的子对象
        for o in range(paragraph.ChildObjects.Count):
            obj = paragraph.ChildObjects[o]
            # 查找图片
            if isinstance(obj, DocPicture):
                picture = obj
                # 获取图片数据并添加到列表中
                data_bytes = picture.ImageBytes
                images.append(data_bytes)

# 将图片数据保存为图片文件
for i, image_data in enumerate(images):
    file_name = f"批注图片-{i}.png"
    with open(os.path.join("批注图片/", file_name), 'wb') as image_file:
        image_file.write(image_data)

document.Close()

pip install Spire.XLS

from spire.xls import *
from spire.xls.common import *

def AppendAllText(fname: str, text: List[str]):
    """
    将文本列表写入指定文件
    
    参数:
    fname (str): 文件名
    text (List[str]): 文本列表
    """
    fp = open(fname, "w")
    for s in text:
        fp.write(s + "\n")
    fp.close()

inputFile = "示例.xlsx"
outputFile = "获取文档属性.txt"

# 创建 Workbook 实例
workbook = Workbook()

# 加载 Excel 文档
workbook.LoadFromFile(inputFile)

# 创建一个列表来存储文档属性
builder = []

# 获取所有标准文档属性的集合
standardProperties = workbook.DocumentProperties

# 获取特定的标准属性并添加到列表中
builder.append("标准文档属性:")
builder.append("标题: " + standardProperties.Title)
builder.append("主题: " + standardProperties.Subject)
builder.append("类别: " + standardProperties.Category)
builder.append("关键字: " + standardProperties.Keywords)
builder.append("备注: " + standardProperties.Comments)
builder.append("")

# 获取所有自定义文档属性的集合
customProperties = workbook.CustomDocumentProperties

builder.append("自定义属性:")
# 遍历集合
for i in range(len(customProperties)):
    
    # 获取每个自定义文档属性的名称、类型和值
    name = customProperties[i].Name
    type = customProperties[i].PropertyType
    obj = customProperties[i].Value

    # 确定具体的属性类型，并将属性值转换为相应的数据类型
    value = None
    if type == PropertyType.Double:
        value = Double(obj).Value
    elif type == PropertyType.DateTime:
        value = DateTime(obj).ToShortDateString()
    elif type == PropertyType.Bool:
        value = Boolean(obj).Value
    elif type == PropertyType.Int:
        value = Int32(obj).Value
    elif type == PropertyType.Int32:
        value = Int32(obj).Value
    else:
        value = String(obj).Value

    # 将属性名称和转换后的属性值添加到列表中   
    builder.append(name + ": " + str(value))

# 将列表的内容写入文本文件
AppendAllText(outputFile, builder)
workbook.Dispose()

from spire.xls import *
from spire.xls.common import *

inputFile = "示例.xlsx"
outputFile = "删除文档属性.xlsx"

# 创建 Workbook 实例
workbook = Workbook()

# 加载 Excel 文档
workbook.LoadFromFile(inputFile)

# 获取所有标准文档属性的集合
standardProperties = workbook.DocumentProperties

# 将每个标准文档属性的值设置为空
standardProperties.Title = ""
standardProperties.Subject = ""
standardProperties.Category = ""
standardProperties.Keywords = ""
standardProperties.Comments = ""

# 获取所有自定义文档属性的集合
customProperties = workbook.CustomDocumentProperties

# 倒序遍历集合
for i in range(len(customProperties) - 1, -1, -1):
    # 根据属性名称从集合中删除每个自定义文档属性
    customProperties.Remove(customProperties[i].Name)

# 保存结果文件
workbook.SaveToFile(outputFile, ExcelVersion.Version2016)
workbook.Dispose()