Einführung

Textsignaturen sind zwar oft einfacher als digitale oder elektronische Signaturen, spielen aber eine entscheidende Rolle bei der Dokumentenverwaltung und -überprüfung. Ob Wasserzeichen, Fußzeilentext oder bestimmte Inhaltsmuster – die Validierung des Vorhandenseins und der Integrität von Textsignaturen ist ein wichtiger Aspekt der Dokumentenüberprüfung.

GroupDocs.Signature für .NET bietet eine leistungsstarke API zur Überprüfung von Textsignaturen in Dokumenten unterschiedlichster Formate. Dieses umfassende Tutorial führt Sie durch die Implementierung der Textüberprüfungsfunktion in Ihren .NET-Anwendungen und stellt so die Integrität und Authentizität Ihrer Dokumente sicher.

Voraussetzungen

Stellen Sie vor der Implementierung der Textüberprüfungsfunktion sicher, dass die folgenden Voraussetzungen erfüllt sind:

GroupDocs.Signature für .NET: Laden Sie die Bibliothek herunter und installieren Sie sie von der Download-Seite.
.NET-Entwicklungsumgebung: Visual Studio oder eine andere kompatible .NET-Entwicklungsumgebung.
Grundkenntnisse: Vertrautheit mit der C#-Programmierung und den Konzepten des .NET-Frameworks.
Testdokument: Ein Dokument, das Textsignaturen zu Überprüfungszwecken enthält.

Erforderliche Namespaces importieren

Beginnen Sie mit dem Importieren der erforderlichen Namespaces, um auf die GroupDocs.Signature-Funktionalität zuzugreifen:

using System;
using GroupDocs.Signature;
using GroupDocs.Signature.Domain;
using GroupDocs.Signature.Options;

Lassen Sie uns den Textüberprüfungsprozess in klare, überschaubare Schritte unterteilen:

Schritt 1: Dokumentpfad angeben

// Pfad zum Dokument mit Textsignaturen
string filePath = "sample_multiple_signatures.docx";

Stellen Sie sicher, dass Sie den Beispielpfad durch den tatsächlichen Pfad zu Ihrem Dokument mit den Textsignaturen ersetzen.

Schritt 2: Initialisieren des Signaturobjekts

// Erstellen Sie eine Instanz der Signature-Klasse, indem Sie den Dokumentpfad übergeben
using (Signature signature = new Signature(filePath))
{
    // Der Verifizierungscode wird hier implementiert
}

Die Signature-Klasse ist der Haupteinstiegspunkt für alle Vorgänge in der GroupDocs.Signature-API.

Schritt 3: Konfigurieren Sie die Textüberprüfungsoptionen

// Definieren Sie Optionen zur Textüberprüfung
TextVerifyOptions options = new TextVerifyOptions()
{
    AllPages = true,                               // Überprüfen Sie alle Seiten des Dokuments
    SignatureImplementation = TextSignatureImplementation.Native,
    Text = "signature",                            // Zu überprüfender Text
    MatchType = TextMatchType.Contains             // Übereinstimmungskriterien angeben
};

Mit den Verifizierungsoptionen können Sie bestimmte Kriterien für den Verifizierungsprozess festlegen:

AllPages: Auf „true“ setzen, um alle Dokumentseiten zu prüfen
SignatureImplementation: Geben Sie an, wie der Text implementiert wird (Native oder Sticker)
Text: Der Textinhalt, der innerhalb des Dokuments übereinstimmen soll
MatchType: Die Methode für die Textübereinstimmung (Enthält, Genau, BeginntMit usw.)

Schritt 4: Verifizierungsprozess durchführen

// Überprüfung durchführen
VerificationResult result = signature.Verify(options);

Dadurch wird der Überprüfungsprozess basierend auf den von Ihnen angegebenen Optionen ausgeführt.

Schritt 5: Ergebnisse der Prozessüberprüfung

// Überprüfen Sie das Verifizierungsergebnis und verarbeiten Sie es entsprechend
if (result.IsValid)
{
    Console.WriteLine($"Document {filePath} contains valid text signatures!");
    
    // Informationen zu erfolgreichen Signaturen anzeigen
    foreach (TextSignature textSignature in result.Succeeded)
    {
        Console.WriteLine($"\nFound valid text signature:");
        Console.WriteLine($"Text: {textSignature.Text}");
        Console.WriteLine($"Location: Page {textSignature.PageNumber}, {textSignature.Left}x{textSignature.Top}");
    }
}
else
{
    Console.WriteLine($"Document {filePath} failed verification process.");
    Console.WriteLine($"Number of failed signatures: {result.Failed.Count}");
}

Dieser Code prüft, ob die Überprüfung erfolgreich war und liefert detaillierte Informationen zu den überprüften Textsignaturen.

Vollständiges Beispiel

Hier ist ein vollständiges funktionierendes Beispiel, das die Überprüfung von Textsignaturen demonstriert:

using System;
using GroupDocs.Signature;
using GroupDocs.Signature.Domain;
using GroupDocs.Signature.Options;

namespace GroupDocs.Signature.Examples
{
    class Program
    {
        static void Main(string[] args)
        {
            // Dokumentpfad
            string filePath = "sample_multiple_signatures.docx";
            
            try
            {
                // Signaturinstanz initialisieren
                using (Signature signature = new Signature(filePath))
                {
                    // Optionen zur Einrichtung der Überprüfung
                    TextVerifyOptions options = new TextVerifyOptions()
                    {
                        AllPages = true,
                        SignatureImplementation = TextSignatureImplementation.Native,
                        Text = "signature",
                        MatchType = TextMatchType.Contains
                    };
                    
                    // Dokumentsignaturen überprüfen
                    VerificationResult result = signature.Verify(options);
                    
                    // Ergebnisse der Prozessüberprüfung
                    if(result.IsValid)
                    {
                        Console.WriteLine($"\nDocument {filePath} was verified successfully!");
                        foreach (TextSignature item in result.Succeeded)
                        {
                            Console.WriteLine($"\nValid signature is found with text: {item.Text}");
                            Console.WriteLine($"Location: Page {item.PageNumber}, position {item.Left}x{item.Top}");
                        }
                    }
                    else
                    {
                        Console.WriteLine($"\nDocument {filePath} failed verification process.");
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
        }
    }
}

Erweiterte Verifizierungsszenarien

GroupDocs.Signature bietet zusätzliche Optionen für komplexere Überprüfungsszenarien:

Verwenden regulärer Ausdrücke zur Überprüfung

Für eine flexiblere Mustererkennung können Sie reguläre Ausdrücke verwenden:

TextVerifyOptions options = new TextVerifyOptions()
{
    Text = "Invoice\\s+#\\d{5,6}",  // Muster wie „Rechnung Nr. 12345“ abgleichen
    MatchType = TextMatchType.Regex
};

Überprüfen von Text in bestimmten Dokumentbereichen

Sie können die Überprüfung auf bestimmte Bereiche des Dokuments beschränken:

TextVerifyOptions options = new TextVerifyOptions()
{
    AllPages = false,
    PageNumber = 1,  // Nur auf der ersten Seite überprüfen
    
    // Definieren Sie den Suchbereich (Koordinaten in Punkten)
    PagesSetup = new PagesSetup() 
    { 
        FirstPage = true,
        LastPage = false,
        OddPages = false,
        EvenPages = false 
    },
    
    // Rechteckfläche in Millimetern
    Rectangle = new Rectangle(10, 10, 100, 30),
    
    Text = "Confidential"
};

Gleichzeitiges Überprüfen mehrerer Textmuster

Sie können mehrere Überprüfungsoptionen erstellen, um nach verschiedenen Textmustern zu suchen:

// Erstellen Sie eine Liste mit Überprüfungsoptionen
List<VerifyOptions> listOptions = new List<VerifyOptions>();

// Erste Textüberprüfung hinzufügen
listOptions.Add(new TextVerifyOptions()
{
    Text = "Confidential",
    MatchType = TextMatchType.Exact
});

// Zweite Textüberprüfung hinzufügen
listOptions.Add(new TextVerifyOptions()
{
    Text = "Do not copy",
    MatchType = TextMatchType.Contains
});

// Mit mehreren Optionen überprüfen
VerificationResult result = signature.Verify(listOptions);

Überprüfen von Text mit einem bestimmten Erscheinungsbild

Sie können auch Text mit bestimmten Formatierungsmerkmalen überprüfen:

TextVerifyOptions options = new TextVerifyOptions()
{
    Text = "APPROVED",
    MatchType = TextMatchType.Exact,
    
    // Überprüfen bestimmter Darstellungseigenschaften
    ForegroundColorRGB = System.Drawing.Color.Green,
    Font = new SignatureFont() { FontFamily = "Arial", FontSize = 12, Bold = true }
};

Best Practices für die Textüberprüfung

Wählen Sie geeignete Übereinstimmungstypen: Wählen Sie basierend auf Ihren Überprüfungsanforderungen den richtigen Übereinstimmungstyp (Enthält, Genau, Regulärer Ausdruck) aus.
Leistungsoptimierung: Erwägen Sie bei großen Dokumenten die Überprüfung bestimmter Seiten statt des gesamten Dokuments.
Fehlerbehandlung: Implementieren Sie eine geeignete Fehlerbehandlung, um unerwartete Szenarien reibungslos zu bewältigen.
Berücksichtigen Sie die Groß./Kleinschreibung: Achten Sie beim Textabgleich auf die Groß./Kleinschreibung, insbesondere bei kritischen Überprüfungen.
Gründlich testen: Testen Sie die Überprüfung mit verschiedenen Dokumentformaten und Textmustern, um die Kompatibilität sicherzustellen.

Fehlerbehebung bei häufigen Problemen

Text nicht erkannt

Überprüfen Sie, ob die Textformatierung oder -kodierung die Erkennung beeinträchtigt
Stellen Sie sicher, dass der Text tatsächlich als normaler Text (kein Bild) im Dokument vorhanden ist.
Probieren Sie verschiedene Übereinstimmungskriterien aus (Enthält statt Genau)

Leistungsprobleme

Optimieren Sie die Verifizierung, indem Sie bestimmte Seiten oder Bereiche ansprechen
Verwenden Sie spezifischere Textmuster, um Fehlalarme zu reduzieren

Überprüfungsfehler

Überprüfen Sie, ob Leerzeichen, Sonderzeichen oder Formatierungen die Übereinstimmung beeinflussen
Überprüfen Sie, ob der Text Teil eines gescannten Bildes ist (wofür OCR erforderlich ist).
Stellen Sie sicher, dass das Dokument seit dem Hinzufügen des Textes nicht geändert wurde

Abschluss

Die Textverifizierung ist ein vielseitiger und praktischer Ansatz zur Dokumentenauthentifizierung, der allein oder in Kombination mit anderen Verifizierungsmethoden verwendet werden kann. GroupDocs.Signature für .NET bietet eine umfassende und benutzerfreundliche API zur Implementierung robuster Textverifizierungsfunktionen in Ihren .NET-Anwendungen.

Indem Sie dieser Schritt-für-Schritt-Anleitung folgen, haben Sie Folgendes gelernt:

Konfigurieren und initialisieren Sie den Textüberprüfungsprozess
Legen Sie verschiedene Überprüfungskriterien fest
Verifizierungsergebnisse verarbeiten und interpretieren
Implementieren Sie erweiterte Überprüfungsszenarien

Mit diesen Funktionen können Sie sichere und zuverlässige Dokumentenverarbeitungssysteme erstellen, die die Authentizität von Texten in verschiedenen Dokumentformaten überprüfen können.

FAQs

Kann GroupDocs.Signature Text in gescannten Dokumenten überprüfen?

GroupDocs.Signature ist in erster Linie für die digitale Textüberprüfung konzipiert. Für gescannte Dokumente müssen Sie zunächst die OCR-Technologie (Optical Character Recognition) verwenden, um die gescannten Bilder in Text umzuwandeln.

Welche Dokumentformate werden für die Textüberprüfung unterstützt?

GroupDocs.Signature unterstützt eine Vielzahl von Dokumentformaten, darunter PDF, Word-Dokumente (DOC, DOCX), Excel-Tabellen (XLS, XLSX), PowerPoint-Präsentationen (PPT, PPTX), Bilder und mehr.

Kann ich formatierten Text (Fettdruck, Kursivdruck, bestimmte Schriftarten) überprüfen?

Ja, GroupDocs.Signature bietet Optionen zum Überprüfen von Text mit bestimmten Formatierungsmerkmalen, einschließlich Schriftart, Größe, Stil (fett, kursiv) und Farbe.

Ist es möglich, Text in passwortgeschützten Dokumenten zu überprüfen?

Ja, GroupDocs.Signature bietet Optionen zum Festlegen von Dokumentkennwörtern beim Öffnen geschützter Dokumente zur Überprüfung.

Kann ich Wasserzeichen und Hintergrundtext überprüfen?

Ja, GroupDocs.Signature kann verschiedene Arten von Textsignaturen überprüfen, einschließlich Wasserzeichen und Hintergrundtext, je nachdem, wie sie im Dokument implementiert wurden.