Introduktion

Textsignaturer, även om de ofta är enklare än digitala eller elektroniska signaturer, spelar en avgörande roll i dokumenthantering och verifiering. Oavsett om det är vattenstämplar, sidfotstext eller specifika innehållsmönster, är validering av textsignaturers närvaro och integritet en viktig aspekt av dokumentverifieringsprocesser.

GroupDocs.Signature för .NET tillhandahåller ett kraftfullt API för att verifiera textsignaturer i dokument i en mängd olika format. Denna omfattande handledning guidar dig genom implementeringen av textverifieringsfunktioner i dina .NET-applikationer, vilket säkerställer att dina dokument bibehåller sin integritet och autenticitet.

Förkunskapskrav

Innan du implementerar textverifieringsfunktionen, se till att du har följande förutsättningar på plats:

  1. GroupDocs.Signature för .NET: Ladda ner och installera biblioteket från nedladdningssida.
  2. .NET-utvecklingsmiljö: Visual Studio eller annan kompatibel .NET-utvecklingsmiljö.
  3. Grundläggande kunskaper: Bekantskap med C#-programmering och .NET Framework-koncept.
  4. Testdokument: Ett dokument som innehåller textsignaturer för verifieringsändamål.

Importera obligatoriska namnrymder

Börja med att importera de namnrymder som behövs för att komma åt GroupDocs.Signature-funktionen:

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

Låt oss dela upp textverifieringsprocessen i tydliga, hanterbara steg:

Steg 1: Ange dokumentsökvägen

// Sökväg till dokumentet som innehåller textsignaturer
string filePath = "sample_multiple_signatures.docx";

Se till att du ersätter exempelsökvägen med den faktiska sökvägen till ditt dokument som innehåller textsignaturer.

Steg 2: Initiera signaturobjektet

// Skapa en instans av Signature-klassen genom att skicka dokumentsökvägen
using (Signature signature = new Signature(filePath))
{
    // Verifieringskoden kommer att implementeras här
}

Signature-klassen är den huvudsakliga ingångspunkten för alla operationer i GroupDocs.Signature API:et.

Steg 3: Konfigurera alternativ för textverifiering

// Definiera alternativ för textverifiering
TextVerifyOptions options = new TextVerifyOptions()
{
    AllPages = true,                               // Kontrollera alla sidor i dokumentet
    SignatureImplementation = TextSignatureImplementation.Native,
    Text = "signature",                            // Text som ska verifieras
    MatchType = TextMatchType.Contains             // Ange matchningskriterier
};

Verifieringsalternativen låter dig definiera specifika kriterier för verifieringsprocessen:

  • AllPagesAnge till sant för att kontrollera alla dokumentsidor
  • SignatureImplementationAnge hur texten implementeras (inbyggd eller klistermärke)
  • TextTextinnehållet som ska matchas i dokumentet
  • MatchTypeMetoden för textmatchning (Innehåller, Exakt, BörjarMed, etc.)

Steg 4: Utför verifieringsprocessen

// Utför verifiering
VerificationResult result = signature.Verify(options);

Detta utför verifieringsprocessen baserat på de alternativ du har angett.

Steg 5: Resultat av processverifiering

// Kontrollera verifieringsresultatet och bearbeta därefter
if (result.IsValid)
{
    Console.WriteLine($"Document {filePath} contains valid text signatures!");
    
    // Visa information om lyckade signaturer
    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}");
}

Den här koden kontrollerar om verifieringen lyckades och ger detaljerad information om de textsignaturer som verifierades.

Komplett exempel

Här är ett komplett fungerande exempel som demonstrerar verifiering av textsignaturer:

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

namespace GroupDocs.Signature.Examples
{
    class Program
    {
        static void Main(string[] args)
        {
            // Dokumentsökväg
            string filePath = "sample_multiple_signatures.docx";
            
            try
            {
                // Initiera signaturinstansen
                using (Signature signature = new Signature(filePath))
                {
                    // Verifieringsalternativ för konfigurering
                    TextVerifyOptions options = new TextVerifyOptions()
                    {
                        AllPages = true,
                        SignatureImplementation = TextSignatureImplementation.Native,
                        Text = "signature",
                        MatchType = TextMatchType.Contains
                    };
                    
                    // Verifiera dokumentsignaturer
                    VerificationResult result = signature.Verify(options);
                    
                    // Resultat av processverifiering
                    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}");
            }
        }
    }
}

Avancerade verifieringsscenarier

GroupDocs.Signature erbjuder ytterligare alternativ för mer komplexa verifieringsscenarier:

Använda reguljära uttryck för verifiering

För mer flexibel mönstermatchning kan du använda reguljära uttryck:

TextVerifyOptions options = new TextVerifyOptions()
{
    Text = "Invoice\\s+#\\d{5,6}",  // Matchmönster som "Faktura #12345"
    MatchType = TextMatchType.Regex
};

Verifiera text i specifika dokumentområden

Du kan begränsa verifieringen till specifika områden i dokumentet:

TextVerifyOptions options = new TextVerifyOptions()
{
    AllPages = false,
    PageNumber = 1,  // Verifiera endast på första sidan
    
    // Definiera område att söka i (koordinater i punkter)
    PagesSetup = new PagesSetup() 
    { 
        FirstPage = true,
        LastPage = false,
        OddPages = false,
        EvenPages = false 
    },
    
    // Rektangelarea i millimeter
    Rectangle = new Rectangle(10, 10, 100, 30),
    
    Text = "Confidential"
};

Verifiera flera textmönster samtidigt

Du kan skapa flera verifieringsalternativ för att kontrollera olika textmönster:

// Skapa en lista med verifieringsalternativ
List<VerifyOptions> listOptions = new List<VerifyOptions>();

// Lägg till första sms-verifiering
listOptions.Add(new TextVerifyOptions()
{
    Text = "Confidential",
    MatchType = TextMatchType.Exact
});

// Lägg till en andra sms-verifiering
listOptions.Add(new TextVerifyOptions()
{
    Text = "Do not copy",
    MatchType = TextMatchType.Contains
});

// Verifiera med flera alternativ
VerificationResult result = signature.Verify(listOptions);

Verifiera text med specifikt utseende

Du kan också verifiera text med specifika formateringsegenskaper:

TextVerifyOptions options = new TextVerifyOptions()
{
    Text = "APPROVED",
    MatchType = TextMatchType.Exact,
    
    // Verifiera specifika utseendeegenskaper
    ForegroundColorRGB = System.Drawing.Color.Green,
    Font = new SignatureFont() { FontFamily = "Arial", FontSize = 12, Bold = true }
};

Bästa praxis för textverifiering

  1. Välj lämpliga matchningstyper: Välj rätt matchningstyp (Innehåller, Exakt, Regex) baserat på dina verifieringskrav.
  2. Optimera för prestanda: För stora dokument, överväg att verifiera specifika sidor snarare än hela dokumentet.
  3. Felhantering: Implementera korrekt felhantering för att hantera oväntade scenarier på ett smidigt sätt.
  4. Tänk på skiftlägeskänslighet: Var uppmärksam på skiftlägeskänslighet vid textmatchning, särskilt för viktiga verifieringar.
  5. Testa noggrant: Testa verifiering med olika dokumentformat och textmönster för att säkerställa kompatibilitet.

Felsökning av vanliga problem

Texten upptäcktes inte

  • Kontrollera om textformateringen eller kodningen påverkar detekteringen
  • Se till att texten faktiskt finns i dokumentet som vanlig text (inte en bild)
  • Prova olika matchningskriterier (Innehåller istället för Exakt)

Prestandaproblem

  • Optimera verifieringen genom att rikta in dig på specifika sidor eller områden
  • Använd mer specifika textmönster för att minska falska positiva resultat

Verifieringsfel

  • Kontrollera om mellanslag, specialtecken eller formatering påverkar matchningen
  • Kontrollera att texten inte är en del av en skannad bild (vilket kräver OCR)
  • Se till att dokumentet inte har ändrats sedan texten lades till

Slutsats

Textverifiering är en mångsidig och praktisk metod för dokumentautentisering som kan användas ensam eller i kombination med andra verifieringsmetoder. GroupDocs.Signature för .NET tillhandahåller ett omfattande och lättanvänt API för att implementera robust textverifieringsfunktionalitet i dina .NET-applikationer.

Genom att följa den här steg-för-steg-guiden har du lärt dig hur du:

  • Konfigurera och initiera textverifieringsprocessen
  • Ange olika verifieringskriterier
  • Bearbeta och tolka verifieringsresultat
  • Implementera avancerade verifieringsscenarier

Dessa funktioner låter dig bygga säkra och tillförlitliga dokumentbehandlingssystem som kan verifiera textens äkthet i olika dokumentformat.

Vanliga frågor

Kan GroupDocs.Signature verifiera text i skannade dokument?

GroupDocs.Signature är främst utformat för verifiering av digital text. För skannade dokument behöver du först använda OCR-teknik (optisk teckenigenkänning) för att konvertera de skannade bilderna till text.

Vilka dokumentformat stöds för textverifiering?

GroupDocs.Signature stöder en mängd olika dokumentformat, inklusive PDF, Word-dokument (DOC, DOCX), Excel-kalkylblad (XLS, XLSX), PowerPoint-presentationer (PPT, PPTX), bilder och mer.

Kan jag verifiera formaterad text (fet, kursiv, specifika teckensnitt)?

Ja, GroupDocs.Signature erbjuder alternativ för att verifiera text med specifika formateringsegenskaper, inklusive teckensnittsfamilj, storlek, stil (fet, kursiv stil och färg).

Är det möjligt att verifiera text i lösenordsskyddade dokument?

Ja, GroupDocs.Signature erbjuder alternativ för att ange dokumentlösenord när skyddade dokument öppnas för verifiering.

Kan jag verifiera vattenstämplar och bakgrundstext?

Ja, GroupDocs.Signature kan verifiera olika typer av textsignaturer, inklusive vattenstämplar och bakgrundstext, beroende på hur de implementerades i dokumentet.

Relaterade resurser