สร้างระบบตรวจทานเอกสาร: คู่มือการทำ Annotation PDF ด้วย .NET

หากคุณต้องการ สร้างระบบตรวจทานเอกสาร ที่ให้ผู้ใช้เพิ่มความคิดเห็น, ไฮไลท์, และรูปทรงต่าง ๆ ลงในไฟล์ PDF โดยตรงจากแอปพลิเคชัน .NET, คุณมาถูกที่แล้ว GroupDocs.Annotation สำหรับ .NET ช่วยขจัดความยุ่งยากของการจัดการ PDF ระดับล่าง พร้อมให้คุณควบคุมแต่ละประเภทของ annotation อย่างละเอียด ในคู่มือนี้คุณจะได้เรียนรู้วิธีตั้งค่าไลบรารี, เพิ่ม annotation ประเภทพื้นที่, รูปวงรีและข้อความ, กรองสิ่งที่บันทึก, และรักษาประสิทธิภาพให้รวดเร็วแม้กับไฟล์หลายร้อยหน้า.

คำตอบสั้น

  • ไลบรารีที่จัดการ PDF annotation ใน .NET คืออะไร? GroupDocs.Annotation for .NET.
  • ฉันสามารถเพิ่มไฮไลท์, วงกลม, และความคิดเห็นโดยโปรแกรมได้หรือไม่? ใช่ – ใช้วัตถุ AreaAnnotation, EllipseAnnotation และ TextAnnotation.
  • ต้องมีลิขสิทธิ์สำหรับการใช้งานในโปรดักชันหรือไม่? จำเป็นต้องมีลิขสิทธิ์ GroupDocs ที่ถูกต้องสำหรับการใช้งานในสภาพแวดล้อมการผลิตใด ๆ.
  • PDF ขนาดเท่าไหร่ที่สามารถประมวลผลได้? สามารถจัดการไฟล์ขนาดสูงสุด 500 MB ได้โดยไม่ต้องโหลดไฟล์ทั้งหมดเข้าสู่หน่วยความจำ.
  • วิธีนี้จะช่วยฉันสร้างระบบตรวจทานเอกสารได้หรือไม่? แน่นอน – คุณสามารถบันทึกเป็นชุด, กรอง, และเวอร์ชันของ annotation สำหรับผู้ตรวจสอบได้.

ระบบตรวจทานเอกสารคืออะไร?

ระบบ document review คือโซลูชันซอฟต์แวร์ที่ทำให้ผู้มีส่วนได้ส่วนเสียหลายคนสามารถทำ annotation, แสดงความคิดเห็น, และอนุมัติไฟล์ PDF ในกระบวนการทำงานที่ประสานกันได้ ระบบนี้รวมศูนย์ฟีดแบ็ก, ติดตามการเปลี่ยนแปลง, และมักจะส่งออกเวอร์ชันที่สะอาดสำหรับการอนุมัติขั้นสุดท้าย.

ทำไมต้องใช้ GroupDocs Annotation สำหรับ .NET เพื่อสร้างระบบตรวจทานเอกสาร?

GroupDocs Annotation รองรับ ประเภท annotation มากกว่า 30 ประเภท, ประมวลผล PDF ขนาดสูงสุด 500 MB, และทำงานบน .NET Framework 4.6.1+, .NET Core 2.0+, และ .NET 6+. API ของมันทำให้คุณสามารถเพิ่ม, ลบ, และกรอง annotation ได้โดยไม่ต้องยุกับโครงสร้างภายในของ PDF, ซึ่งช่วยเร่งการพัฒนาและลดบั๊ก.

ข้อกำหนดเบื้องต้นและการตั้งค่าสภาพแวดล้อม

ก่อนเขียนโค้ดใด ๆ, ตรวจสอบให้แน่ใจว่าสภาพแวดล้อมการพัฒนาของคุณตรงตามเกณฑ์ต่อไปนี้:

  • IDE: Visual Studio 2019 หรือใหม่กว่า, หรือ VS Code พร้อมส่วนขยาย C#.
  • Target Framework: .NET Framework 4.6.1 + หรือ .NET Core 2.0 + (เราแนะนำ .NET 6 สำหรับโครงการใหม่).
  • NuGet Access: ความสามารถในการติดตั้งแพ็กเกจจาก nuget.org.
  • Sample PDFs: อย่างน้อยหนึ่งไฟล์ PDF หลายหน้าเพื่อทดสอบการวาง annotation.
  • Memory & Disk: RAM ขั้นต่ำ 4 GB และพื้นที่ดิสก์ว่างเพียงพอสำหรับไฟล์ชั่วคราว (การประมวลผล annotation สามารถสร้างสตรีมชั่วคราว).

แนวปฏิบัติการพัฒนาที่แนะนำ

  • เก็บโซลูชันของคุณภายใต้ระบบควบคุมเวอร์ชัน (Git) เพื่อให้สามารถย้อนกลับการเปลี่ยนแปลงที่เกี่ยวกับ annotation ได้.
  • ใช้โฟลเดอร์ Annotations แยกเฉพาะในโปรเจคของคุณเพื่อเก็บไฟล์การตั้งค่าและคีย์ลิขสิทธิ์.
  • เปิดใช้งาน nullable reference types (<Nullable>enable</Nullable>) เพื่อจับบั๊ก null‑reference ที่อาจเกิดขึ้นตั้งแต่แรก.

เริ่มต้นใช้งาน: การติดตั้ง GroupDocs.Annotation

วิธีการติดตั้ง

ตัวเลือก 1: NuGet Package Manager Console
รันคำสั่งต่อไปนี้ใน Package Manager Console:

Install-Package GroupDocs.Annotation

ตัวเลือก 2: .NET CLI (แนะนำสำหรับการพัฒนาข้ามแพลตฟอร์ม)
รันในเทอร์มินัล:

dotnet add package GroupDocs.Annotation

ตัวเลือก 3: Visual Studio Package Manager UI

  • คลิกขวาที่โปรเจค → Manage NuGet Packages
  • ค้นหา GroupDocs.Annotation
  • คลิก Install บนเวอร์ชันเสถียรล่าสุด

วิธีการทั้งสามติดตั้งไบนารีเดียวกัน; เลือกวิธีที่สอดคล้องกับกระบวนการทำงานของคุณ.

การกำหนดค่าลิขสิทธิ์

GroupDocs ต้องการลิขสิทธิ์ที่ถูกต้องสำหรับการใช้งานในโปรดักชัน คุณมีสามทางเลือก:

  • Free Trial: การประเมินผล 30 วันพร้อมฟีเจอร์เต็มชุด.
  • Temporary License: การประเมินผลต่อเนื่องสำหรับการพัฒนาและทดสอบ.
  • Commercial License: การใช้งานไม่จำกัดในสภาพแวดล้อมการผลิต.

License class โหลดและใช้ไฟล์ลิขสิทธิ์ GroupDocs เพื่อเปิดใช้งานฟังก์ชันเต็มรูปแบบ คุณสามารถรับลิขสิทธิ์ได้จาก GroupDocs purchase page. หลังจากได้รับไฟล์ .lic, ให้วางไว้ในโฟลเดอร์ที่แอปพลิเคชันของคุณสามารถอ่านได้และชี้คลาส License ไปที่ไฟล์นั้นเมื่อเริ่มต้น.

การตรวจสอบการตั้งค่าเบื้องต้น

สร้างโปรแกรมคอนโซลขนาดเล็กที่โหลด PDF แล้วพิมพ์จำนวนหน้าออกทางคอนโซล หากโปรแกรมทำงานโดยไม่มีข้อยกเว้น แสดงว่าไลบรารีถูกติดตั้งและได้รับลิขสิทธิ์อย่างถูกต้อง.

using GroupDocs.Annotation;
using GroupDocs.Annotation.Options;

var annotator = new Annotator("sample.pdf");
var info = annotator.GetDocumentInfo();
Console.WriteLine($"Pages: {info.PageCount}");

หมายเหตุ: โค้ดด้านบนเป็นเพียงการอธิบาย; คุณ ไม่จำเป็น ต้องเพิ่มบล็อกโค้ดแบบ fenced ในบทความสุดท้าย, แต่สแนปช็อตแบบอินไลน์แสดงการใช้ API อย่างแม่นยำ.

หากคุณเห็นจำนวนหน้าถูกพิมพ์ออกมา คุณพร้อมที่จะเริ่มเพิ่ม annotation จริงแล้ว.

การดำเนินการหลัก: การเพิ่ม Annotation ลงใน PDF

จุดอ้างอิงการกำหนด – Annotator

คลาส Annotator เป็นจุดเริ่มต้นสำหรับการดำเนินการ annotation ของ PDF ทั้งหมดใน GroupDocs.Annotation สำหรับ .NET มันโหลด PDF เข้าในหน่วยความจำ, เปิดเผยเมธอดสำหรับเพิ่ม, แก้ไข, และดึงข้อมูล annotation, และจัดการการบันทึกเอกสารที่แก้ไขแล้ว.

วิธีเพิ่ม annotation ประเภทพื้นที่และวงรี?

โหลด PDF ด้วย new Annotator(...), สร้างวัตถุ AreaAnnotation และ EllipseAnnotation, ตั้งค่าพิกัด, แล้วเพิ่มลงในคอลเลกชันของ annotator. สุดท้ายเรียก Save เพื่อบันทึกการเปลี่ยนแปลง การทำงานนี้ทำให้คุณสามารถไฮไลท์ส่วน (area) หรือวงกลมกราฟิกสำคัญบนการดำเนินการเดียวที่เป็น atomic.

ขั้นตอน 1: เริ่มต้น Annotator

var annotator = new Annotator("input.pdf");

ขั้นตอน 2: สร้าง AreaAnnotation

AreaAnnotation แสดงพื้นที่ไฮไลท์สี่เหลี่ยมบนหน้า PDF.

var area = new AreaAnnotation
{
    PageNumber = 0,
    Box = new RectangleF(100, 150, 200, 50),
    Color = Color.Yellow,
    Opacity = 0.4f,
    Text = "Review this paragraph"
};

ขั้นตอน 3: สร้าง EllipseAnnotation

EllipseAnnotation แสดง annotation รูปวงรีบนหน้า PDF.

var ellipse = new EllipseAnnotation
{
    PageNumber = 2,
    Box = new RectangleF(300, 400, 120, 80),
    Color = Color.Red,
    Opacity = 0.6f,
    Text = "Check this figure"
};

ขั้นตอน 4: เพิ่ม Annotation เป็นกลุ่ม

annotator.Add(new List<AnnotationBase> { area, ellipse });
annotator.Save("output.pdf");

เคล็ดลับ: การเพิ่ม annotation ในรายการและเรียก Add ครั้งเดียวจะลดภาระ I/O, โดยเฉพาะเมื่อคุณต้องแทรกหลายสิบเครื่องหมายบนหลายหน้า.

วิธีบันทึก annotation อย่างเลือกสรร?

SaveOptions กำหนดวิธีการบันทึก PDF ที่มี annotation, รวมถึงประเภท annotation ที่จะรวมไว้ GroupDocs.Annotation ให้คุณกรองประเภท annotation ที่จะเขียนลงไฟล์ผลลัพธ์ สร้างอินสแตนซ์ SaveOptions, ตั้งค่าคอลเลกชัน AnnotationTypes ให้เป็นประเภทที่ต้องการเก็บ, แล้วส่งตัวเลือกเหล่านั้นไปยัง Save. วิธีนี้เหมาะสำหรับการสร้าง PDF เฉพาะผู้ตรวจสอบหรือการลบโน้ตชั่วคราวก่อนเก็บถาวร.

var saveOptions = new SaveOptions
{
    AnnotationTypes = new[] { AnnotationType.Text, AnnotationType.Area }
};
annotator.Save("filtered.pdf", saveOptions);

สถานการณ์การใช้งานจริง

สถานการณ์ 1: กระบวนการตรวจทานเอกสาร

ผู้ตรวจสอบหลายคนเพิ่ม Area, Ellipse, และ Text annotation. หลังจากรอบการตรวจสอบ คุณสร้าง PDF สามไฟล์:

  1. เวอร์ชันเต็มที่มีทุกความคิดเห็น.
  2. เวอร์ชันสำหรับผู้ตรวจสอบเท่านั้น (กรองโน้ตภายใน).
  3. เวอร์ชันสะอาดสำหรับการอนุมัติขั้นสุดท้าย (เก็บเฉพาะไฮไลท์).

สถานการณ์ 2: การสร้างรายงานอัตโนมัติ

แบ็กเอนด์ของคุณประมวลผลรายงานการขายประจำวัน, ไฮไลท์เมตริกสำคัญด้วย area annotation และวงกลมกราฟที่เป็น out‑lier ด้วย ellipse annotation. PDF ที่สร้างขึ้นจะถูกส่งอีเมลให้ผู้มีส่วนได้ส่วนเสียโดยไม่มีการแทรกแซงของมนุษย์.

สถานการณ์ 3: เอกสารกฎหมายแบบร่วมมือ

บริษัทกฎหมายมักต้องแยกความคิดเห็นของพาร์ทเนอร์จากโน้ตของผู้ช่วยระดับจูเนียร์ โดยการแท็ก annotation ด้วย metadata แบบกำหนดเองและใช้การบันทึกแบบเลือกสรร คุณสามารถผลิต PDF สำหรับพาร์ทเนอร์ที่ซ่อนโน้ตของจูเนียร์, ทำให้การควบคุมเวอร์ชันง่ายขึ้น.

การเพิ่มประสิทธิภาพสำหรับการใช้งานในโปรดักชัน

วิธีจัดการหน่วยความจำเมื่อทำ annotation กับ PDF ขนาดใหญ่?

LoadOptions ให้คุณระบุวิธีการโหลด PDF, เช่นช่วงหน้า หรือรหัสผ่าน เมื่อ PDF มีขนาดเกิน 100 MB ควรหลีกเลี่ยงการโหลดไฟล์ทั้งหมดโดยใช้คอนสตรัคเตอร์ของ LoadOptions ที่รับช่วงหน้า ประมวลผลหน้าเป็นชุด, ทำลายอินสแตนซ์ Annotator ด้วยบล็อก using, และทำความสะอาดไฟล์ชั่วคราวหลังแต่ละชุด วิธีนี้ทำให้การใช้หน่วยความจำสูงสุดอยู่ต่ำกว่า 200 MB แม้กับเอกสาร 500‑หน้า.

using (var annotator = new Annotator("large.pdf", new LoadOptions { PageNumbers = new[] { 0, 1, 2 } }))
{
    // annotate first three pages
}

แนวปฏิบัติการจัดการหน่วยความจำที่ดีที่สุด

  • Always wrap Annotator in a using statement เพื่อรับประกันการปลดปล่อยทรัพยากรที่ไม่ได้จัดการ.
  • Batch‑process annotations: รวบรวม annotation ทั้งหมดสำหรับเอกสารหนึ่งไฟล์, แล้วเรียก Add ครั้งเดียว.
  • Avoid loading full PDFs เมื่อคุณต้องแก้ไขเพียงบางหน้าที่เลือก; ใช้ LoadOptions.PageNumbers.

กลยุทธ์การจัดการไฟล์ขนาดใหญ่

  1. Page‑wise processing – โหลด, ทำ annotation, และบันทึกทีละหน้า.
  2. Streaming output – ส่งเมธอด Save ไปยัง MemoryStream เพื่อหลีกเลี่ยงการเขียนไฟล์ชั่วคราวบนดิสก์.
  3. Temporary file cleanup – ลบไฟล์ชั่วคราวใด ๆ ที่สร้างโดย annotator หลังแต่ละการดำเนินการ.

ข้อพิจารณาการประมวลผลพร้อมกัน

  • Thread safety: อินสแตนซ์ Annotator ไม่ปลอดภัยต่อเธรดหลาย ๆ ตัว. สร้างอินสแตนซ์แยกสำหรับแต่ละเธรด.
  • Resource throttling: จำกัดจำนวนงานพร้อมกันให้เท่ากับจำนวนคอร์ของ CPU เพื่อป้องกันการอิ่มตัวของ CPU.
  • Async API: SaveAsync บันทึกเอกสารที่มี annotation อย่างไม่ประสาน, คืนค่า Task, ซึ่งมีประโยชน์ในสภาพแวดล้อม ASP.NET Core.

การแก้ไขปัญหาที่พบบ่อย

ปัญหา 1: ข้อผิดพลาด “File Not Found”

Direct answer: ตรวจสอบให้แน่ใจว่าเส้นทางไฟล์ที่ส่งให้ new Annotator(...) เป็นแบบ absolute หรือ relative อย่างถูกต้องต่อ assembly ที่กำลังทำงาน, และตรวจสอบว่าโปรเซสของแอปพลิเคชันมีสิทธิ์อ่านตำแหน่งนั้น หากไฟล์อยู่ในแชร์เครือข่าย ให้แมปแชร์หรือใช้ UNC path.

Typical fixes:

  • ใช้ Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Docs", "sample.pdf").
  • ให้สิทธิ์อ่าน/เขียนกับโฟลเดอร์แก่ IIS application pool identity.

ปัญหา 2: Annotation ปรากฏในตำแหน่งผิด

Direct answer: ตรวจสอบว่าคุณใช้ระบบพิกัดเดียวกัน (origin ที่มุมบน‑ซ้าย) และ DPI ของหน้าตรงกับค่าที่คุณให้ไว้ ดึงขนาดหน้าโดยใช้ annotator.GetPageInfo(pageNumber) แล้วคำนวณพิกัดสัมพันธ์กับขนาดนั้น.

Typical fixes:

  • คูณพิกัดด้วยสเกลของหน้าหาก PDF ถูกสร้างด้วย DPI ที่ไม่มาตรฐาน.
  • ตรวจสอบให้แน่ใจว่าคุณไม่ได้ผสมหน่วย points (1/72 นิ้ว) กับ pixels.

ปัญหา 3: ปัญหาประสิทธิภาพกับไฟล์ขนาดใหญ่

Direct answer: เปลี่ยนไปใช้การโหลดตามช่วงหน้า, ประมวลผล annotation เป็นชุด, และทำลายอินสแตนซ์ Annotator ทันที นอกจากนี้เปิดใช้งานตัวเลือก MemoryCache ใน LoadOptions เพื่อใช้บัฟเฟอร์ซ้ำระหว่างการดำเนินการ.

Typical fixes:

  • ตั้งค่า LoadOptions.UseMemoryCache = true.
  • ประมวลผลไฟล์แบบ asynchronous ด้วย await annotator.SaveAsync(...).

ปัญหา 4: ข้อผิดพลาดที่เกี่ยวกับลิขสิทธิ์

Direct answer: วางไฟล์ .lic ในโฟลเดอร์ที่แอปพลิเคชันสามารถอ่านได้, แล้วเรียก License license = new License(); license.SetLicense("path/to/license.lic"); ก่อนเรียกใช้ GroupDocs ใด ๆ ตรวจสอบให้แน่ใจว่าเวอร์ชันของลิขสิทธิ์ตรงกับเวอร์ชันของไลบรารีที่คุณใช้.

Typical fixes:

  • ตรวจสอบว่าไฟล์ลิขสิทธิ์ไม่เสียหาย (เปรียบเทียบขนาดไฟล์).
  • ตรวจสอบว่าคุณไม่ได้ผสมลิขสิทธิ์ทดลองกับลิขสิทธิ์เชิงพาณิชย์ในสภาพแวดล้อมเดียวกัน.

เคล็ดลับขั้นสูงและแนวปฏิบัติที่ดีที่สุด

การจัดการสี

สีที่สอดคล้องช่วยเพิ่มความอ่านง่ายสำหรับผู้ตรวจสอบ กำหนดพาเลต (เช่น สีเหลืองสำหรับไฮไลท์, สีแดงสำหรับประเด็นสำคัญ) และเก็บไว้ในคลาสช่วยเหลือแบบ static. อย่าลืมใช้สีคอนทราสต์สูงเพื่อความเข้าถึงได้และเพิ่มหน้า legend ใน PDF เพื่ออ้างอิง.

รูปแบบการจัดการข้อผิดพลาด

ห่อทุกการเรียก annotation ด้วยบล็อก try‑catch ที่จับ GroupDocs.Annotation.Exceptions.AnnotationException โดยเฉพาะ บันทึกข้อความข้อยกเว้น, stack trace, และชื่อ PDF เพื่อช่วยในการดีบัก.

กลยุทธ์การทดสอบ

  • Unit Tests: ใช้ PDF ขนาดเล็กที่มีมิติที่รู้จัก, เพิ่ม annotation, แล้วตรวจสอบว่า GetAnnotations() คืนค่าพิกัดที่คาดไว้.
  • Integration Tests: รันเวิร์กโฟลว์เต็มบน PDF ตั้งแต่ 1 หน้าถึง 200 หน้า, และตรวจสอบว่าเวลาในการประมวลผลอยู่ต่ำกว่า 5 วินาทีสำหรับไฟล์ที่มีขนาดต่ำกว่า 50 MB.
  • Load Tests: จำลองคำขอ annotation พร้อมกัน 50 รายการด้วยเครื่องมือเช่น k6 หรือ Apache JMeter และตรวจสอบการใช้ CPU/หน่วยความจำ.

คำถามที่พบบ่อย

Q: ฉันจะจัดการกับ PDF ที่มีขนาดหน้าต่างกันอย่างไร?
A: GroupDocs จะอ่านมิติของแต่ละหน้าโดยอัตโนมัติ เมื่อกำหนดตำแหน่ง annotation ให้เรียก annotator.GetPageInfo(pageNumber) เสมอและคำนวณพิกัดตามความกว้างและความสูงของหน้านั้น.

Q: ฉันสามารถทำ annotation บน PDF ที่มีการป้องกันด้วยรหัสผ่านได้หรือไม่?
A: ได้. ใช้คอนสตรัคเตอร์ของ LoadOptions ที่รับสตริงรหัสผ่าน เช่น new LoadOptions { Password = "secret" } แล้วส่งให้กับคอนสตรัคเตอร์ Annotator.

Q: จำนวน annotation สูงสุดที่ฉันสามารถเพิ่มใน PDF เดียวคือเท่าไหร่?
A: ไม่มีขีดจำกัดที่แน่นอน, แต่ประสิทธิภาพจะเริ่มลดลงหลังจากหลายพัน annotation. สำหรับชุด annotation ขนาดใหญ่มาก ควรแบ่งเป็นส่วนย่อยและประมวลผลแยกกัน.

Q: ฉันจะลบ annotation เฉพาะโดยโปรแกรมได้อย่างไร?
A: ดึง Id ของ annotation ผ่าน GetAnnotations(), แล้วเรียก Delete(id) หรือสร้าง SaveOptions ที่ไม่รวม AnnotationType ที่ไม่ต้องการ.

Q: ฉันสามารถปรับแต่งลักษณะของ annotation นอกเหนือจากสีได้หรือไม่?
A: แน่นอน. คุณสามารถตั้งค่า opacity, ความหนาของขอบ, รูปแบบ dash, และแม้กระทั่งฝังไอคอน SVG แบบกำหนดเองสำหรับ annotation ประเภท stamp.

Q: จะเกิดอะไรขึ้นหากฉันพยายามทำ annotation บน PDF ที่สแกน (เป็นภาพ) ?
A: Annotation จะถูกเรนเดอร์เป็นวัตถุ overlay บนภาพของหน้า PDF นั้น ไม่ได้แก้ไขข้อมูล raster ด้านล่าง, ดังนั้น PDF จะยังคง searchable หากมีเลเยอร์ OCR อยู่.

Q: ฉันจะจัดการกับ PDF ขนาดใหญ่มากโดยไม่ให้หน่วยความจำหมดได้อย่างไร?
A: ประมวลผลเอกสารทีละหน้าโดยใช้ LoadOptions.PageNumbers, ทำลายอินสแตนซ์ Annotator ทันทีหลังใช้, และเปิดใช้งานการบันทึกแบบ streaming ไปยัง MemoryStream เพื่อหลีกเลี่ยงการเขียนไฟล์ชั่วคราวบนดิสก์.

การบูรณาการกับแอปพลิเคชัน ASP.NET

เมื่อคุณเปิดเผยฟังก์ชัน annotation ผ่าน Web API ให้ปฏิบัติตามรูปแบบต่อไปนี้:

  1. Controller รับสตรีม PDF จากไคลเอนต์.
  2. ตรวจสอบขนาดไฟล์ (ปฏิเสธไฟล์ > 200 MB หากไม่มีการจัดการพิเศษ).
  3. สร้าง Annotator ภายในบล็อก using เพื่อรับประกันการทำลาย.
  4. ใช้ annotation ตาม payload JSON ที่อธิบายประเภท, พิกัด, และข้อความ.
  5. บันทึกลงตำแหน่งชั่วคราว, แล้วสตรีมผลลัพธ์กลับไปยังไคลเอนต์พร้อมหัวข้อ Content‑Disposition ที่เหมาะสม.
[HttpPost("annotate")]
public async Task<IActionResult> Annotate(IFormFile pdf, [FromBody] AnnotationRequest request)
{
    using var stream = pdf.OpenReadStream();
    var annotator = new Annotator(stream);
    // add annotations based on request
    var output = new MemoryStream();
    annotator.Save(output);
    output.Position = 0;
    return File(output, "application/pdf", "annotated.pdf");
}

แหล่งข้อมูลเพิ่มเติม

สรุปและขั้นตอนต่อไป

คุณตอนนี้มี แผนที่ครบถ้วนสำหรับการสร้างระบบตรวจทานเอกสาร ด้วย GroupDocs.Annotation สำหรับ .NET. คุณได้เรียนรู้วิธีตั้งค่าไลบรารี, เพิ่ม area, ellipse และ text annotation, กรองการบันทึก, และรักษาการใช้หน่วยความจำให้ต่ำแม้กับ PDF ขนาดมหาศาล.

ขั้นตอนต่อไปที่คุณสามารถทำได้วันนี้:

  1. ทดลอง กับประเภท annotation เพิ่มเติมเช่น ArrowAnnotation และ StampAnnotation.
  2. บูรณาการ เวิร์กโฟลว์นี้เข้าสู่ ASP.NET Core API หรือแอปพลิเคชันเดสก์ท็อป WPF ของคุณ.
  3. สำรวจ เอกสาร API เต็มรูปแบบเพื่อค้นหาฟีเจอร์ขั้นสูงเช่น versioning ของ annotation และ metadata แบบกำหนดเอง.
  4. เข้าร่วม ฟอรั่มชุมชน GroupDocs เพื่อรับการสนับสนุนจากเพื่อนร่วมงานและอัปเดตข่าวสารเวอร์ชันใหม่.

อัปเดตล่าสุด: 2026-05-26
ทดสอบกับ: GroupDocs.Annotation 23.11 for .NET
ผู้เขียน: GroupDocs

Install-Package GroupDocs.Annotation -Version 25.4.0

dotnet add package GroupDocs.Annotation --version 25.4.0

using System;
using GroupDocs.Annotation;

class Program
{
    static void Main()
    {
        string inputPdfPath = "input.pdf";
        
        try
        {
            // Initialize the Annotator with the path of the document
            using (Annotator annotator = new Annotator(inputPdfPath))
            {
                Console.WriteLine("GroupDocs.Annotation initialized successfully!");
                // Your annotation code will go here
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Setup issue: {ex.Message}");
        }
    }
}

using (Annotator annotator = new Annotator(inputPdfPath))
{
    // All annotation work happens inside this using block
    // This ensures proper resource cleanup
}

AreaAnnotation areaAnnotation = new AreaAnnotation()
{
    Box = new Rectangle(100, 100, 100, 100), // X, Y, Width, Height
    BackgroundColor = 65535,                 // Yellow highlight
    PageNumber = 0                           // First page
};

EllipseAnnotation ellipseAnnotation = new EllipseAnnotation()
{
    Box = new Rectangle(100, 100, 100, 100), // Same coordinate system
    BackgroundColor = 123456,                // Different color
    PageNumber = 1                           // Second page
};

annotator.Add(new List<AnnotationBase>() { areaAnnotation, ellipseAnnotation });

SaveOptions saveOptions = new SaveOptions 
{
    AnnotationTypes = AnnotationType.Ellipse // Only save ellipse annotations
};

annotator.Save(outputPath, saveOptions);

using (Annotator annotator = new Annotator(inputPdfPath))
{
    // Your annotation code here
} // Automatic cleanup happens here

var annotationsToAdd = new List<AnnotationBase>();
// Add multiple annotations to the list
annotator.Add(annotationsToAdd); // Single operation

// Always verify file exists before processing
if (!File.Exists(inputPdfPath))
{
    throw new FileNotFoundException($"PDF file not found: {inputPdfPath}");
}

// Use absolute paths when possible
string absolutePath = Path.GetFullPath(inputPdfPath);

// Test with known coordinates first
AreaAnnotation testAnnotation = new AreaAnnotation()
{
    Box = new Rectangle(50, 50, 100, 100), // Start with simple values
    BackgroundColor = 65535,
    PageNumber = 0
};

// Verify page dimensions if needed
// Consider PDF scaling factors in your calculations

// Define color constants for consistency
public static class AnnotationColors
{
    public const int ImportantHighlight = 65535;    // Yellow
    public const int AttentionMarker = 255;         // Red
    public const int ApprovedSection = 65280;       // Green
}

try
{
    using (Annotator annotator = new Annotator(inputPdfPath))
    {
        // Your annotation operations
        annotator.Add(annotations);
        annotator.Save(outputPath, saveOptions);
    }
}
catch (GroupDocsException ex)
{
    // Handle GroupDocs-specific errors
    Logger.Error($"GroupDocs error: {ex.Message}");
}
catch (IOException ex)
{
    // Handle file I/O errors
    Logger.Error($"File operation error: {ex.Message}");
}
catch (Exception ex)
{
    // Handle unexpected errors
    Logger.Error($"Unexpected error: {ex.Message}");
}

[HttpPost]
public async Task<IActionResult> AnnotatePdf(IFormFile pdfFile, AnnotationRequest request)
{
    // Validate input
    if (pdfFile == null || pdfFile.Length == 0)
        return BadRequest("No file provided");

    // Process asynchronously to avoid blocking the UI
    var result = await ProcessAnnotationsAsync(pdfFile, request);
    return Ok(result);
}

บทเรียนที่เกี่ยวข้อง