c# pdf पेज काउंट – GroupDocs.Annotation के साथ दस्तावेज़ जानकारी निकालें

परिचय

क्या आपने कभी दस्तावेज़ों के ढेर को देखते हुए सोचा है कि उनमें वास्तव में क्या है, बिना प्रत्येक को खोले? आप इस संघर्ष में अकेले नहीं हैं। चाहे आप एक दस्तावेज़ प्रबंधन प्रणाली बना रहे हों, कानूनी फ़ाइलों को प्रोसेस कर रहे हों, या बस अपनी कंपनी की डिजिटल संपत्तियों को व्यवस्थित करने की कोशिश कर रहे हों, C# में दस्तावेज़ जानकारी निकालना—जिसमें c# pdf पेज काउंट भी शामिल है—एक वास्तविक गेम‑चेंजर हो सकता है।

फ़ाइल गुणों को मैन्युअल रूप से जांचना समय‑साध्य और त्रुटिप्रवण है। GroupDocs.Annotation for .NET के साथ, आप इस पूरी प्रक्रिया को स्वचालित कर सकते हैं और फ़ाइल प्रकार, पेज काउंट, दस्तावेज़ आकार, और अधिक को केवल कुछ पंक्तियों के कोड में प्राप्त कर सकते हैं। यह ट्यूटोरियल आपको बताता है कि यह क्यों महत्वपूर्ण है, लाइब्रेरी कैसे सेटअप करें, और बॉक्स से बाहर काम करने वाला चरण‑दर‑चरण कोड।

त्वरित उत्तर

  • GroupDocs.Annotation क्या निकालता है? फ़ाइल प्रकार, पेज काउंट, आकार, और बुनियादी मेटाडेटा।
  • कितने फ़ॉर्मेट समर्थित हैं? 50 से अधिक इनपुट और आउटपुट फ़ॉर्मेट, जिसमें PDF, DOCX, XLSX, PPTX, और सामान्य इमेज प्रकार शामिल हैं।
  • क्या मैं पूरे फ़ाइल को लोड किए बिना c# pdf पेज काउंट प्राप्त कर सकता हूँ? हाँ—GetDocumentInfo() केवल पेज काउंट के लिए आवश्यक हेडर जानकारी पढ़ता है।
  • क्या विकास के लिए लाइसेंस चाहिए? परीक्षण के लिए एक मुफ्त ट्रायल काम करता है; उत्पादन के लिए पूर्ण लाइसेंस आवश्यक है।
  • क्या API वेब ऐप्स के लिए थ्रेड‑सेफ़ है? बिल्कुल—सिर्फ Annotator इंस्टेंस को सही ढंग से डिस्पोज़ करें।

c# pdf पेज काउंट क्या है?

c# pdf पेज काउंट वह कुल पेजों की संख्या है जो एक PDF फ़ाइल द्वारा API के माध्यम से पूछे जाने पर रिपोर्ट की जाती है। GroupDocs.Annotation का उपयोग करके, आप इस मान को तुरंत GetDocumentInfo() मेथड के द्वारा प्राप्त करते हैं बिना पूरे दस्तावेज़ को रेंडर किए। यह काउंट PDF की आंतरिक संरचना से निकाला जाता है, जिससे आप प्रोसेसिंग, स्टोरेज, या डिस्प्ले के बारे में फ़ाइल को व्यूअर में खोले बिना निर्णय ले सकते हैं। यह विशेष रूप से बैच वैलिडेशन, अनुपालन जांच, और UI प्रीव्यू में उपयोगी है जहाँ पेज सीमाएँ महत्वपूर्ण होती हैं।

GroupDocs.Annotation के साथ दस्तावेज़ जानकारी क्यों निकालें?

GroupDocs.Annotation 50+ दस्तावेज़ फ़ॉर्मेट का समर्थन करता है और कई‑सौ‑पेज वाली फ़ाइलों को पूरी फ़ाइल को मेमोरी में लोड किए बिना प्रोसेस कर सकता है, सामान्य सर्वर पर 200 ms से कम समय में मेटाडेटा प्रदान करता है। यह गति और फ़ॉर्मेट विविधता इसे बड़े‑पैमाने पर ऑटोमेशन, अनुपालन जांच, और इंटेलिजेंट कंटेंट क्लासिफिकेशन के लिए आदर्श बनाती है।

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

आपको क्या चाहिए

  • Visual Studio 2019 या बाद का (Community संस्करण ठीक काम करता है)
  • .NET Framework 4.6.1+ या .NET Core 2.0+
  • बुनियादी C# ज्ञान और NuGet की परिचितता

GroupDocs.Annotation स्थापित करना

लाइब्रेरी को अपने प्रोजेक्ट में जोड़ना सरल है। अपनी पसंद का तरीका चुनें:

विकल्प 1: पैकेज मैनेजर कंसोल (सिफ़ारिश किया गया)

Install-Package GroupDocs.Annotation -Version 25.4.0

विकल्प 2: .NET CLI

dotnet add package GroupDocs.Annotation --version 25.4.0

विकल्प 3: पैकेज मैनेजर UI
यदि आप टाइप करने के बजाय क्लिक करना पसंद करते हैं, तो NuGet पैकेज मैनेजर UI में “GroupDocs.Annotation” खोजें और नवीनतम संस्करण स्थापित करें।

अपना लाइसेंस प्राप्त करना

  1. फ़्री ट्रायल से शुरू करें: GroupDocs वेबसाइट से डाउनलोड करें – कोई शर्त नहीं।
  2. और समय चाहिए? विस्तारित मूल्यांकन के लिए एक अस्थायी लाइसेंस प्राप्त करें।
  3. लाइव जाने के लिए तैयार? जब आप डिप्लॉय करने के लिए तैयार हों, तो पूर्ण लाइसेंस खरीदें।

प्रो टिप: फ़्री ट्रायल में वॉटरमार्क शामिल हैं, लेकिन यह आपके कोड को सीखने और परीक्षण करने के लिए बिल्कुल उपयुक्त है।

नवीनतम बदलावों के लिए, देखें रिलीज़ नोट्स।

GroupDocs.Annotation के साथ c# pdf पेज काउंट कैसे प्राप्त करें?

Annotator मुख्य क्लास है जो दस्तावेज़ लोड करता है और एनोटेशन व मेटाडेटा फ़ंक्शन प्रदान करता है।
new Annotator("file.pdf") से अपना PDF लोड करें और GetDocumentInfo() कॉल करें – PageCount प्रॉपर्टी केवल दो पंक्तियों के कोड में सटीक पेज संख्या लौटाती है। GetDocumentInfo() एक DocumentInfo ऑब्जेक्ट लौटाता है जिसमें पेज काउंट, फ़ाइल प्रकार, और आकार जैसी मेटाडेटा होती है। यह मेथड केवल आवश्यक हेडर डेटा पढ़ता है, इसलिए बड़े PDFs भी कुशलता से संभाले जाते हैं।

बुनियादी सेटअप और दस्तावेज़ लोडिंग

using System;
using GroupDocs.Annotation;

class Program
{
    static void Main(string[] args)
    {
        // Initialize the annotator with a document path
        using (Annotator annotator = new Annotator("YOUR_DOCUMENT_DIRECTORY/input.pdf"))
        {
            Console.WriteLine("Document loaded successfully!");
            // We'll add the extraction code here next
        }
    }
}

दस्तावेज़ मेटाडेटा निकालना

DocumentInfo फ़ाइल की निकाली गई प्रॉपर्टीज़ को संलग्न करता है, जिससे उन्हें आपके एप्लिकेशन में पढ़ना और उपयोग करना आसान हो जाता है।

using (Annotator annotator = new Annotator("YOUR_DOCUMENT_DIRECTORY/input.pdf"))
{
    // Extract document info
    IDocumentInfo info = annotator.Document.GetDocumentInfo();
    
    // Always check if info was retrieved successfully
    if (info == null || info.PageCount == 0)
    {
        throw new Exception("Unexpected document information!");
    }

    // Display the extracted information
    Console.WriteLine($"\
File type: {info.FileType}\
Number of pages: {info.PageCount}\
Document size: {info.Size} bytes.");
    
    // Convert size to more readable format
    string readableSize = FormatFileSize(info.Size);
    Console.WriteLine($"Document size (formatted): {readableSize}");
}

// Helper method to format file size
static string FormatFileSize(long bytes)
{
    string[] suffixes = { "B", "KB", "MB", "GB", "TB" };
    int counter = 0;
    decimal number = bytes;
    
    while (Math.Round(number / 1024) >= 1)
    {
        number /= 1024;
        counter++;
    }
    
    return string.Format("{0:n1}{1}", number, suffixes[counter]);
}

उन्नत जानकारी प्रदर्शन

यदि आपको अधिक संदर्भ चाहिए—जैसे कि दस्तावेज़ आकार सीमा से अधिक है या नहीं—तो आप बुनियादी उदाहरण को अतिरिक्त जांच और बिजनेस लॉजिक के साथ विस्तारित कर सकते हैं।

using (Annotator annotator = new Annotator("YOUR_DOCUMENT_DIRECTORY/input.pdf"))
{
    IDocumentInfo info = annotator.Document.GetDocumentInfo();
    
    if (info == null)
    {
        Console.WriteLine("Could not retrieve document information.");
        return;
    }

    // Comprehensive info display
    Console.WriteLine("=== Document Information ===");
    Console.WriteLine($"File Type: {info.FileType}");
    Console.WriteLine($"Page Count: {info.PageCount}");
    Console.WriteLine($"Size: {FormatFileSize(info.Size)}");
    
    // Additional checks you might want to perform
    if (info.PageCount > 100)
    {
        Console.WriteLine("⚠️  Large document detected - consider batch processing");
    }
    
    if (info.Size > 10 * 1024 * 1024) // 10MB
    {
        Console.WriteLine("⚠️  Large file size - may impact processing time");
    }
    
    Console.WriteLine("=== Analysis Complete ===");
}

सामान्य समस्याएँ और समाधान

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

सीधा उत्तर: सुनिश्चित करें कि फ़ाइल पाथ पूर्ण (absolute) है या एप्लिकेशन बेस डायरेक्टरी से सही तरीके से रूटेड है, और प्रक्रिया के पास पढ़ने की अनुमति है।

string documentPath = @"C:\Documents\test.pdf";

// Always check if file exists first
if (!File.Exists(documentPath))
{
    Console.WriteLine($"File not found: {documentPath}");
    return;
}

try
{
    using (Annotator annotator = new Annotator(documentPath))
    {
        // Your code here
    }
}
catch (Exception ex)
{
    Console.WriteLine($"Error loading document: {ex.Message}");
}

समस्या 2: असमर्थित फ़ाइल फ़ॉर्मेट

सीधा उत्तर: पुष्टि करें कि फ़ाइल का एक्सटेंशन 50+ समर्थित फ़ॉर्मेट में से एक से मेल खाता है; यदि नहीं, तो GetDocumentInfo() कॉल करने से पहले इसे समर्थित प्रकार में परिवर्तित करें।

try
{
    using (Annotator annotator = new Annotator(documentPath))
    {
        IDocumentInfo info = annotator.Document.GetDocumentInfo();
        
        if (info == null)
        {
            Console.WriteLine("Unsupported file format or corrupted document");
            return;
        }
        
        // Process the info
    }
}
catch (UnsupportedFileTypeException ex)
{
    Console.WriteLine($"File type not supported: {ex.Message}");
}

समस्या 3: बड़े दस्तावेज़ों में मेमोरी समस्याएँ

सीधा उत्तर: लोड करने से पहले आकार जांच लागू करें और using स्टेटमेंट का उपयोग करके Annotator इंस्टेंस को सुनिश्चित रूप से डिस्पोज़ करें, जिससे मेमोरी लीक रोकें।

const long MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB limit

FileInfo fileInfo = new FileInfo(documentPath);
if (fileInfo.Length > MAX_FILE_SIZE)
{
    Console.WriteLine("File too large for processing");
    return;
}

// Use proper disposal patterns
using (Annotator annotator = new Annotator(documentPath))
{
    // Process quickly and dispose
    IDocumentInfo info = annotator.Document.GetDocumentInfo();
    // Handle info immediately
}
// Annotator is automatically disposed here

वास्तविक‑दुनिया उपयोग केस

दस्तावेज़ प्रबंधन प्रणाली एकीकरण

जब उपयोगकर्ता फ़ाइल अपलोड करता है, तो पहले उसकी मेटाडेटा निकालें ताकि स्टोरेज लोकेशन, इंडेक्सिंग रणनीति, या आवश्यक अनुमोदन वर्कफ़्लो तय किया जा सके।

public class DocumentProcessor
{
    public DocumentMetadata ProcessUpload(string filePath)
    {
        using (Annotator annotator = new Annotator(filePath))
        {
            IDocumentInfo info = annotator.Document.GetDocumentInfo();
            
            return new DocumentMetadata
            {
                FileName = Path.GetFileName(filePath),
                FileType = info.FileType.ToString(),
                PageCount = info.PageCount,
                FileSizeBytes = info.Size,
                ProcessedDate = DateTime.UtcNow,
                Category = DetermineCategory(info)
            };
        }
    }
    
    private string DetermineCategory(IDocumentInfo info)
    {
        // Business logic for automatic categorization
        if (info.FileType.ToString().Contains("Pdf"))
        {
            return info.PageCount > 20 ? "Legal Document" : "Standard Document";
        }
        
        return "Other";
    }
}

बैच दस्तावेज़ विश्लेषण

फ़ाइलों के फ़ोल्डर को बैकग्राउंड जॉब में प्रोसेस करें, प्रत्येक दस्तावेज़ के पेज काउंट और प्रकार को रिपोर्टिंग के लिए लॉग करें।

public void AnalyzeDocumentFolder(string folderPath)
{
    string[] supportedExtensions = { ".pdf", ".docx", ".xlsx", ".pptx" };
    
    foreach (string file in Directory.GetFiles(folderPath))
    {
        if (!supportedExtensions.Contains(Path.GetExtension(file).ToLower()))
            continue;
            
        try
        {
            using (Annotator annotator = new Annotator(file))
            {
                IDocumentInfo info = annotator.Document.GetDocumentInfo();
                Console.WriteLine($"{Path.GetFileName(file)}: {info.FileType}, {info.PageCount} pages");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Failed to process {file}: {ex.Message}");
        }
    }
}

अनुपालन और वैधता

नियमनित उद्योगों को अक्सर दस्तावेज़ों को एक निश्चित पेज काउंट या आकार से नीचे रखना पड़ता है। निकाली गई मेटाडेटा का उपयोग करके गैर‑अनुपालन अपलोड को स्वचालित रूप से अस्वीकार करें।

public bool ValidateDocument(string filePath, DocumentRequirements requirements)
{
    using (Annotator annotator = new Annotator(filePath))
    {
        IDocumentInfo info = annotator.Document.GetDocumentInfo();
        
        // Check file type
        if (requirements.AllowedTypes != null && 
            !requirements.AllowedTypes.Contains(info.FileType.ToString()))
        {
            return false;
        }
        
        // Check page count limits
        if (info.PageCount < requirements.MinPages || 
            info.PageCount > requirements.MaxPages)
        {
            return false;
        }
        
        // Check file size
        if (info.Size > requirements.MaxSizeBytes)
        {
            return false;
        }
        
        return true;
    }
}

प्रदर्शन अनुकूलन टिप्स

1. कैशिंग लागू करें

बार-बार एक्सेस की जाने वाली फ़ाइलों के लिए DocumentInfo परिणामों को कैश करें ताकि दोहराए गए I/O ऑपरेशन्स से बचा जा सके।

private static readonly Dictionary<string, IDocumentInfo> _infoCache = 
    new Dictionary<string, IDocumentInfo>();

public IDocumentInfo GetDocumentInfoCached(string filePath)
{
    string fileHash = GetFileHash(filePath);
    
    if (_infoCache.ContainsKey(fileHash))
    {
        return _infoCache[fileHash];
    }
    
    using (Annotator annotator = new Annotator(filePath))
    {
        IDocumentInfo info = annotator.Document.GetDocumentInfo();
        _infoCache[fileHash] = info;
        return info;
    }
}

2. कई दस्तावेज़ों के लिए असिंक्रोनस प्रोसेसिंग का उपयोग करें

Task.Run या async streams का उपयोग करके कई फ़ाइलों को एक साथ प्रोसेस करें बिना मुख्य थ्रेड को ब्लॉक किए।

public async Task<List<DocumentMetadata>> ProcessDocumentsAsync(string[] filePaths)
{
    var tasks = filePaths.Select(async path =>
    {
        return await Task.Run(() =>
        {
            using (Annotator annotator = new Annotator(path))
            {
                IDocumentInfo info = annotator.Document.GetDocumentInfo();
                return new DocumentMetadata(path, info);
            }
        });
    });
    
    return (await Task.WhenAll(tasks)).ToList();
}

3. मेमोरी प्रबंधन सर्वोत्तम अभ्यास

  • हमेशा Annotator को using ब्लॉक में रखें।
  • दस्तावेज़ों को बैच में प्रोसेस करें, एक साथ नहीं।
  • 100 MB से बड़ी फ़ाइलों के लिए, पहले फ़ाइल को डिस्क पर स्ट्रीम करने पर विचार करें और फिर मेटाडेटा पढ़ें।

समस्या निवारण गाइड

लाइसेंस‑संबंधी समस्याएँ

License वह ऑब्जेक्ट है जो आपके प्रोडक्ट एक्टिवेशन फ़ाइल को GroupDocs लाइब्रेरी के साथ रजिस्टर करता है। सुनिश्चित करें कि लाइसेंस फ़ाइल एप्लिकेशन की रूट फ़ोल्डर में रखी गई है और License ऑब्जेक्ट किसी भी अन्य GroupDocs कॉल से पहले इंस्टैंसिएट किया गया हो।

// Set license before using any GroupDocs functionality
License license = new License();
license.SetLicense("path/to/your/license.lic");

// Or use stream for embedded licenses
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("YourApp.license.lic"))
{
    license.SetLicense(stream);
}

प्रदर्शन समस्याएँ

सीधा उत्तर: अपने एप्लिकेशन का प्रोफ़ाइल बनाएं, रीयल‑टाइम प्रोसेसिंग के लिए फ़ाइल आकार को 100 MB तक सीमित रखें, और दोहराए गए रीड्स के लिए कैशिंग सक्षम करें।

प्लेटफ़ॉर्म‑विशिष्ट समस्याएँ

सीधा उत्तर: क्रॉस‑प्लेटफ़ॉर्म पाथ निर्माण के लिए Path.Combine का उपयोग करें; Windows बैकस्लैश उपयोग करता है जबकि Linux फॉरवर्ड स्लैश।

// Use Path.Combine for cross-platform compatibility
string documentPath = Path.Combine(baseDirectory, "documents", fileName);

पासवर्ड‑सुरक्षित दस्तावेज़ों को संभालना

सीधा उत्तर: Annotator कंस्ट्रक्टर को पासवर्ड पास करें या GetDocumentInfo() कॉल करने से पहले LoadOptions के माध्यम से सेट करें।

LoadOptions loadOptions = new LoadOptions() { Password = "your-password" };
using (Annotator annotator = new Annotator("protected-document.pdf", loadOptions))
{
    // Extract information normally
}

GroupDocs.Annotation को अपडेट करना

सीधा उत्तर: dotnet add package GroupDocs.Annotation --version <latest> चलाएँ या NuGet पैकेज मैनेजर UI का उपयोग करके नवीनतम संस्करण प्राप्त करें।

Update-Package GroupDocs.Annotation

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

प्रश्न: जानकारी निकालने के लिए GroupDocs.Annotation कौन से दस्तावेज़ फ़ॉर्मेट समर्थन करता है?
उत्तर: GroupDocs.Annotation 50 से अधिक दस्तावेज़ फ़ॉर्मेट का समर्थन करता है, जिसमें PDF, DOCX, XLSX, PPTX, JPEG, PNG, TIFF, CAD फ़ाइलें, और कई अन्य शामिल हैं।

प्रश्न: क्या मैं दस्तावेज़ों से कस्टम मेटाडेटा या प्रॉपर्टी निकाल सकता हूँ?
उत्तर: GetDocumentInfo() फ़ाइल प्रकार, पेज काउंट, और आकार जैसी मूल मेटाडेटा प्रदान करता है। कस्टम प्रॉपर्टी जैसे लेखक या निर्माण तिथि के लिए, GroupDocs.Annotation को GroupDocs.Metadata के साथ मिलाएँ या फ़ाइल फ़ॉर्मेट की नेटिव प्रॉपर्टी API का उपयोग करें।

प्रश्न: पासवर्ड‑सुरक्षित दस्तावेज़ों को कैसे संभालें?
उत्तर: Annotator इंस्टेंस बनाते समय पासवर्ड प्रदान करें, उदाहरण के लिए new Annotator("secure.pdf", new LoadOptions { Password = "pwd" })।

प्रश्न: क्या पूरे फ़ाइल को मेमोरी में लोड किए बिना दस्तावेज़ जानकारी निकालने का तरीका है?
उत्तर: हाँ—GetDocumentInfo() केवल फ़ाइल हेडर पढ़ता है, इसलिए कई‑सौ‑पेज PDFs के लिए भी मेमोरी उपयोग कम रहता है।

प्रश्न: क्या इसे वेब एप्लिकेशन या मल्टी‑थ्रेडेड वातावरण में उपयोग कर सकता हूँ?
उत्तर: बिल्कुल। GroupDocs.Annotation थ्रेड‑सेफ़ है; प्रत्येक अनुरोध के लिए नया Annotator बनाएं और तुरंत डिस्पोज़ करें।

निष्कर्ष और अगले कदम

अब आपके पास GroupDocs.Annotation का उपयोग करके c# pdf पेज काउंट, फ़ाइल प्रकार, और आकार निकालने का पूर्ण, प्रोडक्शन‑रेडी तरीका है। आपने लाइब्रेरी सेटअप करना, मेटाडेटा प्राप्त करना, सामान्य समस्याओं को संभालना, और बड़े‑पैमाने पर परिदृश्यों के लिए प्रदर्शन अनुकूलित करना सीखा है।

अगले कदम:

  1. सैंपल प्रोजेक्ट को क्लोन करें और वास्तविक फ़ाइलों के साथ प्लेसहोल्डर चलाएँ।
  2. अतिरिक्त GroupDocs.Annotation सुविधाओं जैसे एनोटेशन रेंडरिंग और दस्तावेज़ तुलना का अन्वेषण करें।
  3. मेटाडेटा एक्सट्रैक्शन को अपने मौजूदा अपलोड पाइपलाइन में एकीकृत करें ताकि वर्गीकरण और वैधता को स्वचालित किया जा सके।

याद रखें, मजबूत दस्तावेज़ प्रोसेसिंग विश्वसनीय मेटाडेटा से शुरू होती है। GroupDocs.Annotation के साथ, आप अधिक स्मार्ट, तेज़, और स्केलेबल समाधान बना सकते हैं।

अंतिम अपडेट: 2026-06-01
परीक्षित संस्करण: GroupDocs.Annotation 25.4.0 (नवीनतम)
लेखक: GroupDocs

महत्वपूर्ण लिंक:

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