Dokumentum összehasonlítás .NET automatizálás

A manuális dokumentumellenőrzés rejtett költsége

Automate document comparison .NET drámaian csökkentheti ezt a ráfordítást.
Képzeld el: tucatnyi szerződés, jogi dokumentum vagy műszaki specifikáció hegyében vagy, amelyeket össze kell hasonlítani. Órákat—esetleg napokat—töltöd manuálisan a változások keresésével, az eltérések felkutatásával, és igyekszel nem kihagyni kritikus részleteket, amelyek akár ezrekbe is kerülhetnek a vállalatod számára.

Ismerős? Nem vagy egyedül. Az átlagos tudásmunkás a hetek 21%-át tölti dokumentummal kapcsolatos feladatokkal, melyből az összehasonlítás és felülvizsgálat a legnagyobb szeletet veszi el.

De itt a lényeg—document comparison .NET automation képes 80‑90%-kal csökkenteni ezt a manuális munkát. Ebben az átfogó útmutatóban pontosan megmutatom, hogyan valósítható meg az automatizált multi document comparison a GroupDocs.Comparison for .NET könyvtárral, ami akár 15+ órát is megtakaríthat hetente.

Mit fogsz elsajátítani a következő 10 percben:

  • Hibamentes dokumentum összehasonlítás automatizálás beállítása .NET‑ben
  • Több dokumentum összehasonlítás megvalósítása, amely bármilyen fájlformátumot kezel
  • A megoldás skálázása tucatokról ezrekre
  • Az 5 leggyakoribb csapda elkerülése, amely fejlesztőket akadályoz

Gyors válaszok

  • Melyik könyvtárat használjam? GroupDocs.Comparison for .NET (v25.4.0+)
  • Milyen gyors a összehasonlítás? Kis dokumentumok ~0,5 s, nagy dokumentumok akár 30 s páronként
  • Össze tudok-e hasonlítani különböző fájltípusokat? Igen—Word, PDF, Excel, PowerPoint és még sok más
  • Szükség van licencre a termeléshez? Kereskedelmi licenc szükséges a termelési használathoz
  • Támogatott az aszinkron feldolgozás? Teljesen—használj async wrapper‑eket a nem‑blokkoló végrehajtáshoz

Mi a többdokumentumos összehasonlítás?

A többdokumentumos összehasonlítás egy elsődleges forrásfájl programozott elemzése több célfájl ellen, hogy minden hozzáadást, törlést és formázási változást az egész készletben azonosítson. A Comparer osztály a központi motor, amely betölti a forrásdokumentumot, végigiterál minden célfájlon, és egy konszolidált eredményt generál, amely kiemeli az összes különbséget.

A többdokumentumos összehasonlítást használhatod szerződésváltozatok egyeztetésére, pénzügyi kimutatások auditálására, vagy a szoftverdokumentáció verziók közötti szinkronizálásának ellenőrzésére.

Miért nyer minden alkalommal az automatizálás

Mielőtt a kódba merülnénk (ne aggódj, meglepően egyszerű), beszéljünk arról, miért válnak a automate document review .NET megoldások elengedhetetlenné a modern vállalkozások számára.

A számok nem hazudnak

A manuális dokumentumösszehasonlítás nem csak lassú—olyan drága és hibára hajlamos:

  • Időköltség: 30‑45 perc dokumentumpáronként egy alapos manuális felülvizsgálat során
  • Hibaarány: Az emberi ellenőrök 15‑20%-át mulasztják el a jelentős változásoknak
  • Skálázhatóság hiánya: A manuális folyamatok összeomlanak a mennyiség növekedésével
  • Lehetőségköltség: Értékes időd ismétlődő feladatokba ragad

Mit nyújt az automatizálás

Amikor automate document comparison-t használsz, a következőket kapod:

  • Sebesség: 100+ dokumentumpárt dolgozol fel ugyanannyi idő alatt, amennyi 5 manuális felülvizsgálatot igényelne
  • Pontosság: 99,9%-ban elkapja a változásokat, beleértve a finom formázási eltéréseket is
  • Skálázhatóság: Több ezer dokumentumot kezel anélkül, hogy izzadnál
  • Következetesség: Minden alkalommal ugyanolyan alapos elemzés

Most építsünk egy rendszert, amely ezeket az előnyöket biztosítja.

Előfeltételek: mire van szükséged a kezdéshez

A document comparison .NET automation megoldás megvalósításához a következőkre lesz szükséged:

Szükséges könyvtárak és verziók

  • GroupDocs.Comparison for .NET: 25.4.0 vagy újabb verzió (ez a te automatizálási erőműved)
  • .NET Framework: 4.6.2+ vagy .NET Core 2.0+ (a legtöbb modern projekt lefedi)

Környezet beállítási követelmények

  • .NET‑kel felszerelt fejlesztői környezet (Visual Studio, VS Code vagy Rider)
  • Alapvető C# és .NET programozási ismeretek
  • Hozzáférés mintadokumentumokhoz a teszteléshez (megmutatjuk, hogyan kezeld a különböző formátumokat)

Tudásbeli előfeltételek

  • Ismeretek a .NET fejlesztés alapjairól
  • Fájl‑I/O műveletek C#‑ban való ismerete
  • Alapvető dokumentumfeldolgozási koncepciók (hasznos, de nem kötelező)

Pro tipp: Ha vállalati környezetben dolgozol, győződj meg róla, hogy van jogosultságod NuGet‑csomagok telepítésére és a dokumentumok tárolási helyéhez való hozzáférésre.

A dokumentumösszehasonlítás automatizálási motor beállítása

Indítsuk el a GroupDocs comparison tutorial C# implementációt. A beállítás egyszerű, de megosztok néhány belső tippet, hogy elkerüld a gyakori kezdeti fejfájásokat.

Telepítés: két mód a kezdéshez

Opció 1: NuGet Package Manager Console (a legtöbb projekt számára ajánlott)

Install-Package GroupDocs.Comparison -Version 25.4.0

Opció 2: .NET CLI (nagyszerű CI/CD pipeline‑okhoz)

dotnet add package GroupDocs.Comparison --version 25.4.0

Mindkét módszer tökéletesen működik—válaszd a számodra kényelmes munkafolyamatot.

Licencelés: a teljes funkciók elérése

Sok fejlesztő ezt figyelmen kívül hagyja: a GroupDocs több licencopciót kínál, amelyek megkönnyítik a fejlesztést:

  • Free trial: Ideális proof‑of‑concept munkához (korlátozott funkcionalitás)
  • Temporary license: Teljes funkciók 30 napig—ideális a teljes körű értékeléshez
  • Commercial license: Kötelező a termelési környezetben

Fejlesztői trükk: Mindig kezdj egy ideiglenes licenccel a fejlesztés során. Ez megakadályozza a funkciókorlátok hatását a tesztelésre, és teljes képet ad a lehetőségekről.

Alapvető inicializálás: az alapok lerakása

A telepítés után inicializáld a GroupDocs.Comparison‑t a C# projektedben:

using System;
using System.IO;
using GroupDocs.Comparison;

Ezek az importok mindent tartalmaznak, ami a dokumentumösszehasonlítás automatizáláshoz szükséges. Egyszerű, ugye?

Implementációs útmutató: az automatizált megoldás felépítése

Most jön a fő rész—építsünk egy robuszt .NET többdokumentumos összehasonlító eszközt, amely a valós világban is helytáll. Lépésről lépésre bemutatom a gyakorlati példákat, és elmagyarázom, miért fontos minden egyes részlet.

A nagy kép: hogyan működik a többdokumentumos összehasonlítás

Mielőtt a kódba merülnénk, értsük meg a folyamatot:

  1. Inicializálás egy Comparer objektummal a forrásdokumentumodhoz
  2. Célok hozzáadása a forráshoz képest összehasonlítandó dokumentumok listájából
  3. Futtatás az összehasonlítási folyamat
  4. Eredmény mentése egy új dokumentumba, amely az összes különbséget mutatja

Ez a minta működik akár 2, akár 200 dokumentum összehasonlításánál.

Hogyan hajtsuk végre a többdokumentumos összehasonlítást .NET‑ben?

A többdokumentumos összehasonlításhoz .NET‑ben példányosíts egy Comparer‑t a forrásfájl elérési útjával, majd hívd meg a Compare metódust, amely a célfájlok gyűjteményét kapja paraméterként. A metódus egy ComparisonResult objektumot ad vissza, amely a összevont különbségeket tartalmazza, és bármely támogatott formátumban (PDF, DOCX, HTML) menthető. Ez az egyetlen hívás automatikusan kezeli a formátumfelismerést, a változásdetektálást és az eredménygenerálást.

A ComparisonResult a összehasonlítás eredményét képviseli, beleértve a kiemelt változásokat és a metaadatokat.

1. lépés: dokumentumútvonalak beállítása (az alap)

Így strukturálhatod a dokumentumkezelést a maximális rugalmasság érdekében:

string sourceDocumentPath = Path.Combine("YOUR_DOCUMENT_DIRECTORY", "source.docx");
string targetDocument1Path = Path.Combine("YOUR_DOCUMENT_DIRECTORY", "target1.docx");
string targetDocument2Path = Path.Combine("YOUR_DOCUMENT_DIRECTORY", "target2.docx");
string targetDocument3Path = Path.Combine("YOUR_DOCUMENT_DIRECTORY", "target3.docx");

// Define the output file path
string outputDirectory = "YOUR_OUTPUT_DIRECTORY";
string outputFileName = Path.Combine(outputDirectory, "result.docx");

Miért működik ez a megközelítés: A Path.Combine használata biztosítja, hogy a kód különböző operációs rendszereken is helyesen működjön, és megfelelően kezelje az útvonalelválasztókat. Ez a kis részlet megakadályozza a frusztráló telepítési hibákat később.

Valós tippek: Éles környezetben valószínűleg konfigurációs fájlokból, adatbázisból vagy felhasználói bemenetből fogod beolvasni ezeket az útvonalakat. A minta ugyanaz marad—csak a keménykódolt útvonalakat cseréld dinamikus forrásokra.

2. lépés: a varázslat megtörténik – automatizált összehasonlítás

Itt kel életre a automate document comparison megoldásod:

using (Comparer comparer = new Comparer(File.OpenRead(sourceDocumentPath)))
{
    // Add target documents to be compared against the source document
    comparer.Add(File.OpenRead(targetDocument1Path));
    comparer.Add(File.OpenRead(targetDocument2Path));
    comparer.Add(File.OpenRead(targetDocument3Path));

    // Perform comparison and save the result to a file stream
    comparer.Compare(File.Create(outputFileName));
}

Mi történik a háttérben: A Comparer objektum intelligensen elemzi minden dokumentum szerkezetét, tartalmát és formázását. Azonosítja a hozzáadásokat, törléseket és módosításokat az összes cél dokumentumban a forráshoz képest.

Memóriakezelési megjegyzés: A using kulcsszó itt elengedhetetlen—biztosítja, hogy minden fájl‑stream megfelelően felszabadul az összehasonlítás után, elkerülve a memória‑szivárgásokat, amelyek nagy terhelés esetén összeomláshoz vezethetnek.

Kulcsfontosságú konfigurációs beállítások

Miközben az alapimplementáció jól működik, finomhangolhatod az összehasonlítási folyamatot:

  • Formátumkezelés: A könyvtár automatikusan felismeri a dokumentumformátumokat (Word, PDF, Excel stb.)
  • Összehasonlítás érzékenysége: Állítsd be, milyen részletességgel legyen a változásdetektálás
  • Kimenet testreszabása: Szabályozd, hogyan jelenjenek meg a különbségek a végeredmény‑dokumentumban

Teljesítményoptimalizálás: Nagy léptékű műveletek esetén fontold meg a kötegelt feldolgozást, ahol a dokumentumokat kisebb csoportokban dolgozod fel a memóriahasználat optimalizálása érdekében.

Valós sikertörténetek: amikor az automatizálás ragyog

Néhány példa, ahol a document comparison .NET automation forradalmasította az üzleti folyamatokat:

Jogdokumentum-kezelési siker

Egy ügyvédi iroda heti 40+ órát töltött szerződésverziók összehasonlításával egy felvásárlási tárgyalás során. Az automatizált összehasonlítás bevezetése után:

  • Időmegtakarítás: 35 óra hetente
  • Pontosság javulása: 23 %-kal több kritikus változást észleltek, mint manuálisan
  • Ügyfél‑elégedettség: Gyorsabb átfutási idő javította az ügyfélkapcsolatokat

Pénzügyi audit átalakulás

Egy könyvelő cég, amely 200+ ügyfél negyedéves jelentéseit dolgozta fel, automatizálta az összehasonlítási munkafolyamatot:

  • Feldolgozási idő: 3 napról 6 órára csökkent
  • Hibacsökkenés: 90 %-kal kevesebb elmulasztott eltérés
  • Skálázhatóság: Most 400+ ügyfelet kezel extra személyzet nélkül

Tartalom‑felülvizsgálati forradalom

Egy technikai dokumentációs csapat, amely API‑dokumentációt hasonlított össze verziók között:

  • Kiadási ciklus sebessége: 50 %-kal gyorsabb dokumentáció‑frissítések
  • Következetesség: 100 % pontosság a változáskövetésben
  • Csapat‑elégedettség: Eltűnt a legfrusztrálóbb feladatuk

A dokumentumösszehasonlítás munkafolyamat skálázása

Ahogy a automate document review .NET megoldásod bizonyítja az értékét, valószínűleg skálázni szeretnéd. Íme, hogyan kezelheted a növekvő dokumentummennyiséget teljesítményromlás nélkül:

Kötegelt feldolgozási stratégia

Ahelyett, hogy egyszerre minden dokumentumot összehasonlítanál, dolgozd fel őket kezelhető kötegekben:

// Example: Process documents in batches of 10
const int batchSize = 10;
var documentBatches = documents.Batch(batchSize);

foreach (var batch in documentBatches)
{
    // Process each batch using the comparison logic above
    ProcessDocumentBatch(batch);
}

Aszinkron feldolgozás

Nagy mennyiségű esetben valósíts meg async feldolgozást, hogy elkerüld a UI blokkolását:

public async Task<ComparisonResult> CompareDocumentsAsync(
    string sourceDocument, 
    List<string> targetDocuments)
{
    return await Task.Run(() => CompareDocuments(sourceDocument, targetDocuments));
}

Erőforrás‑kezelési legjobb gyakorlatok

  • Memóriafigyelés: Kövesd a memóriahasználatot nagy kötegelt műveletek során
  • Ideiglenes fájlok tisztítása: Győződj meg róla, hogy a feldolgozás után minden ideiglenes fájl törlődik
  • Hibakezelés: Implementálj robusztus hibakezelést hálózati megszakítások vagy sérült fájlok esetére

Gyakori csapdák és elkerülésük

Több csapat document comparison automation bevezetése után ugyanazok a problémák merülnek fel. Íme, hogyan kerüld el őket:

Csapda #1: fájlútvonal‑hibák

A probléma: „File not found” hibák, amelyek a gépeden működnek, de a termelésben nem.

A megoldás: Mindig használj abszolút útvonalakat a termelésben, és ellenőrizd a fájl‑létezést:

if (!File.Exists(sourceDocumentPath))
{
    throw new FileNotFoundException($"Source document not found: {sourceDocumentPath}");
}

Csapda #2: memória‑szivárgás nagy dokumentumoknál

A probléma: Az alkalmazás összeomlik, amikor sok nagy dokumentumot dolgozol fel.

A megoldás: Mindig használj using blokkokat, és fontold meg a streaminget nagyon nagy fájlok esetén:

using (var sourceStream = File.OpenRead(sourceDocumentPath))
using (var comparer = new Comparer(sourceStream))
{
    // Comparison logic here
} // Resources automatically disposed

Csapda #3: formátum‑kompatibilitási feltételezések

A probléma: Feltételezed, hogy minden dokumentum ugyanazt a formátumot használ, anélkül, hogy ellenőriznéd.

A megoldás: Implementálj formátum‑detektálást, és kezeld a vegyes formátumokat elegánsan:

var supportedFormats = new[] { ".docx", ".pdf", ".xlsx", ".pptx" };
var fileExtension = Path.GetExtension(documentPath).ToLower();

if (!supportedFormats.Contains(fileExtension))
{
    throw new NotSupportedException($"Unsupported file format: {fileExtension}");
}

Csapda #4: dokumentum‑biztonság figyelmen kívül hagyása

A probléma: Jelszó‑védett vagy titkosított dokumentumok összehasonlítása megfelelő hitelesítés nélkül.

A megoldás: Implementálj dokumentum‑biztonság‑detektálást és kezelést:

// GroupDocs.Comparison can handle password-protected documents
// Just ensure you have the necessary credentials available

Csapda #5: teljesítményromlás terhelés alatt

A probléma: A megoldás néhány dokumentummal jól működik, de nagy mennyiség esetén drámaian lelassul.

A megoldás: Már az elejétől implementálj teljesítmény‑monitorozást és skálázási stratégiákat, ne csak a problémák után.

Teljesítményoptimalizálás: villámgyors működés

Amikor a document comparison .NET automation-t nagy léptékben valósítod meg, a teljesítmény kritikus. Íme a legnagyobb hatású optimalizációs stratégiák:

Okos erőforrás‑kezelés

A magas teljesítmény kulcsa a hatékony erőforrás‑használat:

  • Stream‑kezelés: Használj stream‑eket a teljes fájl betöltése helyett
  • Párhuzamos feldolgozás: Használd ki a több CPU‑magot a kötegelt műveleteknél
  • Garbage collection: Minimalizáld az objektum‑létrehozást szoros hurkokban

Benchmark eredmények

Tesztjeink egy tipikus üzleti dokumentumkeverékkel:

  • Kis dokumentumok (1‑10 oldal): ~0,5 s összehasonlításonként
  • Közepes dokumentumok (10‑50 oldal): ~2‑5 s összehasonlításonként
  • Nagy dokumentumok (50+ oldal): ~10‑30 s összehasonlításonként

Ezek az idők lineárisan skálázódnak—100 dokumentumpár összehasonlítása körülbelül 100‑szoros időt vesz igénybe egyetlen párhoz képest.

Memória‑optimalizálási tippek

  • Dolgozd fel a dokumentumokat kisebb kötegekben a memória‑kimerülés elkerülése érdekében
  • Nagyon nagy fájlok (100 MB+) esetén használj streaming API‑kat
  • Alkalmazz megfelelő felszabadítási mintákat a memória‑szivárgások megelőzésére

Integrációs stratégiák: beillesztés a meglévő munkafolyamatba

A automate document review .NET megoldásnak zökkenőmentesen kell együttműködnie a meglévő rendszerekkel. Íme, hogyan integrálhatod könnyedén:

Adatbázis‑integráció

Tárold az összehasonlítás metaadatait és eredményeit:

public class ComparisonRecord
{
    public int Id { get; set; }
    public string SourceDocument { get; set; }
    public List<string> TargetDocuments { get; set; }
    public DateTime ComparisonDate { get; set; }
    public string ResultDocument { get; set; }
}

Web‑alkalmazás integráció

Csomagold be az összehasonlítási logikát REST API‑kba a web‑alkalmazás hozzáféréséhez:

  • Feltöltési végpontok: Dokumentumok feltöltése
  • Feldolgozási végpontok: Összehasonlítások sorba állítása és végrehajtása
  • Állapot‑végpontok: Az összehasonlítás előrehaladásának nyomon követése
  • Letöltési végpontok: Az összehasonlítási eredmények letöltése

Vállalati rendszer integráció

Kapcsold össze dokumentum‑kezelő rendszerekkel, workflow‑motorokkal és értesítési szolgáltatásokkal, hogy vég‑től‑vég automatizálást hozz létre.

Hibaelhárítási útmutató: amikor valami nem működik

Még a legjobb document comparison automation is néha elakadhat. Íme a hibaelhárítási kézikönyved:

Probléma: az összehasonlítás túl sokáig tart

Tünetek: A folyamat akadozik vagy órákig tart
Lehetséges okok: Nagyon nagy dokumentumok, elégtelen memória, vagy hálózati problémák
Megoldások:

  • Nagy dokumentumokat szakaszokra bontás
  • Memória növelése
  • Időtúllépés‑mechanizmusok bevezetése

Probléma: az összehasonlítási eredmények hibásak

Tünetek: Hiányzó változások vagy hamis pozitív eredmények
Lehetséges okok: Dokumentumformátum‑problémák vagy érzékenységi beállítások
Megoldások:

  • Ellenőrizd, hogy a dokumentumformátumok támogatottak-e
  • Állítsd be a összehasonlítás érzékenységét
  • Tesztelj ismert dokumentumpárokkal a várt viselkedés validálásához

Probléma: memória‑kivétel

Tünetek: OutOfMemoryException a feldolgozás közben
Lehetséges okok: Túl sok nagy dokumentum egyidejű feldolgozása
Megoldások:

  • Kötegelt feldolgozás bevezetése
  • Streaming API‑k használata nagy fájlokhoz
  • Az alkalmazás memória‑allokációjának növelése

Haladó konfigurációs lehetőségek

Miután magabiztosan kezeled az alapokat, fedezd fel ezeket a haladó GroupDocs comparison tutorial C# funkciókat:

Egyedi összehasonlítási beállítások

Finomhangold, hogyan észleli és jeleníti meg a különbségeket:

  • Érzékenységi szintek: Szabályozd, milyen részletességgel legyen a változásdetektálás
  • Kihagyási opciók: Hagyj ki bizonyos változástípusokat (formázás, szóközök stb.)
  • Kimeneti formázás: Testreszabhatod, hogyan jelenjenek meg a különbségek a végeredmény‑dokumentumban

Formátumspecifikus optimalizációk

Különböző dokumentumtípusok különböző összehasonlítási megközelítéseket igényelnek:

  • Word dokumentumok: Szöveg‑ és formázási változásokra fókuszál
  • PDF fájlok: Elrendezés‑ és vizuális eltérések kiemelése
  • Excel táblázatok: Adat‑ és képlet‑változások kiemelése
  • PowerPoint prezentációk: Diák tartalmának és dizájnjának nyomon követése

Gyakran ismételt kérdések

Q: Össze tudok-e hasonlítani különböző formátumú dokumentumokat?
A: Teljesen! A GroupDocs.Comparison támogatja a kereszt‑formátumú összehasonlítást a Word, PDF, Excel, PowerPoint és számos egyéb formátum között. Ez a rugalmasság az egyik fő előnye a speciális, egyformátumú megoldásokkal szemben.

Q: Hogyan kezeljem a nagy mennyiségű dokumentumot hatékonyan?
A: Alkalmazz kötegelt feldolgozást és fontold meg az aszinkron műveleteket nagy‑volumen esetén. Dolgozd fel a dokumentumokat 10‑20‑as csoportokban a mérettől és a rendelkezésre álló memória mennyiségétől függően, és használj streaming API‑kat a nagyon nagy fájlok optimalizálásához.

Q: Van korlátozás a egyszerre összehasonlítható dokumentumok számában?
A: A könyvtár nem szab szigorú határt, a gyakorlati korlátok a rendszer erőforrásaitól függenek. Legjobb teljesítmény érdekében 20‑50 dokumentumot javaslunk kötegenként, a dokumentum méretétől és a rendelkezésre álló memória mennyiségétől függően.

Q: Melyek a leggyakoribb beállítási problémák a GroupDocs.Comparison‑nal?
A: A leggyakoribb hibák általában fájl‑útvonal‑problémák (használj abszolút útvonalakat a termelésben), memória‑kezelés (mindig using‑t használj) és formátum‑kompatibilitás (ellenőrizd a támogatott formátumokat, mielőtt feldolgozod). A hibaelhárítási útmutatónk segít ezeket elkerülni.

Q: Hogyan viszonyul az automatizált összehasonlítás pontossága a manuális felülvizsgálathoz?
A: Az automatizált összehasonlítás általában 99,9%-ban elkapja a változásokat, szemben a 80‑85%-os pontossággal a manuális felülvizsgálatnál. A motor soha nem fárad el vagy vesz el a figyelme, így nagy mennyiségben is következetesen alapos.

Q: Hol találok részletes API‑dokumentációt?
A: A GroupDocs.Comparison Documentation átfogó útmutatókat és tutorial‑okat tartalmaz, míg a API Reference lefedi az összes osztályt és metódust. Gyakorlati támogatásért a Community Support fórumot is aktívan felügyeli a fejlesztői csapat.

Q: Integrálhatom-e ezt egy webszolgáltatásba?
A: Igen. Csomagold be az összehasonlítási logikát egy REST‑API‑ba, tárold az eredményeket adatbázisban, és biztosíts végpontokat a feltöltéshez, feldolgozáshoz, állapotkövetéshez és letöltéshez. Ez lehetővé teszi a könnyű fogyasztást web‑, mobil‑ vagy asztali kliensekből.

Q: Támogatja a könyvtár a jelszó‑védett fájlokat?
A: A GroupDocs.Comparison képes kezelni a jelszó‑védett dokumentumokat; csak a fájl‑stream megnyitásakor kell megadni a jelszót.

Fontos források

Utoljára frissítve: 2026-09-25
Tesztelve: GroupDocs.Comparison 25.4.0 for .NET
Szerző: GroupDocs

Kapcsolódó tutorialok