डॉक्यूमेंट रिव्यू सिस्टम बनाएं: PDF एनोटेशन .NET गाइड

यदि आपको डॉक्यूमेंट रिव्यू सिस्टम बनाना है जो उपयोगकर्ताओं को .NET एप्लिकेशन से सीधे PDF में टिप्पणियाँ, हाइलाइट्स और आकार जोड़ने की अनुमति देता है, तो आप सही जगह पर आए हैं। GroupDocs.Annotation for .NET लो‑लेवल PDF हैंडलिंग की झंझट को दूर करता है और आपको प्रत्येक एनोटेशन प्रकार पर सूक्ष्म नियंत्रण देता है। इस गाइड में आप देखेंगे कि लाइब्रेरी कैसे सेटअप करें, एरिया, एलिप्स और टेक्स्ट एनोटेशन कैसे जोड़ें, क्या सेव किया जाए इसे कैसे फ़िल्टर करें, और कई‑सौ पेज वाली फ़ाइलों के साथ भी प्रदर्शन को तेज़ रखें।

त्वरित उत्तर

  • .NET में PDF एनोटेशन को संभालने वाली लाइब्रेरी कौन सी है? GroupDocs.Annotation for .NET.
  • क्या मैं हाइलाइट्स, सर्कल्स और टिप्पणियाँ प्रोग्रामेटिकली जोड़ सकता हूँ? हाँ – AreaAnnotation, EllipseAnnotation और TextAnnotation ऑब्जेक्ट्स का उपयोग करें।
  • क्या प्रोडक्शन के लिए लाइसेंस आवश्यक है? किसी भी प्रोडक्शन डिप्लॉयमेंट के लिए वैध GroupDocs लाइसेंस अनिवार्य है।
  • कितनी बड़ी PDF प्रोसेस की जा सकती है? 500 MB तक की फ़ाइलों को पूरी फ़ाइल को मेमोरी में लोड किए बिना संभाला जा सकता है।
  • क्या यह मुझे डॉक्यूमेंट रिव्यू सिस्टम बनाने में मदद करेगा? बिल्कुल – आप बैच‑सेव, फ़िल्टर और संस्करण एनोटेशन रिव्यूअर्स के लिए कर सकते हैं।

डॉक्यूमेंट रिव्यू सिस्टम क्या है?

एक डॉक्यूमेंट रिव्यू सिस्टम एक सॉफ़्टवेयर समाधान है जो कई स्टेकहोल्डर्स को समन्वित वर्कफ़्लो में PDF फ़ाइलों पर एनोटेट, टिप्पणी और अनुमोदन करने की अनुमति देता है। यह फीडबैक को केंद्रीकृत करता है, बदलावों को ट्रैक करता है, और अक्सर अंतिम अनुमोदन के लिए एक साफ़ संस्करण निर्यात करता है।

GroupDocs Annotation for .NET का उपयोग करके डॉक्यूमेंट रिव्यू सिस्टम क्यों बनाएं?

GroupDocs Annotation 30+ एनोटेशन प्रकार का समर्थन करता है, 500 MB तक के PDF को प्रोसेस करता है, और .NET Framework 4.6.1+, .NET Core 2.0+, तथा .NET 6+ पर चलता है। इसका API आपको PDF की आंतरिक संरचना को छुए बिना एनोटेशन जोड़ने, हटाने और फ़िल्टर करने की सुविधा देता है, जिससे विकास तेज़ होता है और बग कम होते हैं।

पूर्वापेक्षाएँ और पर्यावरण सेटअप

कोड लिखने से पहले सुनिश्चित करें कि आपका विकास पर्यावरण निम्न मानदंडों को पूरा करता है:

  • IDE: Visual Studio 2019 या नया, या C# एक्सटेंशन के साथ VS Code।
  • टार्गेट फ्रेमवर्क: .NET Framework 4.6.1 + या .NET Core 2.0 + (नए प्रोजेक्ट्स के लिए .NET 6 की सलाह देते हैं)।
  • NuGet एक्सेस: nuget.org से पैकेज इंस्टॉल करने की क्षमता।
  • सैंपल PDFs: परीक्षण के लिए कम से कम एक मल्टी‑पेज PDF।
  • मेमोरी एवं डिस्क: न्यूनतम 4 GB RAM और अस्थायी फ़ाइलों के लिए पर्याप्त खाली डिस्क स्पेस (एनोटेशन प्रोसेसिंग अस्थायी स्ट्रीम बना सकता है)।

अनुशंसित विकास प्रथाएँ

  • अपने सॉल्यूशन को स्रोत नियंत्रण (Git) में रखें ताकि आप एनोटेशन‑संबंधित बदलावों को रोल बैक कर सकें।
  • प्रोजेक्ट में एक समर्पित Annotations फ़ोल्डर बनाकर कॉन्फ़िगरेशन फ़ाइलें और लाइसेंस कुंजियाँ रखें।
  • nullable reference types (<Nullable>enable</Nullable>) को सक्षम करें ताकि संभावित null‑reference बग जल्दी पकड़े जा सकें।

शुरूआत: GroupDocs.Annotation इंस्टॉलेशन

इंस्टॉलेशन विधियाँ

विकल्प 1: NuGet पैकेज मैनेजर कंसोल
Package Manager Console में निम्न कमांड चलाएँ:

Install-Package GroupDocs.Annotation

विकल्प 2: .NET CLI (क्रॉस‑प्लेटफ़ॉर्म विकास के लिए अनुशंसित)
टर्मिनल में निष्पादित करें:

dotnet add package GroupDocs.Annotation

विकल्प 3: Visual Studio पैकेज मैनेजर UI

  • प्रोजेक्ट पर राइट‑क्लिक → Manage NuGet Packages
  • GroupDocs.Annotation खोजें
  • नवीनतम स्थिर रिलीज़ पर Install क्लिक करें

तीनों विधियों से समान बाइनरी इंस्टॉल होता है; वह चुनें जो आपके वर्कफ़्लो से मेल खाता हो।

लाइसेंस कॉन्फ़िगरेशन

GroupDocs किसी भी प्रोडक्शन उपयोग के लिए वैध लाइसेंस की आवश्यकता रखता है। आपके पास तीन विकल्प हैं:

  • फ्री ट्रायल: पूर्ण फीचर सेट के साथ 30‑दिन मूल्यांकन।
  • टेम्पररी लाइसेंस: विकास और परीक्षण के लिए विस्तारित मूल्यांकन।
  • कमर्शियल लाइसेंस: प्रोडक्शन वातावरण में असीमित उपयोग।

License क्लास 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 code block जोड़ने की आवश्यकता नहीं है, लेकिन इनलाइन स्निपेट में सटीक API उपयोग दिखाया गया है।

यदि आप पेज काउंट प्रिंट होते देखते हैं, तो वास्तविक एनोटेशन जोड़ने के लिए तैयार हैं।

कोर इम्प्लीमेंटेशन: PDFs में एनोटेशन जोड़ना

परिभाषा एंकर – Annotator

Annotator क्लास GroupDocs.Annotation for .NET में सभी PDF एनोटेशन ऑपरेशन्स का एंट्री पॉइंट है। यह PDF को मेमोरी में लोड करता है, एनोटेशन जोड़ने, संपादित करने और प्राप्त करने के मेथड्स प्रदान करता है, और संशोधित दस्तावेज़ को सेव करने का कार्य संभालता है।

एरिया और एलिप्स एनोटेशन कैसे जोड़ें?

new Annotator(...) से PDF लोड करें, AreaAnnotation और EllipseAnnotation ऑब्जेक्ट्स बनाएं, उनके कोऑर्डिनेट सेट करें, और उन्हें annotator की कलेक्शन में जोड़ें। अंत में Save कॉल करके बदलाव सहेजें। यह वर्कफ़्लो आपको प्रोग्रामेटिकली सेक्शन (एरिया) हाइलाइट करने या महत्वपूर्ण ग्राफ़िक्स को सर्कल करने की अनुमति देता है, वह भी एक ही एटॉमिक ऑपरेशन में।

चरण 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 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: बैच में एनोटेशन जोड़ें

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

प्रो टिप: एनोटेशन को एक लिस्ट में इकट्ठा करके एक बार Add कॉल करने से I/O ओवरहेड कम होता है, विशेषकर जब कई पेजों में दर्जनों मार्क्स डालने हों।

चयनात्मक एनोटेशन कैसे सेव करें?

SaveOptions निर्धारित करता है कि एनोटेटेड PDF कैसे सेव किया जाए, जिसमें कौन‑से एनोटेशन प्रकार शामिल हों। GroupDocs.Annotation आपको आउटपुट फ़ाइल में लिखे जाने वाले एनोटेशन प्रकारों को फ़िल्टर करने की सुविधा देता है। एक SaveOptions इंस्टेंस बनाएं, AnnotationTypes कलेक्शन को इच्छित प्रकारों पर सेट करें, और इसे Save को पास करें। यह रिव्यूअर‑केवल PDFs बनाने या आर्काइव करने से पहले अस्थायी नोट्स हटाने के लिए आदर्श है।

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

वास्तविक‑दुनिया इम्प्लीमेंटेशन परिदृश्य

परिदृश्य 1: डॉक्यूमेंट रिव्यू वर्कफ़्लो

कई रिव्यूअर Area, Ellipse, और Text एनोटेशन जोड़ते हैं। रिव्यू राउंड के बाद आप तीन PDFs जनरेट करते हैं:

  1. हर टिप्पणी के साथ पूर्ण संस्करण।
  2. रिव्यूअर‑केवल संस्करण (आंतरिक नोट्स फ़िल्टर किए गए)।
  3. अंतिम अनुमोदन के लिए क्लीन संस्करण (सिर्फ हाइलाइट्स रखता है)।

परिदृश्य 2: ऑटोमेटेड रिपोर्ट जेनरेशन

आपका बैकएंड दैनिक बिक्री रिपोर्ट प्रोसेस करता है, प्रमुख मीट्रिक्स को एरिया एनोटेशन से हाइलाइट करता है और आउट्लायर चार्ट्स को एलिप्स एनोटेशन से सर्कल करता है। उत्पन्न PDFs फिर बिना मैनुअल हस्तक्षेप के स्टेकहोल्डर्स को ईमेल किए जाते हैं।

परिदृश्य 3: सहयोगी कानूनी दस्तावेज़

कानूनी फर्मों को अक्सर पार्टनर कमेंट्स को जूनियर एसोसिएट नोट्स से अलग करना पड़ता है। कस्टम मेटाडेटा के साथ एनोटेशन टैग करके और चयनात्मक सेविंग का उपयोग करके आप एक पार्टनर‑रिव्यू PDF बना सकते हैं जो जूनियर टिप्पणी को छुपाता है, जिससे संस्करण नियंत्रण सरल हो जाता है।

प्रोडक्शन उपयोग के लिए प्रदर्शन अनुकूलन

बड़े PDFs में एनोटेशन करते समय मेमोरी कैसे मैनेज करें?

LoadOptions आपको PDF लोड करने का तरीका निर्दिष्ट करने देता है, जैसे पेज रेंज या पासवर्ड। जब PDF 100 MB से बड़ी हो, तो पूरे फ़ाइल को लोड करने से बचें और LoadOptions कंस्ट्रक्टर का उपयोग करें जो पेज रेंज स्वीकार करता है। पेजों को बैच में प्रोसेस करें, प्रत्येक Annotator इंस्टेंस को using ब्लॉक में डिस्पोज़ करें, और प्रत्येक बैच के बाद अस्थायी फ़ाइलें साफ़ करें। यह तरीका 500‑पेज दस्तावेज़ के लिए भी पीक मेमोरी उपयोग को 200 MB से नीचे रखता है।

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

मेमोरी मैनेजमेंट बेस्ट प्रैक्टिसेज

  • हमेशा Annotator को using स्टेटमेंट में रैप करें ताकि अनमैनेज्ड रिसोर्सेज़ का निपटारा सुनिश्चित हो।
  • बैच‑प्रोसेस एनोटेशन: दस्तावेज़ के सभी एनोटेशन इकट्ठा करें, फिर एक बार Add कॉल करें।
  • पूरा PDF लोड न करें जब केवल कुछ पेजों को संशोधित करना हो; LoadOptions.PageNumbers का उपयोग करें।

बड़े फ़ाइल हैंडलिंग रणनीतियाँ

  1. पेज‑वाइज प्रोसेसिंग – एक समय में एक पेज लोड, एनोटेट और सेव करें।
  2. स्ट्रीमिंग आउटपुट – Save मेथड को MemoryStream की ओर निर्देशित करें ताकि मध्यवर्ती डिस्क राइट्स से बचा जा सके।
  3. अस्थायी फ़ाइल क्लीनअप – प्रत्येक ऑपरेशन के बाद annotator द्वारा बनाई गई अस्थायी फ़ाइलें हटाएँ।

समवर्ती प्रोसेसिंग विचार

  • थ्रेड सुरक्षा: Annotator इंस्टेंस थ्रेड‑सेफ़ नहीं हैं। प्रत्येक थ्रेड के लिए अलग इंस्टेंस बनाएँ।
  • रिसोर्स थ्रॉटलिंग: CPU को ओवरलोड न करने के लिए समवर्ती जॉब्स को CPU कोर की संख्या तक सीमित रखें।
  • Async API: SaveAsync एनोटेटेड दस्तावेज़ को असिंक्रोनसली सेव करता है और एक Task रिटर्न करता है, जो ASP.NET Core वातावरण में उपयोगी है।

सामान्य समस्याओं का निवारण

समस्या 1: “File Not Found” त्रुटियाँ

सीधा उत्तर: सुनिश्चित करें कि आप new Annotator(...) में जो फ़ाइल पाथ पास कर रहे हैं वह absolute है या निष्पादित असेंबली के सापेक्ष सही है, और एप्लिकेशन प्रोसेस को उस लोकेशन पर पढ़ने की अनुमति है। यदि फ़ाइल नेटवर्क शेयर में है, तो शेयर को मैप करें या UNC पाथ का उपयोग करें।

आम समाधान:

  • Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Docs", "sample.pdf") का उपयोग करें।
  • IIS एप्लिकेशन पूल आइडेंटिटी को फ़ोल्डर पर पढ़ने/लिखने की अनुमति दें।

समस्या 2: एनोटेशन गलत स्थान पर दिख रहे हैं

सीधा उत्तर: सुनिश्चित करें कि आप समान कोऑर्डिनेट सिस्टम (टॉप‑लेफ़्ट ओरिजिन) का उपयोग कर रहे हैं और पेज का DPI आपके द्वारा प्रदान किए गए मानों से मेल खाता है। annotator.GetPageInfo(pageNumber) से पेज साइज प्राप्त करें और कोऑर्डिनेट्स को उसी साइज के सापेक्ष गणना करें।

आम समाधान:

  • यदि PDF गैर‑मानक DPI के साथ बना है तो कोऑर्डिनेट्स को पेज के स्केलिंग फैक्टर से गुणा करें।
  • यह दोबारा जाँचें कि आप पॉइंट्स (1/72 इंच) को पिक्सेल के साथ नहीं मिला रहे हैं।

समस्या 3: बड़े फ़ाइलों में प्रदर्शन समस्याएँ

सीधा उत्तर: पेज‑रेंज लोडिंग पर स्विच करें, एनोटेशन को बैच में प्रोसेस करें, और प्रत्येक Annotator इंस्टेंस को तुरंत डिस्पोज़ करें। साथ ही LoadOptions में MemoryCache विकल्प को सक्षम करें ताकि बफ़र्स को ऑपरेशन्स के बीच पुनः उपयोग किया जा सके।

आम समाधान:

  • LoadOptions.UseMemoryCache = true सेट करें।
  • await annotator.SaveAsync(...) के साथ फ़ाइलों को असिंक्रोनसली प्रोसेस करें।

समस्या 4: लाइसेंस‑संबंधी त्रुटियाँ

सीधा उत्तर: .lic फ़ाइल को ऐसे फ़ोल्डर में रखें जिसे एप्लिकेशन पढ़ सके, और किसी भी अन्य GroupDocs कॉल से पहले License license = new License(); license.SetLicense("path/to/license.lic"); को कॉल करें। लाइसेंस संस्करण को उपयोग में लाई जा रही लाइब्रेरी संस्करण से मिलाएँ।

आम समाधान:

  • लाइसेंस फ़ाइल भ्रष्ट नहीं है (फ़ाइल आकार की तुलना करें)।
  • सुनिश्चित करें कि आप एक ही पर्यावरण में ट्रायल लाइसेंस और कमर्शियल लाइसेंस दोनों का मिश्रण नहीं कर रहे हैं।

उन्नत टिप्स और बेस्ट प्रैक्टिसेज

रंग प्रबंधन

सुसंगत रंग रिव्यूअर्स की पढ़ने की क्षमता को बढ़ाते हैं। एक पैलेट परिभाषित करें (जैसे हाइलाइट्स के लिए Yellow, गंभीर मुद्दों के लिए Red) और उसे एक स्थैतिक हेल्पर क्लास में रखें। एक्सेसिबिलिटी के लिए हाई‑कॉन्ट्रास्ट रंगों का उपयोग करें और रेफ़रेंस के लिए PDF में एक लेजेंड पेज जोड़ें।

एरर हैंडलिंग पैटर्न

सभी एनोटेशन कॉल को try‑catch ब्लॉक्स में रैप करें जो विशेष रूप से GroupDocs.Annotation.Exceptions.AnnotationException को कैच करे। अपवाद संदेश, स्टैक ट्रेस और PDF नाम को लॉग करें ताकि डिबगिंग आसान हो।

टेस्टिंग रणनीतियाँ

  • यूनिट टेस्ट: ज्ञात डाइमेंशन वाली छोटी PDF में एनोटेशन जोड़ें और सत्यापित करें कि GetAnnotations() अपेक्षित कोऑर्डिनेट्स लौटाता है।
  • इंटीग्रेशन टेस्ट: 1 पेज से 200 पेज तक की PDFs पर पूर्ण वर्कफ़्लो चलाएँ, और 50 MB से कम फ़ाइलों के लिए प्रोसेसिंग समय 5 सेकंड से कम रखें।
  • लोड टेस्ट: k6 या Apache JMeter जैसे टूल से 50 समवर्ती एनोटेशन अनुरोधों का सिमुलेशन करें और CPU/मेमोरी की निगरानी करें।

अक्सर पूछे जाने वाले प्रश्न

प्र.: विभिन्न पेज साइज वाली PDFs को कैसे हैंडल करें?
उ.: GroupDocs प्रत्येक पेज की डाइमेंशन स्वचालित रूप से पढ़ता है। एनोटेशन पोजिशन करते समय हमेशा annotator.GetPageInfo(pageNumber) को क्वेरी करें और कोऑर्डिनेट्स को उस पेज की चौड़ाई और ऊँचाई के आधार पर गणना करें।

प्र.: क्या पासवर्ड‑प्रोटेक्टेड PDFs को एनोटेट किया जा सकता है?
उ.: हाँ। LoadOptions कंस्ट्रक्टर में पासवर्ड स्ट्रिंग पास करें, उदाहरण: new LoadOptions { Password = "secret" }, और इसे Annotator कंस्ट्रक्टर में दें।

प्र.: एक ही PDF में अधिकतम कितने एनोटेशन जोड़े जा सकते हैं?
उ.: कोई कठोर सीमा नहीं है, लेकिन कुछ हजार एनोटेशन के बाद प्रदर्शन घट सकता है। बहुत बड़े सेट के लिए उन्हें तर्कसंगत सेक्शन में बाँटें और प्रत्येक सेक्शन को अलग‑अलग प्रोसेस करें।

प्र.: विशिष्ट एनोटेशन को प्रोग्रामेटिकली कैसे हटाएँ?
उ.: GetAnnotations() से एनोटेशन का Id प्राप्त करें, फिर Delete(id) कॉल करें या एक SaveOptions बनाकर अनचाहे AnnotationType को बाहर रखें।

प्र.: क्या रंगों के अलावा एनोटेशन की उपस्थिति को कस्टमाइज़ किया जा सकता है?
उ.: बिल्कुल। आप अपारदर्शिता, बॉर्डर थिकनेस, डैश स्टाइल सेट कर सकते हैं, और स्टैम्प एनोटेशन के लिए कस्टम SVG आइकन भी एम्बेड कर सकते हैं।

प्र.: स्कैन किए गए (इमेज‑बेस्ड) PDF को एनोटेट करने पर क्या होता है?
उ.: एनोटेशन पेज इमेज के ऊपर ओवरले ऑब्जेक्ट के रूप में रेंडर होते हैं। वे रास्टर डेटा को संशोधित नहीं करते, इसलिए यदि OCR लेयर मौजूद है तो PDF अभी भी सर्चेबल रहता है।

प्र.: बहुत बड़ी PDFs को मेमोरी खत्म हुए बिना कैसे हैंडल करें?
उ.: LoadOptions.PageNumbers के साथ पेज‑बाय‑पेज प्रोसेस करें, प्रत्येक Annotator इंस्टेंस को तुरंत डिस्पोज़ करें, और डिस्क स्पाइक से बचने के लिए MemoryStream में स्ट्रीमिंग सेव का उपयोग करें।

ASP.NET एप्लिकेशनों के साथ इंटीग्रेशन

जब आप वेब API के माध्यम से एनोटेशन फ़ंक्शनैलिटी एक्सपोज़ करते हैं, तो निम्न पैटर्न अपनाएँ:

  1. कंट्रोलर क्लाइंट से PDF स्ट्रीम प्राप्त करता है।
  2. फ़ाइल साइज वैलिडेट करें (200 MB से अधिक फ़ाइलों को विशेष हैंडलिंग के बिना रेजेक्ट करें)।
  3. using ब्लॉक में Annotator इंस्टेंस बनाएं ताकि डिस्पोज़ सुनिश्चित हो।
  4. 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 for .NET द्वारा संचालित डॉक्यूमेंट रिव्यू सिस्टम बनाने के लिए एक पूर्ण, प्रोडक्शन‑रेडी रोडमैप है। आपने लाइब्रेरी सेटअप, एरिया, एलिप्स और टेक्स्ट एनोटेशन जोड़ना, सेविंग फ़िल्टर करना, और बड़े PDFs के साथ मेमोरी उपयोग कम रखना सीखा।

आज आप जो अगले कदम उठा सकते हैं:

  1. प्रयोग करें अतिरिक्त एनोटेशन प्रकार जैसे ArrowAnnotation और StampAnnotation के साथ।
  2. वर्कफ़्लो को अपने मौजूदा ASP.NET Core API या डेस्कटॉप WPF एप्लिकेशन में इंटीग्रेट करें।
  3. पूरा API रेफ़रेंस एक्सप्लोर करें ताकि एनोटेशन वर्ज़निंग और कस्टम मेटाडेटा जैसी उन्नत सुविधाओं को खोज सकें।
  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);
}

संबंधित ट्यूटोरियल