जावा में दस्तावेज़ तुलना – GroupDocs API पूर्ण गाइड

परिचय

क्या आपने कभी दो दस्तावेज़ों को लाइन दर लाइन मैन्युअल रूप से तुलना की है और फिर भी महत्वपूर्ण अंतर छूट गए? आप अकेले नहीं हैं। compare documents in java एक सामान्य चुनौती है, विशेषकर जब आपको मेटाडेटा संरक्षित रखना हो, पासवर्ड‑सुरक्षित फ़ाइलों को संभालना हो, या एक साथ कई फ़ाइलों की तुलना करनी हो।

असल बात यह है कि अधिकांश डेवलपर्स संघर्ष करते हैं क्योंकि वे या तो शून्य से कुछ बनाते हैं (जिसमें बहुत समय लगता है) या बुनियादी डिफ़ टूल्स का उपयोग करते हैं जो फ़ॉर्मेटिंग, मेटाडेटा और सुरक्षा सेटिंग्स को नजरअंदाज़ कर देते हैं। यहीं पर GroupDocs.Comparison for Java काम आता है।

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

अपने जावा प्रोजेक्ट में GroupDocs.Comparison सेट अप करें (यह सोचा से भी आसान है)
compare documents in java करते हुए मेटाडेटा की अखंडता बनाए रखें
java compare multiple files और java compare password protected परिदृश्यों को संभालें
बड़े‑पैमाने पर दस्तावेज़ प्रोसेसिंग के लिए प्रदर्शन को अनुकूलित करें

क्या आप अपने जावा ऐप्स में दस्तावेज़ तुलना को सहज बनाना चाहते हैं? चलिए शुरू करते हैं!

त्वरित उत्तर

कौन सी लाइब्रेरी जावा में दस्तावेज़ तुलना करती है? GroupDocs.Comparison for Java
क्या मैं एक साथ कई फ़ाइलें तुलना कर सकता हूँ? हाँ – जितनी चाहें टार्गेट दस्तावेज़ जोड़ें
पासवर्ड‑सुरक्षित दस्तावेज़ों को कैसे संभालूँ? LoadOptions के साथ दस्तावेज़ पासवर्ड उपयोग करें
प्रोडक्शन के लिए लाइसेंस चाहिए? वैध GroupDocs लाइसेंस वॉटरमार्क और सीमाओं को हटाता है
कौन सा जावा संस्करण आवश्यक है? JDK 8+, JDK 11+ की सलाह दी जाती है

compare documents in java क्या है?

जावा में दस्तावेज़ तुलना का मतलब है प्रोग्रामेटिक रूप से दो या अधिक फ़ाइलों के बीच अंतर—टेक्स्ट परिवर्तन, फ़ॉर्मेटिंग एडिट, या मेटाडेटा अपडेट—को पहचानना, वह भी ऐसी लाइब्रेरी का उपयोग करके जो दस्तावेज़ संरचना को समझती हो। GroupDocs.Comparison जटिलता को सारांशित करता है, जिससे आप एक सरल API के माध्यम से डिफ़ दस्तावेज़ बना सकते हैं जो हर परिवर्तन को हाइलाइट करता है।

GroupDocs.Comparison for Java क्यों उपयोग करें?

समृद्ध फ़ॉर्मेट समर्थन – DOCX, PDF, XLSX, PPTX, TXT, और अधिक
मेटाडेटा हैंडलिंग – परिणाम में स्रोत, लक्ष्य, या कोई मेटाडेटा न रखने का विकल्प
पासवर्ड समर्थन – मैन्युअल डिक्रिप्शन के बिना सुरक्षित फ़ाइलें खोलें
स्केलेबल प्रदर्शन – बैच प्रोसेसिंग, असिंक्रोनस निष्पादन, और मेमोरी‑कुशल डिज़ाइन

पूर्वापेक्षाएँ

जावा वातावरण: JDK 8+ (JDK 11+ की सलाह), पसंदीदा IDE, Maven (या Gradle)
GroupDocs.Comparison लाइब्रेरी: संस्करण 25.2 या बाद का (हमेशा नवीनतम प्राप्त करें)
लाइसेंस: फ्री ट्रायल, 30‑दिन का टेम्पररी लाइसेंस, या कमर्शियल लाइसेंस

अपने प्रोजेक्ट में GroupDocs.Comparison सेट अप करना

Maven कॉन्फ़िगरेशन

सबसे पहले – अपने pom.xml में GroupDocs रिपॉज़िटरी और डिपेंडेंसी जोड़ें। अधिकांश ट्यूटोरियल इस हिस्से को अनावश्यक रूप से जटिल बनाते हैं, लेकिन यह वास्तव में बहुत आसान है:

<repositories>
   <repository>
      <id>repository.groupdocs.com</id>
      <name>GroupDocs Repository</name>
      <url>https://releases.groupdocs.com/comparison/java/</url>
   </repository>
</repositories>

<dependencies>
   <dependency>
      <groupId>com.groupdocs</groupId>
      <artifactId>groupdocs-comparison</artifactId>
      <version>25.2</version>
   </dependency>
</dependencies>

प्रो टिप: हमेशा नवीनतम संस्करण संख्या GroupDocs रिलीज़ पेज पर चेक करें। नए संस्करण अक्सर प्रदर्शन सुधार और बग फ़िक्स शामिल करते हैं जो आपके सिरदर्द को कम कर सकते हैं।

अपना लाइसेंस सेट करना

बहुत से डेवलपर्स यह नहीं जानते कि आप GroupDocs.Comparison को तुरंत उनके फ्री ट्रायल के साथ टेस्ट कर सकते हैं। कोई क्रेडिट कार्ड नहीं, कोई शर्त नहीं।

आपके विकल्प:

फ्री ट्रायल – टेस्टिंग और छोटे प्रोजेक्ट्स के लिए परफेक्ट। बस डाउनलोड करें और कोड लिखना शुरू करें!
टेम्पररी लाइसेंस – अधिक समय चाहिए? 30‑दिन का टेम्पररी लाइसेंस यहाँ से प्राप्त करें here
कमर्शियल लाइसेंस – प्रोडक्शन के लिए तैयार? प्राइसिंग यहाँ देखें here

फ्री ट्रायल सभी फीचर देता है लेकिन आउटपुट फ़ाइलों में वॉटरमार्क जोड़ता है। डेवलपमेंट और टेस्टिंग के लिए यह आमतौर पर ठीक रहता है।

दस्तावेज़ तुलना कार्यान्वयन: पूर्ण चरण‑दर‑चरण गाइड

अब मुख्य भाग! हम चरण‑दर‑चरण एक पूर्ण दस्तावेज़ तुलना समाधान बनाएँगे। चिंता न करें – हम न केवल "कैसे" बल्कि प्रत्येक निर्णय के "क्यों" को भी समझाएंगे।

मेटाडेटा स्रोतों को समझना (यह बहुत ज़रूरी है!)

कोडिंग शुरू करने से पहले, चलिए एक ऐसी बात पर चर्चा करते हैं जो कई डेवलपर्स को उलझा देती है: मेटाडेटा स्रोत। जब आप compare documents in java करते हैं, तो आपको तय करना होता है कि परिणाम में किस दस्तावेज़ का मेटाडेटा (लेखक, निर्माण तिथि, कस्टम प्रॉपर्टीज़, आदि) संरक्षित रहेगा।

GroupDocs.Comparison आपको तीन विकल्प देता है:

SOURCE – मूल दस्तावेज़ से मेटाडेटा उपयोग करें
TARGET – तुलना किए जा रहे दस्तावेज़ से मेटाडेटा उपयोग करें
NONE – परिणाम से सभी मेटाडेटा हटाएँ

अधिकांश बिज़नेस एप्लिकेशन में, आप SOURCE का उपयोग करके स्थिरता बनाए रखेंगे।

चरण‑दर‑चरण कार्यान्वयन

हम एक पुन: उपयोग योग्य यूटिलिटी बनाएँगे जिसे आप किसी भी प्रोजेक्ट में डाल सकते हैं।

चरण 1: आवश्यक क्लासेज़ इम्पोर्ट करें

import com.groupdocs.comparison.Comparer;
import com.groupdocs.comparison.options.enums.MetadataType;
import com.groupdocs.comparison.options.save.SaveOptions;
import java.nio.file.Path;
import java.io.IOException;

चरण 2: Comparer इंस्टेंस बनाएं

यहाँ से जादू शुरू होता है। Comparer क्लास सभी तुलना ऑपरेशन्स का मुख्य एंट्री पॉइंट है:

try (Comparer comparer = new Comparer("YOUR_DOCUMENT_DIRECTORY/source.docx")) {
    // All our comparison logic goes here
}

try‑with‑resources क्यों उपयोग करें? Comparer क्लास AutoCloseable को इम्प्लीमेंट करती है, जिसका मतलब है कि यह उपयोग समाप्त होने पर संसाधनों को सही ढंग से साफ़ करता है। यह मेमोरी लीक को रोकता है – विशेषकर जब आप कई दस्तावेज़ प्रोसेस कर रहे हों।

चरण 3: तुलना के लिए टार्गेट दस्तावेज़ जोड़ें

comparer.add("YOUR_DOCUMENT_DIRECTORY/target1.docx");

एक कूल फीचर: आप वास्तव में कई टार्गेट दस्तावेज़ जोड़ सकते हैं और उन्हें एक ही ऑपरेशन में स्रोत के खिलाफ तुलना कर सकते हैं। बस add() को कई बार कॉल करें:

comparer.add("YOUR_DOCUMENT_DIRECTORY/target1.docx");
comparer.add("YOUR_DOCUMENT_DIRECTORY/target2.docx");
comparer.add("YOUR_DOCUMENT_DIRECTORY/target3.docx");

चरण 4: मेटाडेटा हैंडलिंग कॉन्फ़िगर करें और तुलना चलाएँ

यहाँ हम मेटाडेटा स्रोत सेट करते हैं और वास्तविक तुलना चलाते हैं:

final Path resultPath = comparer.compare("output/comparison_result.docx",
        new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)
                .build());

क्या हो रहा है? हम GroupDocs को बता रहे हैं:

सभी जोड़े गए दस्तावेज़ों को स्रोत के खिलाफ तुलना करें
परिणाम को निर्दिष्ट पाथ पर सहेजें
अंतिम परिणाम में SOURCE दस्तावेज़ का मेटाडेटा उपयोग करें

पूर्ण कार्यशील उदाहरण

अब सब कुछ एक मेथड में जोड़ते हैं जिसे आप सीधे उपयोग कर सकते हैं:

public class DocumentComparison {
    
    public static Path compareDocumentsWithMetadata(
            String sourcePath, 
            String targetPath, 
            String outputPath) throws IOException {
        
        try (Comparer comparer = new Comparer(sourcePath)) {
            // Add the target document
            comparer.add(targetPath);
            
            // Configure comparison options
            SaveOptions saveOptions = new SaveOptions.Builder()
                    .setCloneMetadataType(MetadataType.SOURCE)
                    .build();
            
            // Execute comparison and return result path
            return comparer.compare(outputPath, saveOptions);
        }
    }
}

सामान्य जाल और उनका समाधान

सैकड़ों डेवलपर्स को दस्तावेज़ तुलना लागू करते समय वही समस्याएँ बार‑बार मिलती हैं। यहाँ प्रमुख समस्याएँ (और उनके समाधान) हैं:

फ़ाइल पाथ समस्याएँ

समस्या: FileNotFoundException जबकि फ़ाइल मौजूद है
समाधान: हमेशा एब्सोल्यूट पाथ उपयोग करें या रिलेटिव पाथ को सही ढंग से रिज़ॉल्व करें

// Instead of this:
String sourcePath = "documents/source.docx";

// Do this:
String sourcePath = Paths.get("documents", "source.docx").toAbsolutePath().toString();

मेमोरी प्रबंधन समस्याएँ

समस्या: बड़े दस्तावेज़ों की तुलना करते समय Out of memory त्रुटि
समाधान: JVM हीप साइज बढ़ाएँ और उचित रिसोर्स मैनेजमेंट उपयोग करें

# Add these JVM arguments when running your application
-Xmx4g -XX:+UseG1GC

गलत मेटाडेटा हैंडलिंग

समस्या: तुलना के दौरान महत्वपूर्ण दस्तावेज़ मेटाडेटा खो जाना
समाधान: हमेशा स्पष्ट रूप से मेटाडेटा टाइप सेट करें – डिफ़ॉल्ट पर भरोसा न करें

// Always be explicit about metadata handling
SaveOptions saveOptions = new SaveOptions.Builder()
        .setCloneMetadataType(MetadataType.SOURCE)  // Be explicit!
        .build();

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

समस्या: प्रोडक्शन में वॉटरमार्क दिखना
समाधान: Comparer इंस्टेंस बनाने से पहले लाइसेंस सही ढंग से लोड हुआ है, यह सत्यापित करें

// Load license at application startup
License license = new License();
license.setLicense("path/to/your/license.lic");

प्रोडक्शन उपयोग के लिए सर्वोत्तम प्रैक्टिसेज़

वास्तविक‑दुनिया के अनुभव के आधार पर, यहाँ वे प्रैक्टिसेज़ हैं जो शौकिया इम्प्लीमेंटेशन को प्रोडक्शन‑रेडी समाधान से अलग करती हैं:

वास्तव में मददगार एरर हैंडलिंग

सिर्फ एक्सेप्शन को कैच न करें – उनका अर्थपूर्ण रूप से निपटें:

public ComparisonResult compareDocuments(String source, String target) {
    try (Comparer comparer = new Comparer(source)) {
        comparer.add(target);
        Path result = comparer.compare("output.docx", 
            new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)
                .build());
        
        return new ComparisonResult(true, result.toString(), null);
        
    } catch (IOException e) {
        logger.error("File access error during comparison", e);
        return new ComparisonResult(false, null, "Unable to access document files");
        
    } catch (Exception e) {
        logger.error("Unexpected error during document comparison", e);
        return new ComparisonResult(false, null, "Document comparison failed");
    }
}

प्रदर्शन अनुकूलन

हाई‑वॉल्यूम परिदृश्यों के लिए, इन अनुकूलनों पर विचार करें:

Comparer इंस्टेंस को पुन: उपयोग करें जब संभव हो (थ्रेड‑सेफ़्टी का ध्यान रखें)
डॉक्यूमेंट्स को बैच में प्रोसेस करें ताकि सिस्टम रिसोर्स ओवरलोड न हो
असिंक्रोनस प्रोसेसिंग बड़े दस्तावेज़ों के लिए उपयोग करें
मेमोरी उपयोग मॉनिटर करें और JVM सेटिंग्स को तदनुसार समायोजित करें

सुरक्षा विचार

संवेदनशील दस्तावेज़ों को संभालते समय:

फ़ाइल प्रकारों को वैलिडेट करें प्रोसेसिंग से पहले
उचित एक्सेस कंट्रोल लागू करें
टेम्पररी फ़ाइलें तुरंत साफ़ करें
तुलना परिणाम को एन्क्रिप्ट करने पर विचार करें

वास्तविक‑दुनिया के एप्लिकेशन और उपयोग‑के‑मामले

आइए देखें कि डेवलपर्स प्रोडक्शन में GroupDocs.Comparison का कैसे उपयोग कर रहे हैं:

लीगल डॉक्यूमेंट रिव्यू

कानूनी फर्में अनुबंधों और कानूनी समझौतों में बदलाव ट्रैक करने के लिए दस्तावेज़ तुलना का उपयोग करती हैं। मेटाडेटा प्रिज़र्वेशन फ़ीचर यहाँ अत्यंत महत्वपूर्ण है क्योंकि उन्हें दस्तावेज़ की उत्पत्ति बनाए रखनी होती है।

// Typical legal document comparison workflow
public void reviewContractChanges(String originalContract, String revisedContract) {
    try (Comparer comparer = new Comparer(originalContract)) {
        comparer.add(revisedContract);
        
        SaveOptions options = new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)  // Preserve original metadata
                .build();
        
        Path result = comparer.compare("contract_review.docx", options);
        
        // Send result to legal team for review
        notifyLegalTeam(result);
    }
}

कंटेंट मैनेजमेंट सिस्टम्स

CMS प्लेटफ़ॉर्म संस्करण नियंत्रण और परिवर्तन ट्रैकिंग के लिए दस्तावेज़ तुलना का उपयोग करते हैं:

public class CMSDocumentVersioning {
    
    public VersionComparisonResult compareVersions(
            DocumentVersion current, 
            DocumentVersion previous) {
        
        try (Comparer comparer = new Comparer(current.getFilePath())) {
            comparer.add(previous.getFilePath());
            
            String outputName = String.format("comparison_%s_vs_%s.docx", 
                current.getVersionNumber(), 
                previous.getVersionNumber());
            
            Path result = comparer.compare(outputName, 
                new SaveOptions.Builder()
                    .setCloneMetadataType(MetadataType.SOURCE)
                    .build());
            
            return new VersionComparisonResult(result, current, previous);
        }
    }
}

फाइनेंशियल डॉक्यूमेंट एनालिसिस

वित्तीय संस्थान नियामक अनुपालन और ऑडिट ट्रेल के लिए इसका उपयोग करते हैं:

public AuditResult auditFinancialDocument(String originalReport, String submittedReport) {
    // Compare submitted report against original
    // Metadata preservation is critical for audit compliance
    try (Comparer comparer = new Comparer(originalReport)) {
        comparer.add(submittedReport);
        
        Path auditResult = comparer.compare("audit_comparison.docx",
            new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)
                .build());
        
        return generateAuditReport(auditResult);
    }
}

प्रदर्शन अनुकूलन और स्केलेबिलिटी

जब आप गंभीर दस्तावेज़ वॉल्यूम संभालने के लिए तैयार हों, तो ये रणनीतियाँ आपके एप्लिकेशन को प्रतिक्रियाशील रखेगी:

मेमोरी मैनेजमेंट

बड़े दस्तावेज़ जल्दी ही उपलब्ध मेमोरी खा सकते हैं। यहाँ उन्हें कुशलता से हैंडल करने का तरीका है:

public class OptimizedDocumentProcessor {
    
    private final ExecutorService executor = Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors());
    
    public CompletableFuture<Path> compareDocumentsAsync(
            String source, 
            String target, 
            String output) {
        
        return CompletableFuture.supplyAsync(() -> {
            try (Comparer comparer = new Comparer(source)) {
                comparer.add(target);
                return comparer.compare(output, 
                    new SaveOptions.Builder()
                        .setCloneMetadataType(MetadataType.SOURCE)
                        .build());
            }
        }, executor);
    }
}

बैच प्रोसेसिंग

कई दस्तावेज़ तुलना के लिए, बैच प्रोसेसिंग आपका दोस्त है:

public List<ComparisonResult> processBatch(List<DocumentPair> documentPairs) {
    return documentPairs.parallelStream()
        .map(this::compareDocumentPair)
        .collect(Collectors.toList());
}

private ComparisonResult compareDocumentPair(DocumentPair pair) {
    try (Comparer comparer = new Comparer(pair.getSourcePath())) {
        comparer.add(pair.getTargetPath());
        Path result = comparer.compare(pair.getOutputPath(),
            new SaveOptions.Builder()
                .setCloneMetadataType(MetadataType.SOURCE)
                .build());
        return new ComparisonResult(pair, result, true);
    } catch (Exception e) {
        return new ComparisonResult(pair, null, false, e.getMessage());
    }
}

ट्रबलशूटिंग गाइड

जब चीज़ें गड़बड़ हों (और कभी‑कभी होती हैं), तो यहाँ आपका डिबगिंग चेकलिस्ट है:

"Comparison Failed" एरर

सबसे आम कारण:

असमर्थित फ़ाइल फ़ॉर्मेट
स्रोत दस्तावेज़ भ्रष्ट
अपर्याप्त मेमोरी
फ़ाइल परमिशन समस्याएँ

डिबगिंग स्टेप्स:

// Add comprehensive logging to identify the issue
logger.debug("Starting comparison: source={}, target={}", sourcePath, targetPath);

try (Comparer comparer = new Comparer(sourcePath)) {
    logger.debug("Comparer initialized successfully");
    
    comparer.add(targetPath);
    logger.debug("Target document added successfully");
    
    Path result = comparer.compare(outputPath, saveOptions);
    logger.info("Comparison completed successfully: result={}", result);
    
    return result;
} catch (Exception e) {
    logger.error("Comparison failed", e);
    throw new DocumentComparisonException("Failed to compare documents", e);
}

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

यदि तुलना बहुत समय ले रही है:

डॉक्यूमेंट साइज चेक – 100 MB से बड़ी फ़ाइलों को विशेष हैंडलिंग की जरूरत हो सकती है
मेमोरी उपयोग मॉनिटर – आवश्यक होने पर हीप साइज बढ़ाएँ
फ़ाइल I/O प्रदर्शन – धीमा स्टोरेज ऑपरेशन्स को बॉटलनेक बना सकता है
डॉक्यूमेंट फ़ॉर्मेट – कुछ फ़ॉर्मेट प्रोसेस करने में अधिक जटिल होते हैं

मेमोरी लीक्स

लीक के संकेत:

समय के साथ एप्लिकेशन प्रदर्शन घटता है
कई दस्तावेज़ प्रोसेस करने के बाद OutOfMemoryError
उच्च गार्बेज कलेक्शन एक्टिविटी

समाधान: हमेशा try‑with‑resources उपयोग करें और प्रोफ़ाइलिंग टूल्स से एप्लिकेशन मॉनिटर करें।

पासवर्ड‑सुरक्षित फ़ाइलों को संभालना

यदि आपको java compare password protected दस्तावेज़ों की तुलना करनी है, तो स्रोत या टार्गेट खोलते समय LoadOptions के साथ पासवर्ड प्रदान करें:

LoadOptions loadOptions = new LoadOptions("your_password");
try (Comparer comparer = new Comparer("protected_document.docx", loadOptions)) {
    // Process password‑protected document
}

Spring Boot के साथ इंटीग्रेशन

माइक्रोसर्विसेज़ बना रहे डेवलपर्स के लिए, तुलना लॉजिक को Spring सर्विस बीन्स में रैप करें:

@Service
public class DocumentComparisonService {
    
    public ComparisonResult compareDocuments(String source, String target) {
        try (Comparer comparer = new Comparer(source)) {
            comparer.add(target);
            Path result = comparer.compare("output.docx",
                new SaveOptions.Builder()
                    .setCloneMetadataType(MetadataType.SOURCE)
                    .build());
            return new ComparisonResult(result);
        }
    }
}

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

प्रश्न: क्या मैं एक साथ दो से अधिक दस्तावेज़ तुलना कर सकता हूँ?
उत्तर: बिल्कुल! comparer.add() के साथ कई टार्गेट दस्तावेज़ जोड़ें और फिर तुलना चलाएँ।

प्रश्न: GroupDocs.Comparison किन फ़ाइल फ़ॉर्मेट्स को सपोर्ट करता है?
उत्तर: यह DOCX, PDF, XLSX, PPTX, TXT और कई अन्य फ़ॉर्मेट्स को सपोर्ट करता है। पूरी सूची आधिकारिक डॉक्यूमेंटेशन में देखें।

प्रश्न: पासवर्ड‑सुरक्षित दस्तावेज़ों को कैसे हैंडल करूँ?
उत्तर: LoadOptions क्लास का उपयोग करके पासवर्ड प्रदान करें जब Comparer इंस्टेंस बनाते हैं (ऊपर के उदाहरण देखें)।

प्रश्न: क्या GroupDocs.Comparison थ्रेड‑सेफ़ है?
उत्तर: एकल Comparer इंस्टेंस थ्रेड‑सेफ़ नहीं है, लेकिन आप कई इंस्टेंस को समानांतर थ्रेड्स में सुरक्षित रूप से उपयोग कर सकते हैं।

प्रश्न: बड़े दस्तावेज़ों के लिए प्रदर्शन कैसे बढ़ाऊँ?
उत्तर: JVM हीप (-Xmx) बढ़ाएँ, फ़ाइलों को असिंक्रोनस प्रोसेस करें, बैच में चलाएँ, और जब संभव हो Comparer ऑब्जेक्ट्स को पुन: उपयोग करें।

अतिरिक्त संसाधन

GroupDocs.Comparison Documentation – व्यापक API रेफ़रेंस और उदाहरण
GroupDocs Community Forum – अन्य डेवलपर्स से मदद प्राप्त करें

अंतिम अपडेट: 2025-12-21
टेस्टेड वर्ज़न: GroupDocs.Comparison 25.2
लेखक: GroupDocs

FilesExpand file tree

_index.md

Latest commit

History