Snabbstart: SDK v3.0 för C#-klientbiblioteket | Förhandsgranska

Referensdokumentation | Bibliotekskällkod | Paket (NuGet) | Prover

Kom igång med Azure Formigenkänning med programmeringsspråket C#. Azure Formigenkänning är en molnbaserad Azure Applied AI-tjänst som använder maskininlärning för att extrahera och analysera formulärfält, text och tabeller från dina dokument. Du kan enkelt anropa Formigenkänning modeller genom att integrera våra klientbiblioteks-SDks i dina arbetsflöden och program. Vi rekommenderar att du använder den kostnadsfria tjänsten när du lär dig tekniken. Kom ihåg att antalet kostnadsfria sidor är begränsat till 500 per månad.

Mer information om Formigenkänning och utvecklingsalternativ finns på översiktssidan.

I den här snabbstarten använder du följande funktioner för att analysera och extrahera data och värden från formulär och dokument:

• 🆕 allmänt dokument– Analysera och extrahera text, tabeller, struktur, nyckel/värde-par och namngivna entiteter.

• Layout– Analysera och extrahera tabeller, linjer, ord och markeringsmarkeringar som alternativknappar och kryssrutor i formulärdokument, utan att du behöver träna en modell.

• Förbyggd modell (faktura) Analysera och extrahera vanliga fält från fakturor med hjälp av en förtränad fakturamodell.

Förutsättningar

• Azure-prenumeration – Skapa en kostnadsfritt.

• Den aktuella versionen av Visual Studio IDE.

• En Cognitive Services eller Formigenkänning resurs. När du har din Azure-prenumeration kan du skapa en resurs för Formigenkänning tjänst eller flera tjänster i Azure Portal för att hämta din nyckel och slutpunkt. Du kan använda den kostnadsfria prisnivån ( F0 ) för att prova tjänsten och senare uppgradera till en betald nivå för produktion.

• När resursen har distribuerats väljer du Gå till resurs. Du behöver nyckeln och slutpunkten från den resurs som du skapar för att ansluta ditt program till Formigenkänning-API:et. Du klistrar in nyckeln och slutpunkten i koden nedan senare i snabbstarten:

  

Konfigurera

1. Starta Visual Studio 2019.

2. På startsidan väljer du Skapa ett nytt projekt.

   

3. På sidan Skapa ett nytt projekt anger du konsolen i sökrutan. Välj mallen Konsolprogram och välj sedan Nästa.

   

4. I dialogrutan Konfigurera ditt nya projekt anger du i Project formRecognizer_quickstart namn. Välj sedan Nästa.

   

5. I dialogrutan Ytterligare information väljer du .NET 5.0 (aktuell) och sedan Skapa.

   

Installera klientbiblioteket med NuGet

1. Högerklicka på ditt formRecognizer_quickstart och välj Hantera NuGet-paket... .

   

2. Välj fliken Bläddra och skriv Azure.AI.FormRecognizer.

   

3. Markera kryssrutan Inkludera förhandsversion.

4. Välj version 4.0.0-beta.1 i listrutan och välj Installera.

   

Skapa ditt program

Om du vill Formigenkänning-tjänsten måste du skapa en instans av DocumentAnalysisClient klassen . Det gör du genom att skapa en med AzureKeyCredential din apiKey och en DocumentAnalysisClient -instans med AzureKeyCredential och Formigenkänning endpoint .

1. Öppna filen Program.cs.

2. Ta med följande användningsdirektiv:

   using System;
   using System.Threading.Tasks;
   using Azure;
   using Azure.AI.FormRecognizer;
   using Azure.AI.FormRecognizer.DocumentAnalysis;
   

3. Ange endpoint apiKey miljövariablerna och och skapa AzureKeyCredential DocumentAnalysisClient instansen och :

   string endpoint = "<your-endpoint>";
   string apiKey = "<your-apiKey>";
   AzureKeyCredential credential = new AzureKeyCredential(apiKey);
   DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);
   

4. Ta bort raden Console.Writeline("Hello World!"); , och lägg till ett av Try It-kodexe exemplen i Main-metoden i filen Program.cs:

   

Välj ett kodexempel som du vill kopiera och klistra in i programmets Main-metod:

• Allmänt dokument

• Layout

• Fördefinierade fakturor

Prova: Allmän dokumentmodell

Lägg till följande kod i huvudmetoden för ditt allmänna dokumentprogram

// sample form document
string fileUri = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf";

AnalyzeDocumentOperation operation = await client.StartAnalyzeDocumentFromUriAsync("prebuilt-document", fileUri);

await operation.WaitForCompletionAsync();

AnalyzeResult result = operation.Value;

Console.WriteLine("Detected entities:");

foreach (DocumentEntity entity in result.Entities)
{
    if (entity.SubCategory == null)
    {
        Console.WriteLine($"  Found entity '{entity.Content}' with category '{entity.Category}'.");
    }
    else
    {
        Console.WriteLine($"  Found entity '{entity.Content}' with category '{entity.Category}' and sub-category '{entity.SubCategory}'.");
    }
}

Console.WriteLine("Detected key-value pairs:");

foreach (DocumentKeyValuePair kvp in result.KeyValuePairs)
{
    if (kvp.Value.Content == null)
    {
        Console.WriteLine($"  Found key with no value: '{kvp.Key.Content}'");
    }
    else
    {
        Console.WriteLine($"  Found key-value pair: '{kvp.Key.Content}' and '{kvp.Value.Content}'");
    }
}

foreach (DocumentPage page in result.Pages)
{
    Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
    Console.WriteLine($"and {page.SelectionMarks.Count} selection mark(s).");

    for (int i = 0; i < page.Lines.Count; i++)
    {
        DocumentLine line = page.Lines[i];
        Console.WriteLine($"  Line {i} has content: '{line.Content}'.");

        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {line.BoundingBox[0].X}, Y= {line.BoundingBox[0].Y}");
        Console.WriteLine($"      Upper right => X: {line.BoundingBox[1].X}, Y= {line.BoundingBox[1].Y}");
        Console.WriteLine($"      Lower right => X: {line.BoundingBox[2].X}, Y= {line.BoundingBox[2].Y}");
        Console.WriteLine($"      Lower left => X: {line.BoundingBox[3].X}, Y= {line.BoundingBox[3].Y}");
    }

    for (int i = 0; i < page.SelectionMarks.Count; i++)
    {
        DocumentSelectionMark selectionMark = page.SelectionMarks[i];

        Console.WriteLine($"  Selection Mark {i} is {selectionMark.State}.");
        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {selectionMark.BoundingBox[0].X}, Y= {selectionMark.BoundingBox[0].Y}");
        Console.WriteLine($"      Upper right => X: {selectionMark.BoundingBox[1].X}, Y= {selectionMark.BoundingBox[1].Y}");
        Console.WriteLine($"      Lower right => X: {selectionMark.BoundingBox[2].X}, Y= {selectionMark.BoundingBox[2].Y}");
        Console.WriteLine($"      Lower left => X: {selectionMark.BoundingBox[3].X}, Y= {selectionMark.BoundingBox[3].Y}");
    }
}

foreach (DocumentStyle style in result.Styles)
{
    // Check the style and style confidence to see if text is handwritten.
    // Note that value '0.8' is used as an example.

    bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;

    if (isHandwritten && style.Confidence > 0.8)
    {
        Console.WriteLine($"Handwritten content found:");

        foreach (DocumentSpan span in style.Spans)
        {
            Console.WriteLine($"  Content: {result.Content.Substring(span.Offset, span.Length)}");
        }
    }
}

Console.WriteLine("The following tables were extracted:");

for (int i = 0; i < result.Tables.Count; i++)
{
    DocumentTable table = result.Tables[i];
    Console.WriteLine($"  Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");

    foreach (DocumentTableCell cell in table.Cells)
    {
        Console.WriteLine($"    Cell ({cell.RowIndex}, {cell.ColumnIndex}) has kind '{cell.Kind}' and content: '{cell.Content}'.");
    }
}

Prova: Layoutmodell

Extrahera text, markeringsmarkeringar, textformat och tabellstrukturer, tillsammans med koordinaterna för deras avgränsande region från dokument.

Lägg till följande kod i main-metoden för layoutprogrammet

// sample form document
string fileUri = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-layout.pdf";

AnalyzeDocumentOperation operation = await client.StartAnalyzeDocumentFromUriAsync("prebuilt-layout", fileUri);

await operation.WaitForCompletionAsync();

AnalyzeResult result = operation.Value;

foreach (DocumentPage page in result.Pages)
{
    Console.WriteLine($"Document Page {page.PageNumber} has {page.Lines.Count} line(s), {page.Words.Count} word(s),");
    Console.WriteLine($"and {page.SelectionMarks.Count} selection mark(s).");

    for (int i = 0; i < page.Lines.Count; i++)
    {
        DocumentLine line = page.Lines[i];
        Console.WriteLine($"  Line {i} has content: '{line.Content}'.");

        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {line.BoundingBox[0].X}, Y= {line.BoundingBox[0].Y}");
        Console.WriteLine($"      Upper right => X: {line.BoundingBox[1].X}, Y= {line.BoundingBox[1].Y}");
        Console.WriteLine($"      Lower right => X: {line.BoundingBox[2].X}, Y= {line.BoundingBox[2].Y}");
        Console.WriteLine($"      Lower left => X: {line.BoundingBox[3].X}, Y= {line.BoundingBox[3].Y}");
    }

    for (int i = 0; i < page.SelectionMarks.Count; i++)
    {
        DocumentSelectionMark selectionMark = page.SelectionMarks[i];

        Console.WriteLine($"  Selection Mark {i} is {selectionMark.State}.");
        Console.WriteLine($"    Its bounding box is:");
        Console.WriteLine($"      Upper left => X: {selectionMark.BoundingBox[0].X}, Y= {selectionMark.BoundingBox[0].Y}");
        Console.WriteLine($"      Upper right => X: {selectionMark.BoundingBox[1].X}, Y= {selectionMark.BoundingBox[1].Y}");
        Console.WriteLine($"      Lower right => X: {selectionMark.BoundingBox[2].X}, Y= {selectionMark.BoundingBox[2].Y}");
        Console.WriteLine($"      Lower left => X: {selectionMark.BoundingBox[3].X}, Y= {selectionMark.BoundingBox[3].Y}");
    }
}

foreach (DocumentStyle style in result.Styles)
{
    // Check the style and style confidence to see if text is handwritten.
    // Note that value '0.8' is used as an example.

    bool isHandwritten = style.IsHandwritten.HasValue && style.IsHandwritten == true;

    if (isHandwritten && style.Confidence > 0.8)
    {
        Console.WriteLine($"Handwritten content found:");

        foreach (DocumentSpan span in style.Spans)
        {
            Console.WriteLine($"  Content: {result.Content.Substring(span.Offset, span.Length)}");
        }
    }
}

Console.WriteLine("The following tables were extracted:");

for (int i = 0; i < result.Tables.Count; i++)
{
    DocumentTable table = result.Tables[i];
    Console.WriteLine($"  Table {i} has {table.RowCount} rows and {table.ColumnCount} columns.");

    foreach (DocumentTableCell cell in table.Cells)
    {
        Console.WriteLine($"    Cell ({cell.RowIndex}, {cell.ColumnIndex}) has kind '{cell.Kind}' and content: '{cell.Content}'.");
    }
}

Prova: Förbyggd modell

Det här exemplet visar hur du analyserar data från vissa vanliga dokumenttyper med en förtränad modell med hjälp av en faktura som exempel.

Välj det fördefinierade fakturamodell-ID:t

Du är inte begränsad till fakturor – det finns flera fördefinierade modeller att välja mellan, där var och en har en egen uppsättning fält som stöds. Vilken modell som ska användas för analysåtgärden beror på vilken typ av dokument som ska analyseras. Här är modell-ID:erna för de fördefinierade modeller som för närvarande stöds av Formigenkänning tjänsten:

• prebuilt-invoice: extraherar text, markeringsmarkeringar, tabeller, nyckel/värde-par och nyckelinformation från fakturor.
• prebuilt-receipt: extraherar text- och nyckelinformation från kvitton.
• prebuilt-idDocument:extraherar text- och nyckelinformation från drivrutinslicenser och internationella pass.
• prebuilt-businessCard:extraherar text- och nyckelinformation från visitkort.

Lägg till följande kod i den fördefinierade huvudmetoden för fakturaprogrammet

// sample invoice document
string filePath = "(https://raw.githubusercontent.com/Azure-Samples/cognitive-services-REST-api-samples/master/curl/form-recognizer/sample-invoice.pdf";

using var stream = new FileStream(filePath, FileMode.Open);

AnalyzeDocumentOperation operation = await client.StartAnalyzeDocumentAsync("prebuilt-invoice", stream);

await operation.WaitForCompletionAsync();

AnalyzeResult result = operation.Value;

for (int i = 0; i < result.Documents.Count; i++)
{
    Console.WriteLine($"Document {i}:");

    AnalyzedDocument document = result.Documents[i];

    if (document.Fields.TryGetValue("VendorName", out DocumentField vendorNameField))
    {
        if (vendorNameField.ValueType == DocumentFieldType.String)
        {
            string vendorName = vendorNameField.AsString();
            Console.WriteLine($"Vendor Name: '{vendorName}', with confidence {vendorNameField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("CustomerName", out DocumentField customerNameField))
    {
        if (customerNameField.ValueType == DocumentFieldType.String)
        {
            string customerName = customerNameField.AsString();
            Console.WriteLine($"Customer Name: '{customerName}', with confidence {customerNameField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("Items", out DocumentField itemsField))
    {
        if (itemsField.ValueType == DocumentFieldType.List)
        {
            foreach (DocumentField itemField in itemsField.AsList())
            {
                Console.WriteLine("Item:");

                if (itemField.ValueType == DocumentFieldType.Dictionary)
                {
                    IReadOnlyDictionary<string, DocumentField> itemFields = itemField.AsDictionary();

                    if (itemFields.TryGetValue("Description", out DocumentField itemDescriptionField))
                    {
                        if (itemDescriptionField.ValueType == DocumentFieldType.String)
                        {
                            string itemDescription = itemDescriptionField.AsString();

                            Console.WriteLine($"  Description: '{itemDescription}', with confidence {itemDescriptionField.Confidence}");
                        }
                    }

                    if (itemFields.TryGetValue("Amount", out DocumentField itemAmountField))
                    {
                        if (itemAmountField.ValueType == DocumentFieldType.Double)
                        {
                            double itemAmount = itemAmountField.AsDouble();

                            Console.WriteLine($"  Amount: '{itemAmount}', with confidence {itemAmountField.Confidence}");
                        }
                    }
                }
            }
        }
    }

    if (document.Fields.TryGetValue("SubTotal", out DocumentField subTotalField))
    {
        if (subTotalField.ValueType == DocumentFieldType.Double)
        {
            double subTotal = subTotalField.AsDouble();
            Console.WriteLine($"Sub Total: '{subTotal}', with confidence {subTotalField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("TotalTax", out DocumentField totalTaxField))
    {
        if (totalTaxField.ValueType == DocumentFieldType.Double)
        {
            double totalTax = totalTaxField.AsDouble();
            Console.WriteLine($"Total Tax: '{totalTax}', with confidence {totalTaxField.Confidence}");
        }
    }

    if (document.Fields.TryGetValue("InvoiceTotal", out DocumentField invoiceTotalField))
    {
        if (invoiceTotalField.ValueType == DocumentFieldType.Double)
        {
            double invoiceTotal = invoiceTotalField.AsDouble();
            Console.WriteLine($"Invoice Total: '{invoiceTotal}', with confidence {invoiceTotalField.Confidence}");
        }
    }
}

Köra ditt program

Välj den gröna Start-knappen bredvid formRecognizer_quickstart för att skapa och köra programmet, eller tryck på F5.

Grattis! I den här snabbstarten använde du Formigenkänning C# SDK för att analysera olika formulär och dokument på olika sätt. Utforska sedan referensdokumentationen för att lära dig Formigenkänning API på djupet.

Nästa steg