The problem with general-purpose AI agents is that they are subject to “hallucinations” (these days, we say that those agents produce answers that aren’t “grounded”).

One solution to that problem is to create a custom AI agent with your own content and have your agent use that content to generate grounded answers (this is referred to as Retrieval Augmented Generation or RAG). Effectively, you can create a dedicated, reliable AI assistant for your users for any aspect of your organization.

Progress Telerik Document Processing Libraries (DPL) include a set of AI connectors that support creating those custom RAG-enabled AI agents of your own using any of the existing Large Language Models (LLMs) available to you in Azure or on your own computer/server using Ollama. And, once that agent is created, Telerik UI tools will let you integrate it into any application.

So, this post kicks off a series of posts where I’m going to walk you through all of the steps you need to create a custom AI agent by using Telerik DPL (and related AI tools), integrated with an LLM available on Azure or in Ollama. Once you’ve created an agent, I’ll show you how to add that custom agent into your application’s UI using AI-enabled Telerik UI components in either JavaScript or Blazor (though you could also create your frontend in ASP.NET, Windows Forms or .NET MAUI).

But … having said that, if all you want to do is add an AI prompt to your application, then, thanks to Telerik tools, this post might be the only one you need. At the end of this post, I’ll show you how to create a simple frontend for your application to use your LLM. In fact, if you’ve already got an LLM deployed (which is what this post is about), you might want to skip the rest of this post and go directly to that last section.

Picking Your LLM Provider

If you stick with Microsoft’s offerings, you actually have three options for creating the LLM your application will use. The good news here is that, thanks to Microsoft and Telerik tools, it doesn’t make much difference to your code which of those three options you use.

Your three choices are:

• Microsoft Foundry: This gives you access to a wide variety of LLMs from multiple providers (including the OpenAI LLMs), while giving you integration with Azure security. Microsoft Foundry also gives you extensive monitoring for your LLM, enables data privacy and supports integration with other Azure services. This is Microsoft’s recommended option. I’ll call this the “Foundry option.”

• Azure OpenAI: This is the easiest option to set up but also provides the least access to Azure functionality. The Azure OpenAI option gives you access only to OpenAI’s LLMs and only limited integration with other Azure resources (principally, security). With this choice you do, however, get access to the latest OpenAI LLMs, potentially before they show up in Microsoft Foundry. I’ll call this the “OpenAI-only option.”

• Ollama: Unlike OpenAI or Microsoft Foundry, Ollama runs on your local computer, rather than in the cloud. Since there are no API fees, that makes Ollama an attractive choice for cheaper solutions (provided you have a powerful enough development computer). I’ll call this the “Client-side option.”

Setting Up OpenAI/Microsoft Foundry

While I’m treating the OpenAI-only option as a separate case from the Foundry option, the OpenAI-only option is actually hosted in Microsoft Foundry. As a result, the processes for setting up the OpenAI-only or the Foundry option are very similar:

1. In the Azure portal at portal.azure.com, create an Azure resource.
2. In the Microsoft Foundry portal at ai.azure.com, add an LLM—a “deployment”—to that resource.

Creating the Resource

To start, surf to the Azure Portal and search for Microsoft Foundry. On the Microsoft Foundry page, in the menu on the left, expand the Use with Foundry node and click on either:

• The Foundry node for the Foundry option
• The Azure OpenAI node for the OpenAI-only options

Either choice will open a page on the right. On that new page, click on the +Create menu choice at the left end of the menu running across the top of the page. That will start the wizard that will create your Azure resource.

If you opened this page from the Foundry node, you’ll start the wizard for creating your Foundry resource.

If you opened this page from the OpenAI node, you’ll get a dropdown list with two choices: OpenAI and Microsoft Foundry. This is, effectively, your last chance to switch to the Foundry option instead of OpenAI-only. Pick the OpenAI choice to open the wizard for creating an OpenAI-only resource.

Regardless of which wizard you’ve invoked, on the wizard’s first page you’ll need to provide a resource group, a name for your resource and a region for your LLM to run in. In addition, on the first page:

• For a Foundry resource, you’ll need to provide a default project name
• For an Azure OpenAI resource, you’ll need to select a pricing tier

After that, it’s just a matter of “Next”ing your way through the rest of the wizard’s tabs.

Setting Network Access

Both the Foundry and OpenAI-only wizards include a Network tab to control access to your resource. You have three choices on the Network tab:

• All networks: Gives access to your resource from anywhere
• Selected networks: Limits access to a subnet on a specific Azure virtual network, plus a list of IP addresses (e.g., your development computer)
• Disabled: Allows access only through a private endpoint on an Azure virtual network

You would use the last two options if you were going to run your application on a VM on a virtual network or in an App Service. You don’t need to use the network choices to control access to your resource. You could control access to your LLM just through the resource’s Access Control/IAM roles, for example, or your application’s built-in security. However, for a production application, you should always lean toward more control rather than less and pick whichever of these options that makes sense for limiting network access to your resource.

Setting Foundry Option

The Foundry wizard includes three additional tabs that the OpenAI wizard does not:

• Storage: This tab provides access to multiple additional Azure resources. You can:
      » Tie your resource to an Azure Key Vault where you can store passwords or other credentials that agents in your resource will need
      » Turn on Application Insights to log activities in your resource
      » Tie in an AI Search agent that your resource can access when processing requests
      » Add a Storage account to hold uploaded files
      » Integrate a CosmosDB account to hold conversation history.
• Identity: Assign a Managed Identity to your resource to support agents that access other Azure resources
• Encryption: Use your own encryption keys for any data stored by your resource

For a proof-of-concept project, you can take the defaults on all these tabs.

Both wizards finish with the standard Tags tab and Review-and-create tab. When you get to that last tab, click the Create button to create your resource.

Selecting an LLM

Your application interacts with a deployed instance of some LLM so your next step is to create a deployment that uses one of the LLMs available to your resource.

To do that, navigate to your resource and, on the Overview page, click on the Go to Foundry portal link at the top of the page. This will open a new tab in your browser displaying the ai.azure.com portal. This is where you will select the LLM you’ll use in your deployment.

To create a deployment, on the Microsoft Foundry page for your resource, in the menu on the left, click on the Model catalog node. That will take you to a page where you can select your LLM.

A warning: Over and above whatever criteria you have for getting the right model for your application, selecting a model may require some trial-and-error poking around. That’s because:

• Some models are deprecated or may not be available for your resource (e.g., selecting a non-OpenAI LLM for an OpenAI-only resource).
• You may not be eligible for some models.
• Your subscription may not have the necessary resources to support a model.
• The model you select may not support the processing you want to implement.

Once you open the page listing available LLMs, if you got to the page from a:

• Foundry resource: You can browse the lists of LLMs from a variety of providers or you can search for an LLM using the search box just below those lists
• OpenAI resource: You can browse the list of OpenAI LLMs

When you select an LLM, Azure will display a page with high-level information about your LLM. For my case study, I created three deployments, one each for these three LLMs:

• gpt-5.2-chat LLM as an example of a Foundry resource
• gpt-5-chat LLM as an example of an Azure OpenAI-only resource
• text-embedding-3-large as an example of an LLM with specific features (I’ll use it in a later post on querying with Telerik AI connectors).

Creating a Deployment

To create your deployment, at the top of the page, click the button labeled “Use this model.” That will display a dialog where you can customize the LLM you’ve chosen, including giving your deployment a name (your deployment’s name will default to the name of your LLM). Click on the button at the bottom of the page labeled “Create resource and deploy” … and then be patient because this can take a moment.

After your deployment is created with your selected LLM:

• In a Foundry resource, you’ll be taken to the page describing your deployment.
• In an OpenAI-only resource, you’ll be taken to an Overview page. In the menu on the left, click on the Models + endpoints node to open a list of your deployments. Select the deployment you just created to be taken to the page describing your deployment.

Once you’re on your deployment’s page, you need three required pieces of information from the page to use in your application and one optional piece:

• Name: Displayed at the top of the page.
• Authentication information: Your deployment will default to Key authentication, which is fine for a proof-of-concept application (you can switch to Entra Id authentication for production, but the code to access your resource will get more complicated). Assuming that you stick with Key Authentication, copy the Key provided on this page.
• URL: At the top of your deployment’s page, find the Target Uri and copy the first segment of the URL provided (i.e., everything from the “https://” and up to, but not including, the first forward slash in the URL).
• Version: Depending on how you intend to use your LLM, you may not need this, but it does no harm to grab it now. Again, the easiest place to get this is from the sample code. Look for the string put in the variable called api-version (it will look like a date, e.g., “2025-12-01”).

Returning to Your Deployment

To return to your resource or your model, first surf to ai.azure.com and sign in. This portal is, currently, in the process of migrating to a new UI, so:

• If you get the “old” UI then, you may get a list of Foundry and Open AI resources. If so, pick the resource you want to go to the resource’s page. On the other hand, you may just be taken directly to one of your resources. Either way, in the menu on the left, select the Models + endpoints node to see a list of your deployments.
• If you don’t get that list of your resources … well, then you’re probably in the new UI and, at this point, I’d recommend using the toggle at the top of the page to return to the old UI so you can follow along.

You have more to do to create your own custom RAG-enabled AI agent (load your own content, for example). But if all you want is an application that integrates an AI prompt, you’ve done everything you need to support that. You just need to create a frontend that lets the user query your LLM’s deployment. The Telerik AI Prompt will let you do that with minimum effort. I’ll cover that after showing how to set up the client-side option with Ollama.

Setting Up Ollama

To implement the client-side option, you first need to download Ollama and install it. To confirm that Ollama installed successfully, open a command window and enter ollama. You should get back a list of Ollama commands.

You next need to add the LLM you want to use to Ollama. To do that, open a command window and use Ollama’s pull command to install one of the LLMs from the Ollama registry. This command installs OpenAI’s gpt-oss LLM:

ollama pull gpt-oss

After using the pull command, you can use Ollama’s list command (which displays the installed LLMs) to confirm your installation.

The Ollama server should start automatically after installation (and after every reboot) and should be listening on port 11434 on localhost. You can confirm that by using Ollama’s serve command. If server isn’t running, it will start and report the address the server is listening on. If the server is already running, you’ll get an error message that includes address that Ollama is listening on.

Make a note of the address (probably http://localhost:11434) and the name of the LLM you installed—you’ll need both in your code.

I’m building up to a creating a custom AI agent over this series of posts. But, at this point, you’ve done everything you need to create an application with an AI prompt—it’s just a matter of adding a frontend to your LLM.

Adding a Front End

In my next posts, I’ll use Telerik Document Processing Library tools to create applications that allow users to apply AI to documents. However, once you’ve created an LLM deployment, you can tie that deployment into your application’s UI with a few lines of code in your application’s Program.cs file and then query your LLM through the Telerik AI Prompt component in your application’s UI.

To do that in a .NET 8 or later application, you first need to add the Microsoft.Extensions.AI.OpenAI NuGet package to your application. After that, you need to tie your model into your application by adding the following code to your application’s Program.cs file, inserting the information about your LLM that you gathered from your deployment’s information page.

For either of my Foundry or OpenAI-only options that code looks like this:

builder.Services.AddSingleton(new AzureOpenAIClient(
     new Uri(“<url>”),
     new AzureKeyCredential(“<key>”)
 ));
builder.Services.AddChatClient(services => 
         services.GetRequiredService<AzureOpenAIClient>()
            .GetChatClient(<deployment name>).AsIChatClient());

For Ollama, in addition to adding the Microsoft.Extensions.AI.OpenAI NuGet package, you’ll also need to add the OllamaSharp and Microsoft.SemanticKernel.Connectors.Ollama packages. After that, this single line of code will integrate Ollama into your application:

builder.Services.AddSingleton<IChatClient>(
    sp => new OllamaApiClient("<Ollama address>", "<model name>")
);

Your last step is to add the Telerik AIPrompt to your application’s UI (available in JavaScript for Kendo UI, Blazor, ASP.NET AJAX, WinForms and .NET MAUI). That can be as simple as this in an application that supports Razor (e.g., ASP.NET or Blazor):

<TelerikAIPrompt/>

And that would give you this UI:

In a JavaScript application, you’ll need to add a <div> element, set the element’s id attribute, and write a couple lines of JavaScript code. I’ll cover that in a later post in this series.

You can now start your application, enter a prompt into the AIPrompt component (e.g., “Tell me about RAG-enabled AI applications”) and get a response.

There’s obviously far more that you can do with the AI Prompt … and I’ll return to that after my next post. Before that, however, I’m going to roll in Telerik Document Processing Library to let you load the content for your custom AI agent.

Explore Telerik Document Processing Libraries, plus component libraries, reporting and more with a free trial of the Telerik DevCraft bundle:

Try DevCraft

Progress Telerik Document Processing Libraries, in addition to letting you work with a variety of document formats (PDF, DOCX, RTF, HTML, XLSX and more), are an example of the reason you buy into a suite of tools: All the tools bear a “family resemblance.”

The ideal scenario, of course, would be for a single tool that made all these document formats look the same. Given the differences in format and functionality between, for example, a PDF, a Microsoft Word (or RTF or HTML) document and an Excel spreadsheet, that’s not reasonable (though Progress Telerik has achieved that with DOCX, RTF and HTML documents).

The good news here is that, with Telerik Document Processing Libraries (DPL), the family resemblance is strong enough that, for all of the document types the library supports, I can show you how to load documents, start the editing process, convert between various document types and save a document in this one post.

Configuring Your Project

The sample code in this post was all written using the DPL for Windows libraries (even though I was working in ASP.NET Core—the more technical name for the version I used is “.NET(Target OS: Windows).” The suite is also available for the .NET Framework.

To create an ASP.NET Core project that would work with “all the documents,” I added these NuGet packages to my project:

• To work with PDF files: Telerik.Windows.Documents.Fixed
• To work with DOCX, HTML and RTF files: Telerik.Windows.Documents.Flow
• To work with Excel spreadsheets: Telerik.Windows.Documents.Spreadsheet

For the Excel spreadsheets, I’m only going to work with XLSX files, so I added the Telerik.Windows.Documents.Spreadsheet.FormatProviders.OpenXml package to my project. (If I was going to work with, for example, XLS spreadsheet, then I would have added the Telerik.Documents.Spreadsheet.FormatProviders.Xls package.)

Loading Your Document

The code to load a document from a file into any of these libraries is very similar:

1. Create the appropriate provider.
2. Use the .NETFile object’s OpenRead to create a Stream that points to the file.
3. Use the provider’s Import method to load the stream into the document object.

Here, for example, is the code to load a PDF file into a RadFixedDocument object (I used this code in an ASP.NET Core application with documents in my project’s wwwroot folder):

RadFixedDocument doc;
PdfFormatProvider prov = new();

using (Stream str = File.OpenRead(@"wwwroot/documents/Priorities.pdf"))
{
    doc = prov.Import(str, TimeSpan.FromSeconds(10));
}

And here’s the code to load a DOCX file into a RadFlowDocument:

RadFlowDocument doc;
DocxFormatProvider prov = new();

using (Stream str = File.OpenRead(@"wwwroot/documents/Priorities.docx"))
{
    doc = prov.Import(str, TimeSpan.FromSeconds(10));
}

As you can see, the code is identical except for the provider (PdfFormatProvider vs. DocxFormatProvider) and document objects (RadFlowDocument vs. RadFixedDocument).

Because both RTF and HTML documents load into the same RadFlowDocument object as a DOCX document, only the provider object changes (HtmlFormatProvider or RtfFormatProdiver instead of DocxFormatProvider) when working with those file formats. Here’s the code to load an RTF document:

RadFlowDocument doc;
RtfFormatProvider prov = new();

using (Stream str = File.OpenRead(@"wwwroot/documents/Priorities.rtf"))
{
    doc = prov.Import(str, TimeSpan.FromSeconds(10));
}

And here’s the almost identical code to load an HTML file:

RadFlowDocument doc;
HtmlFormatProvider prov = new();

using (Stream str = File.OpenRead(@"wwwroot/documents/Priorities.html"))
{
    doc = prov.Import(str, TimeSpan.FromSeconds(10));
}

The code to load an Excel workbook is also similar to what you’ve seen before, just swapping in a new document object (Workbook) and provider (XlsxFormatProvider):

Workbook doc;
XlsxFormatProvider prov = new();
using (Stream str = File.OpenRead(@"wwwroot/documents/priority.xlsx"))
{
    doc = prov.Import(str, TimeSpan.FromSeconds(10));
}

A note: The Workbook object assumes that you’re going to load the whole Excel workbook into memory. For very large workbooks, that may not make sense. For that scenario, you should look at the SpreadStreamProcessing Library.

Modifying the Documents

Once you’ve loaded the documents, you can start working with them. You can often simplify your code by using the RadFixedDocumentEditor with PDF documents or the RadFlowDocumentEditorwith Word/RTF/HTML documents. Not surprisingly, the code for creating an editor is almost identical for these two document types: create an editor object and pass the document you want loaded into the editor.

The code to create an editor for a PDF document looks like this:

RadFixedDocumentEditor editor = new RadFixedDocumentEditor(doc);

The code for Word/RTF/HTML documents looks like this:

RadFlowDocumentEditor editor = new RadFlowDocumentEditor(doc);

That’s not to say that, as you start working with those documents, there aren’t going to be differences. These are, after all, very different kinds of documents. Having said that, some functionality does work in a similar way across all the document types.

If, for example, I want to search a PDF document for the text “ASP.NET,” I create a TextSearch instance from my document object. I then use the TextSearch object’s FindAll method to search for text in my PDF document, passing two things: my search text and a TextSearchOptions object that specifies how I want my search conducted. That FindAll object returns a collection of SearchResult objects that I can loop through.

Typical code, then, looks like this:

TextSearch search = new TextSearch(doc);
TextSearchOptions opts = new() {
CaseSensitive = false,
WholeWordsOnly = true,
UseRegularExpression = true
                                                              };

IEnumerable<SearchResult> items = search.FindAll("ASP.NET", opts);

Debug.Print($"Found {items.Count()} items.");
foreach (SearchResult item in items)
{
    Debug.Print($"Found at {item.Range.StartPosition} ");
    Debug.Print($"Found: {item.Result}");
}

The process is almost identical for the RadFlowDocument object, except:

• You call the FindAllmethod directly from the RadFlowDocumentEditor.
• There isn’t a separate options object (though all the search options from the TextSearch object are still available).
• The FindAll method on the editor returns FindResult objects instead of SearchResult objects.

As a result, the equivalent search code for a DOCX, RTF or HTML document looks like this:

RadFlowDocumentEditor editor = new RadFlowDocumentEditor(doc);

IEnumerable<FindResult> items = editor.FindAll("ASP.NET");

Debug.Print($"Found {items.Count()} items.");
foreach (FindResult item in items)
{
    Debug.Print($"Found at {item.RelativeStartIndex} ");
    Debug.Print($"Found: {item.FullMatchText}");
}

Searching a spreadsheet works similarly. The differences:

• The FindAll method is built right into the Workbook object.
• You have more search options available with the spreadsheet object.
• You pass your search string as part of the options object.

My find code with a workbook would look like this:

FindOptions opts = new() {
FindWhat = "ASP.NET",
MatchCase = false,
MatchEntireCellContents = true,
                                                };

IEnumerable<FindResult> items = doc.FindAll(opts);

Debug.Print($"Found {items.Count()} items.");
foreach(FindResult item in items)
{
    Debug.Print($"Found at {item.FoundCell.CellIndex} ");
    Debug.Print($"Found: {item.ResultValue}");
}

One note: It is certainly convenient when objects from the different libraries share the same name (like the FindResult object that’s defined in both the RadFlowDocument and Workbook libraries). However, if you try to use both FindResult objects in the same code file, the compiler will get confused because the two objects are in different namespaces. In the unlikely case that you’re working with both Excel and Word documents in the same code file, you’ll have to fully qualify the object names—something I haven’t done in this post.

Saving Your Documents

To save your modified documents back to disk, you just need to use the provider’s Export method. The code for all the document types is identical:

using (Stream str = File.Create(@"wwwroot/documents/Prioritiesnew.<filetype>"))
{
    prov.Export(doc,str, TimeSpan.FromSeconds(10));
}

Converting Documents

You can convert from one type in the suite to other types and, not surprisingly, the conversion processes look very much alike. As you’ve seen before, it often comes down to using the right provider.

If, for example, you want plain text version of your PDF file, you use the TextFormatProvider object’s Export method:

TextFormatProvider prov = new();
string text = prov.Export(doc, TimeSpan.FromSeconds(10));

For Word/HTML/RTF document types, the code is almost identical except it uses the TxtFormatProvider object:

TxtFormatProvider txProv = new();
string text = prov.Export(doc, TimeSpan.FromSeconds(10));            

One note: There is a downside to having the classes that do similar things to different document types have the same name. If you are mixing document types and, as a result, using the Fixed, Flow and spreadsheet libraries in the same application, the compiler can get confused about which class from which library you’re using. If so, you’ll have to fully qualify your class names by including their namespaces in the class names. That makes for hard-to-read code, so I haven’t done that here.

But, as an example of how different documents require different functionality, you probably wouldn’t ever want to convert an Excel workbook to a string … but you might want to save your workbook as a CSV file. As you might expect by now, the code to save your imported workbook into a CSV file just means using the Export method on the appropriate provider—the CsvFormatProvider object in this case.

Typical code would look like this:

CsvFormatProvider prov = new();

using (Stream str = File.Create("Priority.csv"))
{
    prov.Export(doc, str, TimeSpan.FromSeconds(10));
}

Converting any of these document types (Excel, Word, HTML, etc.) to PDF is equally straightforward. Because all the libraries look very much alike, it’s really just a matter of adding the library with the provider you need.

But you can also convert your Workbook object into a RadFixedDocument if you wanted to manipulate your spreadsheet as a PDF object. That conversion is handled by the PdfFormatProvider from the Telerik.Windows.Documents.Spreadsheet.Formatproviders.Pdf package and using its ExportToFixedDocumentmethod:

PdfFormatProvider prov = new();

RadFixedDocument fixedDoc = 
        prov.ExportToFixedDocument(doc, TimeSpan.FromSeconds(10));

The code is identical if you want to convert a Word/RTF/HTML document to a RadFixedDocument to work with it as a PDF file. That conversion also uses a PdfFormatProvider object but, this time, from the Telerik.Windows.Documents.Flow.FormatProviders.Pdf namespace.

But, because the providers from the two libraries have the same name, if you’re using both libraries in the same code file, you will need to fully qualify your provider names to make sure you’re getting the appropriate PdfFormatProvider.

Of course, once you start using these tools to create or modify the documents you’ve loaded, you’ll find more differences—the functionality in a spreadsheet is very different from the functionality in an HTML document. But, while the family resemblances among this suite won’t eliminate those differences, it does cut those differences down to what matters: how those documents differ in their functionality. Which is, after all, what you want.

Explore Telerik Document Processing Libraries, plus component libraries, reporting and more with a free trial of the Telerik DevCraft bundle:

Try DevCraft

Modern applications rely on automation and intelligent processing to handle large volumes of data, and spreadsheets are no exception. With the 2026 Q1 release, Progress introduced Agentic Tools (in Preview) for Telerik Document Processing Libraries (DPL).

These tools are purpose‑built .NET APIs for agentic document workflows, enabling AI agents to analyze, extract, edit and generate Excel and PDF files; run aggregates; transform content; and convert formats directly inside your app. The new Agentic Tools cover both PdfProcessing and SpreadProcessing libraries and are available with a Subscription license.

In this post, we’ll walk you through how to use the SpreadProcessing Agentic Tools to analyze an existing spreadsheet.

Importing the Workbook

Let’s create a simple .NET console app. Our first step is to import the Workbook. I am going to add the necessary DPL dependencies, in this case:

and then use this code:

Workbook workbook = null;

using (Stream input = File.OpenRead("Electric_Vehicle_Population_Data.xlsx"))
{
    XlsxFormatProvider formatProvider = new();
    workbook = formatProvider.Import(input, null);
}

In case you are wondering, this file contains 17 columns and 75,331 rows of data.

An agent using the DPL tools can work with multiple files at the same time by importing and exporting them via the SpreadProcessingFileManagementAgentTools and managing them with the InMemoryWorkbookRepository. However, in this example we are going to concentrate on analyzing one workbook, so we are going to use the SingleWorkbookRepository, a class which gives an agent a single file to work with in memory.

IWorkbookRepository repository = new SingleWorkbookRepository(workbook);

For this code, we need to reference the Telerik.Documents.AI.AgentTools.Spreadsheet package.

Initializing the DPL Agentic Tools

Initializing the Agentic Tools is very simple. For this example, we will use an Azure Open AI deployment, so first we are going to add the Microsoft.Agents.AI.OpenAI and Azure.AI.OpenAI packages. Then we are going to collect the Read and Formula tools in one collection:

List<AITool> tools = new SpreadProcessingReadAgentTools(repository).GetTools().ToList();
tools.AddRange(new SpreadProcessingFormulaAgentTools(repository).GetTools());

And then we can initialize our agent. We are going to need an Azure Open AI endpoint and key and are going to use gpt-4.1-mini.

OpenAI.Chat.ChatClient chatClient = new AzureOpenAIClient(
    new Uri(endpoint),
    new ApiKeyCredential(key))
    .GetChatClient(model);

AIAgent agent = chatClient.AsIChatClient().AsAIAgent(
    instructions: "",
    name: "SpreadsheetAnalyzer",
    tools: tools);

At this point, we can already ask a simple question to check our progress:

AgentResponse response = await agent.RunAsync("What is the value on cell A4?");
Console.WriteLine(response.ToString());

Here is the result:

If you examine the response of the agent more closely, you will notice that it contains three messages. The first is the function call the agent made to the document processing tool GetCellValues and with what parameters. The second is the response. And the third is what the LLM has reasoned and has decided to give us.

Giving It UI

A console app is good for a proof of concept, but it would be nice to give our functionality a more finished look. One of the ways to do this is by using some Progress Telerik for WPF controls. The RadSpreadsheet control can show the content of our file, and we can leverage RadChat for the conversation with the agent.

We can give the repository the Workbook object of the RadSpreadsheet like this when initializing the chat:

IWorkbookRepository repository = new SingleWorkbookRepository(this.radSpreadsheet.Workbook);

Then we are going to subscribe to the SendMessage event, which is where our logic for running the agent is going to go:

this.radChat.SendMessage += this.RadChat_SendMessage;

After a few more tweaks, this is the result:

The full code of the demo can be found on this link: AgentToolsAnalyzeSpreadsheet on GitHub

Conclusion

Agentic workflows introduce a powerful new way to interact with documents, moving beyond static reading and writing to dynamic, intelligent analysis. As you’ve seen, the setup integrates seamlessly with .NET, and, once the agent is initialized, it can leverage the full capabilities of the Document Processing Libraries.

This example is just the beginning! The same approach can be extended to multi-document scenarios, automated reporting, data validation or even generating new spreadsheets from scratch.

The future of document processing is agentic, and it’s already here.

Try out the Telerik Document Processing Libraries, which are included in the Telerik DevCraft bundles to pair perfectly with your favorite component libraries.

Try Telerik DevCraft

Offloading document generation, conversion or manipulation to cloud services allows you to handle large workloads without overloading on-prem resources. Azure Functions and AWS Lambda scale automatically based on demand, so whether you need to generate 10 or 10,000 documents, the infrastructure adjusts dynamically. Serverless models charge per execution time and resources consumed, eliminating the need for dedicated servers for document processing. Thus, you pay only for what you use.

This blog post introduces comprehensive cloud integration demonstrations for Azure and AWS, showcasing PDF processing capabilities using Progress Telerik Document Processing in serverless environments. The examples demonstrate two main integration patterns: PDF merging and external digital signing, implemented for both Azure Functions and AWS Lambda. The complete code projects are available in our SDK repository: Cloud Integration Demos.

Integrate RadPdfProcessing with Azure Functions

First, you’ll need: an active Azure subscription, Azure functions tools installed and the Telerik NuGet feed set up.

1. Create an Azure Functions App

2. Select Anonymous authorization level:

3. Install the following NuGet packages:

• Install the Telerik.Documents.Fixed NuGet package.
• Install the HttpMultipartParser NuGet package:

4. Rename the Functiona1.cs file to “MergeFunction” and introduce your custom implementation in the Run method:

using HttpMultipartParser;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using System.Net;
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
 
namespace MyAzureFunctionApp;
 
public class MergeFunction
{
    [Function("MergeFunction")]
    public async Task<HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req)
    {
        Task<MultipartFormDataParser> parsedFormBody = MultipartFormDataParser.ParseAsync(req.Body);
 
        PdfFormatProvider provider = new PdfFormatProvider();
        RadFixedDocument result = MergePdfs(provider, parsedFormBody.Result.Files);
 
        using (MemoryStream outputStream = new MemoryStream())
        {
            provider.Export(result, outputStream, TimeSpan.FromSeconds(20));
            outputStream.Seek(0, SeekOrigin.Begin);
 
            HttpResponseData httpResponseData = req.CreateResponse(HttpStatusCode.OK);
            httpResponseData.Headers.Add("Content-Type", "application/pdf");
            await outputStream.CopyToAsync(httpResponseData.Body);
 
            return httpResponseData;
        }
    }
 
    static RadFixedDocument MergePdfs(PdfFormatProvider pdfFormatProvider, IReadOnlyList<FilePart> files)
    {
        RadFixedDocument mergedDocument = new RadFixedDocument();
        foreach (FilePart file in files)
        {
            RadFixedDocument documentToMerge = pdfFormatProvider.Import(file.Data, TimeSpan.FromSeconds(20));
            mergedDocument.Merge(documentToMerge);
        }
 
        return mergedDocument;
    }
} 

This Azure Function, named MergeFunction, handles HTTP GET and POST requests to merge multiple PDF files into a single document. It uses:

• HttpMultipartParser to parse multipart form data and extract uploaded files.
• Telerik PdfFormatProvider and RadFixedDocument to import and merge PDF documents.
• The merged PDF is exported to a memory stream and returned as an HTTP response with the application/pdf content type.

The function supports anonymous access and processes uploaded files efficiently, so that the merged PDF is delivered in the response. Since the function is implemented with anonymous access for demo purposes, consider adding authentication as needed for your scenario.

5. Run the project and copy the URL from the window that pops up:

6. Create a .NET Console App (e.g., MyMergeApp) that acts as a client for the Azure Function PDF Merge service.

using System.Diagnostics;
using System.Net.Http.Headers;
 
namespace MyMergeApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string functionUrl = "http://localhost:7163/api/MergeFunction";
 
            // Specify PDF files to merge from the Resources directory
            string[] pdfFilePaths = { "../../../Resources/file1.pdf", "../../../Resources/file2.pdf" };
 
            // Create multipart form data content for file upload
            using MultipartFormDataContent content = new();
 
            // Add each PDF file to the form data
            foreach (string filePath in pdfFilePaths)
            {
                byte[] fileBytes = File.ReadAllBytes(filePath);
                ByteArrayContent fileContent = new(fileBytes);
                fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/pdf");
                content.Add(fileContent, "files", Path.GetFileName(filePath));
            }
 
            // Send the merge request to the Azure Function
            HttpResponseMessage response = PostAsync(functionUrl, content).Result;
            response.EnsureSuccessStatusCode();
 
            // Read the merged PDF from the response
            byte[] result = response.Content.ReadAsByteArrayAsync().Result;
 
            // Save the merged PDF to disk
            string outputPath = "merged_output.pdf";
            if (File.Exists(outputPath))
            {
                File.Delete(outputPath);
            }
            File.WriteAllBytes(outputPath, result);
 
            // Open the merged PDF in the default viewer
            Process.Start(new ProcessStartInfo(outputPath) { UseShellExecute = true });
        }
        static async Task<HttpResponseMessage> PostAsync(string url, MultipartFormDataContent content)
        {
            using HttpClient httpClient = new HttpClient();
            httpClient.Timeout = TimeSpan.FromMinutes(2); // Allow sufficient time for large files
 
            return await httpClient.PostAsync(url, content);
        }
    }
}

It demonstrates how to send multiple PDF files to the MergeFunction endpoint and handle the merged result. The workflow includes:

• Loading PDF files from a local Resources directory.
• Packaging the files as multipart form data for upload.
• Sending an HTTP POST request to the Azure Function endpoint.
• Receiving the merged PDF in the response and saving it to disk.
• Automatically opening the merged PDF in the system’s default viewer.
  The application uses HttpClient for communication, enables proper content type headers and includes a helper method PostAsync for sending requests with a configurable timeout.

7. Run the Azure Functions .NET Worker (e.g., MyAzureFunctionApp.csproj):

8. While the service is running, run the Console App (e.g., MyMergeApp).

As a result, a merged PDF document will be produced:

Integrate RadPdfProcessing with AWS Lambda

Using an AWS Lambda function for signing PDF documents offers a more secure, scalable and cost-effective approach to digital signature workflows. By offloading the signing process to a serverless environment, sensitive private keys remain isolated in the cloud, reducing the risk of exposure on client machines.

The following tutorial defines the steps for creating an AWS Lambda function that performs digital signature operations for PDF documents using a private key stored in a certificate file. The AWS Lambda function is purposed to act as a more secure service that remotely signs PDF documents, and the private key is never exposed to the client.

Before starting, you’ll need valid AWS Credentials and the Telerik NuGet Feed properly set up.

1. Create AWS Lambda Project (e.g., MyAWSLambda):

2. From the Select Blueprint wizard, select “.NET 8 (Container Image)”:

3. Open the Function.cs file and implement the custom logic for signing PDF documents in the FunctionHandler:

The method receives data to be signed, signs it using a private key certificate, and returns the Base64-encoded signature. The .pfx certificate is stored independently from the project used for processing documents.

NOTE: Do not forget that sensitive data should be stored properly and that this implementation is for demo purposes.

using Amazon.Lambda.Core;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
 
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
 
namespace MyAWSLambda;
 
public class Function
{
    public async Task<string> FunctionHandler(Input input, ILambdaContext context)
    {
        byte[] dataToSign = Convert.FromBase64String(input.DataToSign);
 
        byte[]? result = SignData(dataToSign, input.DigestAlgorithm);
 
        if (result != null)
        {
            return Convert.ToBase64String(result);
        }
        else
        {
            throw new InvalidOperationException("Signing operation failed");
        }
    }
    static byte[]? SignData(byte[] dataToSign, string? digestAlgorithm)
    {
        string certificateFilePassword = "johndoe";
        string certificateFilePath = "Resources/JohnDoe.pfx";
 
        using (Stream stream = File.OpenRead(certificateFilePath))
        {
            byte[] certRawData = new byte[stream.Length];
            stream.ReadExactly(certRawData, 0, (int)stream.Length);
 
            using (X509Certificate2 fullCert = new X509Certificate2(certRawData, certificateFilePassword))
            {
                using (RSA? rsa = fullCert.GetRSAPrivateKey())
                {
                    if (rsa == null)
                    {
                        throw new InvalidOperationException("Certificate does not contain an RSA private key");
                    }
 
                    // Map the digest algorithm string to HashAlgorithmName
                    HashAlgorithmName algorithmName = HashAlgorithmName.SHA256;
                    algorithmName = digestAlgorithm switch
                    {
                        "Sha384" => HashAlgorithmName.SHA384,
                        "Sha512" => HashAlgorithmName.SHA512,
                        _ => HashAlgorithmName.SHA256,
                    };
 
                    byte[]? bytes = rsa.SignData(dataToSign, algorithmName, RSASignaturePadding.Pkcs1);
                    return bytes;
                }
            }
        }
    }
 
    public class Input
    {
        public string DataToSign { get; set; } = string.Empty;
 
        public string? DigestAlgorithm { get; set; }
    }
}

4. Modify the aws-lambda-tools-defaults.json file and specify the function-name for the AWS Lambda function (e.g., ExternalSignPdfAWSFunction):

{
  "Information": [
    "This file provides default values for the deployment wizard inside Visual Studio and the AWS Lambda commands added to the .NET Core CLI.",
    "To learn more about the Lambda commands with the .NET Core CLI execute the following command at the command line in the project root directory.",
    "dotnet lambda help",
    "All the command line options for the Lambda command can be specified in this file."
  ],
  "profile": "telerik-dpl",
  "region": "eu-north-1",
  "configuration": "Release",
  "package-type": "image",
  "function-memory-size": 512,
  "function-timeout": 30,
  "image-command": "MyAWSLambda::MyAWSLambda.Function::FunctionHandler",
  "docker-host-build-output-dir": "./bin/Release/lambda-publish",
  "function-name": "ExternalSignPdfAWSFunction"
}

5. Create a Console App (e.g., MySigningApp.csproj) that will consume the AWS Lambda function.

6. Install the following NuGet packages:

• AWSSDK.Lambda
• Telerik.Documents.Fixed

The Resources folder stores the unsigned PDF document together with the public .crt certificate.

7. Modify the Program.cs file to demonstrate how to apply a digital signature to a PDF document using the Telerik PdfProcessinglibrary and an external AWS Lambda signer. The workflow includes importing a PDF, creating a signature field with a visual representation, configuring signature settings and exporting the signed document.

Note: We will use the specified function-name in the previous step when creating the LambdaFunctionSigner object:

using System.Diagnostics;
using Telerik.Documents.Fixed.Model.DigitalSignatures;
using Telerik.Documents.Primitives;
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
using Telerik.Windows.Documents.Fixed.Model.Annotations;
using Telerik.Windows.Documents.Fixed.Model.DigitalSignatures;
using Telerik.Windows.Documents.Fixed.Model.Editing;
using Telerik.Windows.Documents.Fixed.Model.InteractiveForms;
using Telerik.Windows.Documents.Fixed.Model.Objects;
using Telerik.Windows.Documents.Fixed.Model.Resources;
 
namespace MySigningApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            PdfFormatProvider provider = new PdfFormatProvider();
            RadFixedDocument document = ImportDocument(provider);
 
            string signatureName = "SampleSignature";
 
            Form form = new Form();
            form.FormSource = new FormSource();
            form.FormSource.Size = new Size(120, 120);
 
            // We will use the editor to fill the Form XObject.  
            FixedContentEditor formEditor = new FixedContentEditor(form.FormSource);
            formEditor.DrawCircle(new Point(50, 50), 20);
            formEditor.DrawText(signatureName);
 
            // The Signature object is added to a signature field, so we can add a visualization to it.  
            SignatureField signatureField = new SignatureField(signatureName);
 
            // Create the external signer that will call AWS Lambda to perform the actual signing
            ExternalSignerBase externalSigner = new LambdaFunctionSigner("ExternalSignPdfAWSFunction", "eu-north-1");
 
            // Configure the signature with digest algorithm and timestamp server
            Signature signature = new Signature(externalSigner);
            signature.Settings.DigestAlgorithm = DigestAlgorithmType.Sha512;
            signature.Settings.TimeStampServer = new TimeStampServer("http://timestamp.digicert.com", TimeSpan.FromSeconds(10));
            signatureField.Signature = signature;
 
            // The widget contains the Form XObject and defines the appearance of the signature field.  
            SignatureWidget widget = signatureField.Widgets.AddWidget();
            widget.Rect = new Rect(200, 600, 100, 100);
            widget.Border = new AnnotationBorder(100, AnnotationBorderStyle.Solid, null);
            widget.Content.NormalContentSource = form.FormSource;
 
            // The Widget class inherits from Annotation. And, as any other annotation, must be added to the respective collection of the page.  
            RadFixedPage page = document.Pages.AddPage();
            page.Annotations.Add(widget);
            document.AcroForm.FormFields.Add(signatureField);
 
            document.AcroForm.SignatureFlags = SignatureFlags.AppendOnly;
 
            ExportDocument(provider, document);
 
        }
 
        static RadFixedDocument ImportDocument(PdfFormatProvider provider)
        {
            using (FileStream stream = File.OpenRead("Resources/SampleDocument.pdf"))
            {
                return provider.Import(stream, TimeSpan.FromSeconds(20));
            }
        }
 
        static void ExportDocument(PdfFormatProvider provider, RadFixedDocument document)
        {
            string outputPath = "ExternallySignedDocument.pdf";
            File.Delete(outputPath);
 
            using (FileStream stream = File.Create(outputPath))
            {
                provider.Export(document, stream, TimeSpan.FromSeconds(60));
            }
 
            Process.Start(new ProcessStartInfo(outputPath) { UseShellExecute = true });
        }
    }
}

8. Implement the External Signer.

The LambdaFunctionSigner class is a custom implementation of an external signer that delegates digital signing operations to an AWS Lambda function. It inherits from ExternalSignerBaseand is designed for scenarios where the private key is securely stored in AWS Lambda, while the public certificate resides locally.

using Amazon.Lambda;
using Amazon.Lambda.Model;
using Amazon.Runtime; 
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Text.Json;
using Telerik.Documents.Fixed.Model.DigitalSignatures;
 
namespace MySigningApp
{
    public class LambdaFunctionSigner : ExternalSignerBase
 
    {
        private readonly string functionName;
        private readonly AmazonLambdaClient lambdaClient;
 
        /// <summary>
        /// Creates a new instance of LambdaFunctionSigner.
        /// </summary>
        /// <param name="functionName">The AWS Lambda function name or ARN (e.g., "MyAWSLambda" or "arn:aws:lambda:region:account:function:name")</param>
        /// <param name="region">The AWS region where the Lambda function is deployed (e.g., "us-east-1", "eu-north-1")</param>
        public LambdaFunctionSigner(string functionName, string region)
        {
            this.functionName = functionName;
            var credentials = new BasicAWSCredentials("your-access-key", "your-secret-key");
            this.lambdaClient = new AmazonLambdaClient(credentials, Amazon.RegionEndpoint.GetBySystemName(region));
        }
 
        /// <summary>
        /// Gets the certificate chain used for signing.
        /// </summary>
        /// <returns>An array of X509Certificate2 objects representing the certificate chain.</returns>
        /// <remarks>
        /// The public certificate is loaded from the Resources folder and should match
        /// the private key certificate stored in the AWS Lambda function.
        /// </remarks>
        protected override X509Certificate2[] GetCertificateChain()
        {
            string publicKey = "Resources/JohnDoe.crt";
            return [new X509Certificate2(publicKey)];
        }
 
        /// <summary>
        /// Signs the provided data by invoking the AWS Lambda function.
        /// </summary>
        /// <param name="dataToSign">The byte array containing the data to be signed.</param>
        /// <param name="settings">The signature settings containing digest algorithm and other configuration.</param>
        /// <returns>A byte array containing the digital signature.</returns>
        /// <exception cref="InvalidOperationException">Thrown when the Lambda invocation fails or returns an error.</exception>
        /// <remarks>
        /// This method:
        /// 1. Serializes the data and settings to JSON
        /// 2. Invokes the Lambda function synchronously
        /// 3. Validates the response
        /// 4. Returns the decoded signature bytes
        /// </remarks>
        protected override byte[] SignData(byte[] dataToSign, SignatureSettings settings)
        {
            var requestData = new
            {
                DataToSign = Convert.ToBase64String(dataToSign),
                DigestAlgorithm = settings.DigestAlgorithm.ToString()
            };
 
            string jsonRequest = JsonSerializer.Serialize(requestData, new JsonSerializerOptions
            {
                WriteIndented = true
            });
 
            var invokeRequest = new InvokeRequest
            {
                FunctionName = this.functionName,
                InvocationType = InvocationType.RequestResponse, // synchronous
                Payload = jsonRequest
            };
 
            InvokeResponse invokeResponse = lambdaClient.InvokeAsync(invokeRequest).Result;
 
            if (invokeResponse.StatusCode != 200)
            {
                throw new InvalidOperationException($"Lambda invocation failed with status code: {invokeResponse.StatusCode}");
            }
 
            if (!string.IsNullOrEmpty(invokeResponse.FunctionError))
            {
                string errorMessage = Encoding.UTF8.GetString(invokeResponse.Payload.ToArray());
                throw new InvalidOperationException($"Lambda function error: {invokeResponse.FunctionError}. Details: {errorMessage}");
            }
 
            string jsonResponse = Encoding.UTF8.GetString(invokeResponse.Payload.ToArray());
            string? base64Signature = JsonSerializer.Deserialize<string>(jsonResponse);
 
            if (string.IsNullOrEmpty(base64Signature))
            {
                throw new InvalidOperationException("Invalid response from Lambda function");
            }
 
            return Convert.FromBase64String(base64Signature);
        }
    }
}

9. Run the project.

As a result, the unsigned PDF document is successfully signed:

Wrapping Up

Integrating Telerik Document Processing with Azure Functions and AWS Lambda demonstrates how serverless architectures can transform document workflows. By leveraging cloud scalability and pay-per-use models, organizations can efficiently handle tasks like PDF merging and secure digital signing without maintaining dedicated infrastructure. These approaches not only reduce operational overhead but also enhance security by isolating sensitive keys in the cloud.

As businesses continue to adopt remote and distributed solutions, similar patterns can be extended to other workflows such as document conversion, watermarking and batch processing, unlocking even greater flexibility and cost efficiency. The examples provided serve as a foundation for building robust, cloud-powered document services that scale seamlessly with demand.

Try out the Telerik Document Processing Libraries, which are included in the Telerik DevCraft bundles to pair perfectly with your favorite component libraries.

The PDF file format is a fixed format, which allows its creator full control on how the document content will be arranged and displayed. It is widely used and required in a variety of scenarios, which makes it an indispensable staple of past and present digital communication. Any application which deals with documents in any way cannot do without it.

Creating PDF files programmatically, however, is not so straightforward. The standard is intricate, and its specification is daunting in its size of about a thousand pages. Putting together a PDF file from scratch is realistically not a feasible task for many development teams.

In comes the Progress Telerik Document Processing Libraries—DPL for short. DPL is a set of .NET libraries which provide APIs for the creation of the most commonly used file formats and conversion between them. DPL is a great fit for web, desktop and cross-platform apps, both for modern .NET and .NET Framework. This blog post will show you how to use it to turn almost any document into a PDF.

How DPL Conversion Works

Here is the short and sweet version of the way DPL operates. Each file format has a class which corresponds to it. For example, for PDF this is RadFixedDocument, for DOCX this is RadFlowDocument, and for XLSX it is Workbook. One object of these classes corresponds to one file and can be either created from scratch or imported from a file.

Each format has one or more format provider classes which are responsible for its import and export. Converting a file to a PDF boils down to importing a file into an object and then exporting it again to a PDF file. Let’s dive deeper into how this is done for each format.

DOCX to PDF

Starting with the classics, DOCX is one of the most natural file formats to export to PDF. The DOCX format is imported into a RadFlowDocument using the DocxFormatProvider:

RadFlowDocument flowDocument;

using (Stream inputStream = File.OpenRead(@"…\docxSample.docx"))
{
  DocxFormatProvider docxProvider = new DocxFormatProvider();
  flowDocument = docxProvider.Import(inputStream);
}

All the information, contents, styles, images are now in the flowDocument object. If you’d like to make changes to the file, now is a good time to do so using the RadFlowDocument API.

The next step is to export the object to PDF. This is done the same way as the import, but using the dedicated PdfFormatProvider for flow documents:

using (Stream outputStream = File.Create(@"…\docxToPdfSample.pdf"))
{
  PdfFormatProvider pdfProvider = new PdfFormatProvider();
  pdfProvider.Export(flowDocument, outputStream);
}

DOCX

PDF

If you would like to play around with what your document will look like as a PDF, check out our WordsProcessing export to PDF demo.

HTML to PDF

HTML is another natural format to export to PDF. Our approach will be the same as DOCX. Import an HTML file into a RadFlowDocument object and export the object to a PDF file.

RadFlowDocument flowDocument;

using (Stream inputStream = File.OpenRead(@"..\htmlSample.html"))
{
  HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
  flowDocument = htmlProvider.Import(inputStream);
}

using (Stream outputStream = File.Create(@"..\htmlToPdfSample.pdf"))
{
  PdfFormatProvider pdfProvider = new PdfFormatProvider();
  pdfProvider.Export(flowDocument, outputStream);
}

Once again, you can test this in the WordsProcessing export to PDF demo and upload your own HTML file.

XLSX to PDF

While DOCX and HTML fall into the domain of WordsProcessing, XLSX import and export are part of the SpreadProcessing library. The conversion mechanism, however, remains the same.

By now you probably already know the drill. Import the XLSX file into an object—in this case, the Workbook—and export it to PDF. SpreadProcessing has its own PdfFormatProvider, which we will use in this sample.

Workbook xlsxDocument;

using(Stream inputStream = File.OpenRead(@"..\xlsxSample.xlsx"))
{
  XlsxFormatProvider xlsxFormatProvider = new XlsxFormatProvider();
  xlsxDocument = xlsxFormatProvider.Import(inputStream);
}

using (Stream outStream = File.Create(@"..\xlsxToPdfSample.pdf"))
{
  PdfFormatProvider pdfFormatProvider = new PdfFormatProvider();
  pdfFormatProvider.Export(xlsxDocument, outStream);
}

XLSX

PDF

While DOCX and to some extent HTML come with an inherent page layout, XLSX does not split into pages that intuitively. SpreadProcessing will do the job, just as Excel does when you want to print a document, but you might want to make some adjustments if the result is not split and laid out as you expect.

This is what the WorksheetPrintOptions are for. They allow you to set print areas, fit the content horizontally or vertically, set the orientation of the page and much more. Let’s make some changes to make our document fit better:

using(Stream inputStream = File.OpenRead(@"..\xlsxSample.xlsx"))
[…]

Worksheet worksheet = xlsxDocument.ActiveWorksheet;
worksheet.WorksheetPageSetup.FitToPages = true;
worksheet.WorksheetPageSetup.FitToPagesWide = 1;
worksheet.WorksheetPageSetup.PageOrientation = PageOrientation.Landscape;

using (Stream outStream = File.Create(@"..\xlsxToPdfSample.pdf"))
[…]

PDF

Conclusion

As you can see, with Telerik Document Processing Library, converting files to PDF is indeed quick and easy! Interested? Check out the DPL page, where you will find additional information, demos and documentation:

Document Processing Libraries

DPL is part of the following Telerik products:

• Telerik UI for Blazor
• Telerik UI for ASP.NET Core
• Telerik UI for ASP.NET MVC
• Telerik UI for ASP.NET AJAX
• Telerik UI for .NET MAUI
• Telerik UI for WinForms
• Telerik UI for WPF
• And the Telerik DevCraft bundle, which includes all of the above—try it yourself!

While Progress Telerik is busy creating its own line of smart components (which you can try out on a bunch of platforms), there’s nothing stopping your from integrating AI into your applications right now. You can, for example, start using Azure’s Language Services in any application you’re currently building.

To make that point (and show you how to get started with Azure’s AI services), I’m going to show how to create an AI-enabled summary from a PDF document (I’ve got a kid going back to school and, I bet, he could find this useful). And, if you don’t care about how to make this work and just want to see how good a job Azure’s tools do in generating summaries from technical articles, scroll to the section at the end of this post called “So: How Good are the Summaries?” You’ll find some summaries of a variety of business and geeky articles, along with links to the original articles. You can make up your own mind about how good the tools are.

For this case study, I’m going to implement a solution in ASP.NET Core that displays the summary on the page above the PDF document. But, quite frankly, except for the markup making up the UI, the code you see would be same on any platform (and, if you use one of PDF Viewers from Progress Telerik, even the UI code will be similar, no matter what platform you try this on).

Signing Up to Language Services

If you want to implement this yourself, you’ll need start by creating an Azure Language Service. If you’ve already signed up with Azure, you can use your existing login credentials to get to the Language service overview page.

Once on the Azure AI Services | Language Service page, click on the +Create link in the horizontal menu on the right to start the Wizard that will create your service.

The first page in the wizard lists the included features of a language service and some additional customization features that you can add. The base features include default Text Summarization processing, which is all I need for this case study, so I just clicked on the “Continue to create your resource” button at the bottom of the page.

The next page includes the typical information required to create any Azure resource: Subscription, resource group, etc. You will need, when picking a region, to pick one that supports the AI features you want to use—in this case, text analysis summarization. East U.S. is both close to me and, as near as I can tell, supports all the AI services, so I selected that region. You might want to select a closer region.

You’ll also find two items that aren’t part of the regular resource-creation process:

• A pricing tier. You have two choices here: A free (F0) tier and a standard tier (S). Both will work. The F0 tier will limit you to 5,000 requests in a week, while the S level will give you up to 1,000 requests every minute. Both are probably more than enough for a proof-of-concept test (I’d be surprised if using the S level costs you even a dollar for a proof-of-concept project).
• The option stating that you’ve read the documents on the responsible use of AI that are linked to from the page.

After filling out this page, I skipped the rest of the wizard by clicking the Review + Create button. If you want to control network access, set up a managed identity to assign permissions or assign tags, you may want to visit the other pages. Once on the final page of the wizard, I clicked the Create button and waited patiently for my resource to be created.

Once your service is created, on the Azure site, enter Language in the search box at the top of the Azure page and select Language from the resulting dropdown list to be taken back to Azure AI Services | Language service page. You should find your new service listed there—click on the service to open its Overview page.

Your code is, eventually, going to require two pieces of information about the service:

• Its URL
• The secret key that will give your application access to the service

Both of those are available from the Overview page’s Manage keys link—clicking on the link will takes you to the service’s “Keys and endpoint” page. On that page, copy the values for Key 1 (the secret key) and EndPoint (the service’s URL) and paste them somewhere safe.

Once you’ve got those two values, you can close down your Azure page.

Create an ASP.NET Core Project

Rather than wait for my resource to be created, I started creating the ASP.NET Core application that will let me load a PDF file and call my new service to summarize its content. I set up the project, as usual for a Telerik-enabled project.

Not surprisingly, I decided to use the ASP.NET Core PDF Viewer to display the PDF document I was summarizing. The language service only accepts text files, so I also decided to use the Telerik Document Processing Library (DPL) objects to convert my PDF file to text. To support all of that, my project requires just three NuGet packages:

• AI-processing: Azure.AI.TextAnalytics
• Telerik PDF Viewer: Telerik.UI.for.ASPNet.Core
• Processing documents: Telerik.Documents.Fixed and Telerik.Web.PDF

To load and display a PDF in the kendo-pdfviewer, I added this markup to a Razor Page (I could use the same code in any View for MVC-style processing):

@page
@model IndexModel
@addTagHelper *, Kendo.Mvc

<kendo-pdfviewer height="1200"
                 name="pdfviewer">
    <dpl-processing load-on-demand="true">
        <read url="/Home/GetInitialPDF" />
    </dpl-processing>
    <toolbar enabled="false"/>
</kendo-pdfviewer>
<script src="~/kendo-ui-license.js"></script>

The kendo-pdfviewer’s read element’s url attribute has to point to a method that will retrieve the initial document to display. As the URL in my sample code implies, I implemented that by creating method called GetInitialPDF in my project’s Home controller.

In this code from my GetInitialPDF method, I use .NET’s File object to load a PDF document (named sample.pdf) from a subfolder called Documents in my project’s wwwroot folder. I use the Telerik FixedDocument object to create an object that the kendo-pdfviewer can display.

That code looks like this:

    public class HomeController
    {
        public IActionResult GetInitialPdf(int? pageNumber)
        {
            JsonResult jrt;

            byte[] pdfBytes = File.ReadAllBytes(
@"wwwroot\Documents\sample.pdf");
            var pdfDoc = FixedDocument.Load(pdfBytes, true);
            if (pageNumber == null)
            {
                jrt = new JsonResult(pdfDoc.ToJson());
            }
            else
            {
                jrt = new JsonResult(pdfDoc.GetPage((int)pageNumber));
            }
            return jrt;
        }        
    } 

Writing the AI Code

To generate the summary that I’ll display above the PDF file in my webpage, I created a separate class called AIProcessing with a method called GetSummary. I set up the GetSummary method to return my summary (a string) and to accept the relative file path to the document in my website (also a string). I’m eventually going to call an async method inside this method, so I set up my GetSummary method with async modifier and wrapped my return value in a Task object:

public class AIProcessing
{    
    Internal async Task<string> GetSummary(string docPath)
    {

Within my GetSummary method, I create:

• PdfFormatProvider to convert my PDF document into a Telerik RadFixedDocument
• TextFormatProvider to convert my RadFixedDocument into text

With those two objects in place, I use a .NET File object to read my document into a Stream that I import into the PdfFormatProvider to create a format-neutral RadFixedDocument. I then feed the RadFixedDocument to the TextFormatProvider’s Export method to create my text document:

PdfFormatProvider pdfProv = new PdfFormatProvider();
TextFormatProvider txtProvider = new TextFormatProvider();

using (Stream str = File.OpenRead(docPath))
{
    RadFixedDocument radDoc = pdfProv.Import(str);
    string txtDoc = txtProvider.Export(radDoc);

Now I have a text document that I can feed to my Language Service. The next step is to connect to my Language Service. I do that by creating a TextAnalysisClient object, passing the URL and secret key I copied from my service’s “Keys and endpoint” page (I’ve omitted those values from this sample code):

TextAnalyticsClient tac = new TextAnalyticsClient(
    new Uri("<Endpoint>"),
    new AzureKeyCredential("<Key 1>"));

To actually pass my text document to the service, I need to add the document to a List of TextDocumentInput objects … which means I first have to create a TextDocumentInput that holds my text document.

A TextDocumentInput consists of a unique identifier for the document (unique within the collection, at any rate) and the text document itself. For the key, I decided to use the name of my PDF file (I used the .NET Path class to pull the file name out of the filepath passed to my method). Once I’ve created that TextDocumentInput, I add it to my list.

Here’s that code:

string key = Path.GetFileName(docPath);
TextDocumentInput doc = new(key, txtDoc);
IList<TextDocumentInput> docs = new List<TextDocumentInput>();
docs.Add(doc);

The next step is to create my summary by calling the Language Service’s AbstractiveSummarize method and then catch the resulting AbstractiveSummarizeOperation object.

I won’t lie: The summary is buried pretty deeply in the AbstractiveSummarizeOperation object. Once you have the object, you first call its GetValues method which hands back the collection of results from the analysis. The summaries that I’m interested in for this case study are in the first results collection returned by the GetValues method, so I use this code to retrieve that collection of results:

AbstractiveSummarizeOperation aso = await tac.AbstractiveSummarizeAsync(
WaitUntil.Completed, docs);
AbstractiveSummarizeResultCollection results = aso.GetValues().First();

Now that I’ve got the result collection I’m interested in, I pull out the result for the document I’m interested in, using the key I created when adding the document to the list of documents I processed (in my case, that key was the file name). I worry about things so, in the following code, I check to see if I found a result and, if I did, pull out the text of the first summary in the result. That summary is what I return from this method (and if I don’t find anything, I return an empty string):

AbstractiveSummarizeResult docResult = results.FirstOrDefault(r => r.Id == key);
if (docResult != null)
{
    return docResult.Summaries.First().Text;
}
return string.Empty;

Adding the Summary to the Page

The last step is to display that summary on my page just above my PDF document. I just need update my Razor Page’s GetAsync method with the code to call my GetSummary method and then update a property in my Razor page with the text summary the method returns. If I were using MVC-style processing, I’d put this code in a method in my Controller that a user could surf to and update a property on the Model I would pass to the View holding my PDF Viewer.

This code catches the string returned by my GetSummary method and stuffs it into a property called summary:

    public string summary { get; set; }
        
    public async Task OnGetAsync()
    {
        AIProcessing aiproc = new AIProcessing();
        summary = await aiproc.GetSummary(@"wwwroot\Documents\526M_Labs.pdf");
    }

I feel that I should make at least some attempt to provide a readable display of the summary and the document, so I used this markup in my View to display the summary property (in Model.summary), just above my PDFViewer, inside a nicely formatted box:

@page
@model IndexModel
@addTagHelper *, Kendo.Mvc

<div style="width: 800px">
    <label>Summary:</label>
    <div style="margin: 20px; padding: 5px; border:1px solid black;">
        @Model.summary
    </div>
    </br>
    <label>Full Document:</label>
    <div style="margin: 20px">
        <kendo-pdfviewer name="pdfviewer">
…..
       </kendo-pdfviewer>
    </div>
</div>

Of course, you won’t want an application that displays exactly one document. To add the ability to dynamically switch between documents and generate summaries for each document, you should look at the PDF Viewer’s documentation.

But that’s your problem. What I wanted to know was: Are the summaries any good?

So: How Good Are the Summaries?

To test the quality of the summaries generated, I decided to use some of my own articles, as published on the Telerik.com site. Among other issues, this plan would avoid any copyright infringement issues. In addition, you can review those documents and make your own decision on how good the summaries are (that you’ll also be driving up my readership statistic when you do is just a happy accident).

For my first test, I took a subject near and dear to my heart that has general appeal but also has some technical content: The second of a series of posts I did on the fundamental principles of UX design (there’s nothing wrong with the first post, but I wanted something a little geekier than that introductory post). Here’s the AI generated summary:

The article provides a comprehensive guide on implementing effective user interfaces (UIs) by adhering to five key principles. It emphasizes the importance of being consistent with design, leveraging design patterns, supporting user scenarios, organizing UIs logically, and conducting thorough testing. The author introduces the concept of supporting a user’s mental model, whether it’s guiding them through a process or replacing it with a new one that offers greater value. The article further delves into the use of progress bars, menu structures, and navigation tools to enhance the user experience. It also discusses the significance of understanding user expectations and mental models in creating intuitive and efficient UIs.

And, I have to admit: That’s a pretty good summary of what I covered in the article. To put it another way—if I was forced to write a 100-word summary of that post, I don’t know that I could do better.

For my second test, I went with a post with very little technical content and more of a business orientation: A post on enterprise reporting standards and best practices. Here’s the summary for that post, which is also pretty good:

Enterprise reporting has evolved with self-service reporting tools, enabling users to transform data into valuable information independently. However, this progression has introduced two levels of reports: those created for individual or team use, and enterprise reports intended for a broader audience, often across multiple departments. To manage these reports effectively, it’s crucial to organize them in a way that’s intuitive for users, much like curating art in a museum. Each report should have a clear description, outlining its target audience, the questions it answers, and the data aggregation level, which aids in assessing report quality and relevance. Additionally, establishing consistent data sources, a standardized report format, and a company-wide style sheet are vital steps in ensuring the accuracy, accessibility, and coherence of enterprise reports.

I would have made a couple of changes in this summary:

• In the third sentence, I would replace “To manage these reports” with “To manage those reports for the broader audience.”
• In the second to last sentence, I would replace the clause “which aids in assessing report quality and relevance” with a separate sentence—something like “Those are also criteria that can be used in assessing…” Other than that, though, I’d be happy with this summary.

And for my final test … how about this document you just read (minus this paragraph and the next)? It’s nerdier than the previous two documents and self-referential so it doesn’t get it quite right, does it:

The source document provides a comprehensive guide on integrating AI analysis with Telerik’s PDF viewer and document processing tools, as well as implementing AI-enabled summaries using Azure’s Language Services. It details the process of creating an ASP.NET Core application that can display a PDF document and call upon an AI service to generate a summary, which is then displayed above the document. The document emphasizes the importance of understanding user expectations and mental models in designing intuitive and efficient user interfaces. Additionally, the document includes a case study where the author tests the quality of AI-generated summaries using their own articles and explores the principles of effective user experience design.

Plainly, the processor got a little confused between the content of the article and the examples that I used to demonstrate what you should expect from the tool (it was all too “meta,” I guess). But fixing that would just mean deleting two things: the second to last sentence on UI design and the clause at the end of the last sentence. I’d also like to include a sentence about how this article contains all the code you need to implement language processing in your own application. Altogether, maybe 30 seconds’ work. I could live with that.

But that’s only my opinion and I’m not here to tell you what to think: You can skim the articles and make up your own mind. And, if you decide that the summaries have value and, with whatever issues you have, the AI generated summaries are better than no summary at all … well, now you know to add them to your own apps.

But here’s the important part: I used the S, paid tier to build this case study. Development, testing and running all of these samples cost me a total of six cents. I can live with that. I might even do some more.

He did, indeed, do more. Read the next post: Applying AI Document Analysis with Blazor.

Try out Telerik UI for ASP.NET Core yourself, free for 30 days.

Try Now

The smooth integration between the Progress Telerik UI for WinForms suite and the Document Processing Libraries brings a full set of file formats that are supported by RadGridView and its export functionality.

RadGridView can be exported to XLSX (XLS*), CSV, PDF, TXT and HTML. Considering the number of records and how important the style settings are to the generated file, we can optimize the export time by running the export asynchronously. Let’s get familiar with all the options you have when you generate a file with the data stored in the grid control.

Export with RadSpreadProcessing

GridViewSpreadExport utilizes our RadSpreadProcessing library to export the content of RadGridView to XLSX (XLS*), CSV, PDF and TXT formats.

The spread export functionality requires the TelerikExport.dll assembly. To access the types in TelerikExport, you must include the assembly in your project and reference the Telerik.WinControls.Export namespace.

GridViewSpreadExport spreadExporter = new GridViewSpreadExport(this.radGridView1);
SpreadExportRenderer exportRenderer = new SpreadExportRenderer();
string fileName = @"..\..\exportedFile.xlsx";
spreadExporter.RunExport(fileName, exportRenderer);
Process.Start(fileName);

*Image export is not available in the XLS format provider.

You will notice that the default settings for the export wouldn’t bring the same look and feel to the exported file. If you need to achieve as close as possible the style available in the grid inside the exported file, like columns’ width or font, you can enable the ExportVisualSettings property or handle the CellFormatting event and apply all the style changes you need.

More information about the public API that the GridViewSpreadExport offers is available in the Properties and Events sections in the online documentation.

Each column in RadGridView has an ExcelExportType property that you can use to explicitly set the data type of the cells in the exported document.

To change the format of the exported data: Set the ExcelExportType property of the specific column to Custom and specify the ExcelExportFormatString property with the desired format. (Read more.)

this.radGridView1.Columns["ProductID"].ExcelExportType = Telerik.WinControls.UI.Export.DisplayFormatType.Custom;
this.radGridView1.Columns["ProductID"].ExcelExportFormatString = "#.#";
this.radGridView1.Columns["Unitprice"].ExcelExportType = Telerik.WinControls.UI.Export.DisplayFormatType.Currency;

The ExportFormat property defines the format the grid will be exported to. The available values are:

• XLSX
• PDF
• CSV
• TXT

The default value of the property is XLSX, hence, if not otherwise specified, the exporter will export to XLSX.

Export with RadSpreadStreamProcessing

When it comes to a scenario of exporting a grid with a lot of records, e.g., 100,000 rows, it may require some time to generate the export file with the GridViewSpreadExport.

After performing a quick test, it took around 50 seconds to export 100K records with the GridViewSpreadExport:

Here comes the GridViewSpreadStreamExport that uses the RadSpreadStreamProcessing library which allows you to create big documents (without loading the entire document in the memory) and export them to the most common formats. Thus, you can optimize the export time and memory consumption.

GridViewSpreadStreamExport spreadStreamExport = new GridViewSpreadStreamExport(this.radGridView1);
spreadStreamExport.ExportVisualSettings = true;
string fileName = @"..\..\exportedFile.xlsx";
spreadStreamExport.RunExport(fileName, new SpreadStreamExportRenderer());

As a result, the same number of grid rows are exported much faster with the stream export in around 20 seconds:

A full list of the public API and fine-tuning for the exported file can be found here.

Export with RadPdfProcessing

RadGridView’s data can be exported natively to the PDF format by GridViewPdfExport, which utilizes the powerful RadPdfProcessing library.

The GridViewPdfExport functionality is also located in the TelerikExport.dll assembly. You need to include the following namespace in order to access the types contained in TelerikExport: Telerik.WinControls.Export.

Telerik.WinControls.Export.GridViewPdfExport pdfExporter = new Telerik.WinControls.Export.GridViewPdfExport(this.radGridView1);
pdfExporter.FileExtension = "pdf";
pdfExporter.HiddenColumnOption = Telerik.WinControls.UI.Export.HiddenOption.DoNotExport; ;
pdfExporter.ShowHeaderAndFooter = true;

pdfExporter.HeaderHeight = 30;
pdfExporter.HeaderFont = new Font("Arial", 22);
pdfExporter.Logo = System.Drawing.Image.FromFile(@"C:\MyLogo.png");
pdfExporter.LeftHeader = "[Logo]";
pdfExporter.LogoAlignment = ContentAlignment.MiddleLeft;
pdfExporter.LogoLayout = Telerik.WinControls.Export.LogoLayout.Fit;

pdfExporter.MiddleHeader = "Middle header";
pdfExporter.RightHeader = "Right header";
pdfExporter.ReverseHeaderOnEvenPages = true;

pdfExporter.FooterHeight = 30;
pdfExporter.FooterFont = new Font("Arial", 22);
pdfExporter.LeftFooter = "Left footer";
pdfExporter.MiddleFooter = "Middle footer";
pdfExporter.RightFooter = "Right footer";
pdfExporter.ReverseFooterOnEvenPages = true;

pdfExporter.FitToPageWidth = true;
string fileName = @"..\..\exportedFile.pdf";
pdfExporter.RunExport(fileName, new Telerik.WinControls.Export.PdfExportRenderer());

Once you have the grid’s content exported to one of the above-mentioned file formats, with the help of the Document Processing Libraries it is possible to manage further the file and convert it to any other format supported by the DPL.

Export to HTML

If you need to export the grid’s content in HTML format, it is suitable to use the ExportToHTML class. It offers excellent export performance and creates an HTML formatted file, which can be opened in a browser or MS Word. However, the HTML export is pretty old and its API is very limited.

That is why we strive to utilize as much as possible the rich API of our Document Processing Libraries for exporting the RadGridView. It includes a set of cross-platform libraries that let you import and export content between different formats and work with archive files.

Try It for Free

Try out the GridView and 160 other controls from Telerik UI for WinForms today with our free trial:

Try Telerik UI for WinForms

Better yet, try Telerik UI for WinForms and Document Processing Libraries (and a bunch of other good stuff) with Telerik DevCraft—the most comprehensive UI component suite you can get your hands on:

Try Telerik DevCraft

Working with PDF documents is a common request for every business application, no matter whether it is mobile, desktop or web. The Progress Telerik suite for .NET MAUI offers a PDF library to edit and create documents programmatically. And now with R2 2023, you can display any PDF document you need to no matter whether it includes Images, Shapes, Links, Lists or various other visual elements.

The PDF Viewer for .NET MAUI is supported in Windows, macOS, iOS and Android platforms and comes with:

• Support for various document sources – You can load a PDF document from a stream, from a file added as an embedded resource, a file located on the device and so on.
• Support for complex PDF structure – Link annotations, lists, visuals, different fonts and more.
• Zooming, continuous scrolling and navigation capabilities – You can choose between different layout modes and configure the level of zooming factor to magnify the documents.
• API for advanced scenarios – Tinker with the settings for more specialized situations such as opening password-protected documents, opening invalid documents and more.
• Load On Demand – The PDF Viewer control implements read-on-demand loading, and each page of the document loads dynamically only when it is shown in the PDF Viewer. When that page isn’t in the view area, it gets unloaded. The stream that holds the document stays open while the document is used in PDF Viewer.
• BusyIndicator, toolbar with predefined items and rich customization options – Take advantage of a pre-defined UI automatically wired with some of the commands provided by the control through built-in functionality.

Enough talking, let’s see it in action:

Set up the Component in the .NET MAUI App

As with any of the other UI components, setting up Telerik UI for .NET MAUI is simple and can be done in three steps:

1. Download and install Telerik UI for .NET MAUI.
2. Call the UseTelerik() method inside the Maui Program.cs file of your .NET MAUI project. This is needed for all Telerik UI for .NET MAUI components as UseTelerik() registers all built-in or additionally created handlers to the Telerik components.
3. Define Telerik PDFViewer in XAML or C#.

XAML

xmlns:telerik="http://schemas.telerik.com/2022/xaml/maui"
<telerik:RadPdfViewer x:Name="pdfViewer" />

C#

using Telerik.Maui.Controls
RadPDfViewer pdfViewer = new RadPdfViewer();

Now, if you run the application, the control will be there. But a document still needs to be loaded, so let’s continue with this.

Display Documents from Various Sources

Documents can be loaded from various document sources like:

• FileDocument
• Uri
• ByteArray
• Stream
• FixedDocument

The magic happens with the Source property of the component type—DocumentSource accepts FileName, UriBytes, FixedDocument or direct stream.

Note: Detailed illustrations for all types of sources can be found in Telerik documentation.

For this post, we will open a document stored as part of the .NET MAUI application. The best way to do that is to use the Stream function to load the document as shown below:

Func<CancellationToken,  Task<Stream>> streamFunc = ct =>  Task.Run(()  =>  
{  
  Assembly assembly =  typeof(MinMaxZoomLevel).Assembly;  
  string fileName = assembly.GetManifestResourceNames().FirstOrDefault(n => n.Contains("pdfdoc.pdf"));// here we are searching for the resource document  
  Stream stream = assembly.GetManifestResourceStream(fileName);  
  return stream;  
});  
this.pdfViewer.Source  = streamFunc;

Another good option is to use the integration between the Telerik PDF Processing library and create a FixedDocument/RadFixedDocument and use it as a Source to the PDFViewer.

Telerik PDF Processing Library API is part of Telerik UI for .NET MAUI, and you already have a reference to it once you added Telerik PDFViewer to your app. Learn more about what other capabilities this gives you here: Telerik Document Processing.

By using this approach, you have more control over the loading process. For example, you can modify the document after importing it and before assigning it as a Source to the PDF Viewer control.

Then the code will look like this:

Telerik.Windows.Documents.Fixed.FormatProviders.Pdf.PdfFormatProvider provider =  new  Telerik.Windows.Documents.Fixed.FormatProviders.Pdf.PdfFormatProvider();  
  Assembly assembly =  typeof(MinMaxZoomLevel).Assembly;  
  string fileName = assembly.GetManifestResourceNames().FirstOrDefault(n => n.Contains("pdf-processing.pdf"));  
  using (Stream stream = assembly.GetManifestResourceStream(fileName))  
  {  
    RadFixedDocument document = provider.Import(stream);  
    this.pdfViewer.Source  = document;  
  }

No matter which approach you choose, the result will be a loaded document, a beautiful long PDF with a table of contents, different fonts, tables, shapes and images.

Let’s continue to work with this document to see what else we can do. The full document and demo can be found in Telerik GitHub repo – Getting Started.

Configure the Document

First, Let’s Configure the Fonts

When you load a PDF document in Telerik PDF Viewer it already comes embedded with 14 standard fonts:

• Helvetica
• Helvetica-Bold
• Helvetica-Oblique
• Helvetica-BoldOblique
• Courier
• Courier-Bold
• Courier-Oblique
• Courier-BoldOblique
• Times-Roman
• Times-Bold
• Times-Italic
• Times-BoldItalic
• Symbol (Symbol)
• ZapfDingbats

However, you can embed all other fonts that you want to be displayed using the RegisterFont method that is part of Telerik PdfProcessing Library API .

Telerik.Windows.Documents.Fixed.Model.Fonts.FontsRepository.RegisterFont(  
new  FontFamily("Verdana"),  FontStyles.Normal,  FontWeights.Normal, fontData);

Note: Make sure to update the build action of the .ttf file to embedded resource.

Choose a Layout: One Page at a Time or by Scrolling to the End

The Telerik UI for .NET MAUI PDF Viewer supports two layout modes that you can set through its LayoutMode property.

The available options are:

• ContinuousScroll (default) – Displays pages in a continuous vertical column.
• SinglePage – Displays one page at a time.

We will stay with ContinuousScroll, but you can switch to SinglePage like this: LayoutMode="SinglePage"

You can also give the same control to the end user by exposing a separate UI and bind the ToggleLayoutModeCommand to it or add a ToggleLayoutModeToolbarItem to the toolbar (wait a sec for that, when we will talk more about the ToolBar ).

Control the Space Between Pages

Once you choose the layout, you can continue with setting the space between pages using the PageSpacing property.

For example, if you want to have 50px between pages the code will look like this:

<telerik:RadPdfViewer x:Name="pdfViewer" PageSpacing="50" />

Zooming & Scrolling

RadPdfViewer offers a smooth end-user navigation experience with zooming and scrolling and a rich API to control it programmatically.

You can control the zoom level with two properties: MaxZoomLevel and MinZoomLevel. The default value of both is 0.3.

There are also commands that you can expose outside the component to build your own navigation:

• ZoomInCommand
• ZoomOutCommand
• NavigateToNextPageCommand
• NavigateToPreviousPageCommand
• NavigateToPageCommand

Link Annotations

The Telerik .NET MAUI PDF Viewer supports link annotations and allows the end user to tap any hyperlink that leads to an absolute URI, and the link will open in the browser.

In addition, if the PDF contains links that point to bookmarks in the same document, the viewport scrolls to the destination specified in the link so you can easily display scenarios as Table of Contents, Sections and others.

The behavior can also be customized by subscribing to the LinkAnnotationTapped event which fires when a link is tapped/clicked. For example:

private void LinkTapped(object sender,  Telerik.Maui.Controls.PdfViewer.Annotations.LinkAnnotationTappedEventArgs e)  
{  
  if  (e.LinkAnnotation.Action  is  UriAction uriAction)  
  {  
    e.Handled  =  true;  
    Application.Current.MainPage.DisplayAlert("Confirm",  "Are you sure you want to navigate",  "Yes",  "No").ContinueWith(t =>  
    {  
      bool shouldNavigateAway = t.Status  ==  TaskStatus.RanToCompletion  ? t.Result  :  false;  
      if  (shouldNavigateAway)  
      {  
        Dispatcher.Dispatch(()  =>  
        {  
          Launcher.OpenAsync(uriAction.Uri);  
        });  
      }  
    });  
  }  
}

Password Protection

Security and privacy is an important topic in the era of information that we are living in, so sometimes we need to work with password-protected documents and be cautious about the access we provide.

Telerik PDFViewer provides a SourcePasswordNeeded event to subscribe to validate the access to documents like this:

private  void pdfViewer_SourcePasswordNeeded(object sender,  Telerik.Windows.Documents.Fixed.FormatProviders.Pdf.Import.PasswordNeededEventArgs e)  
{  
e.Password  =  "my_user_password_here";  
}

Manipulate the Document OnLoad

Sometimes we need to control end-user behavior or change something in the document when a page is loaded. The OnPageElementsLoaded is here for that. When this event fires we can access the page content and modify it like this:

private  void  OnPageElementsLoaded(object sender,  PageElementsLoadedEventArgs e)  
{  
  foreach  (var item in e.Page.Content)  
  {  
    if  (item is  Telerik.Windows.Documents.Fixed.Model.Graphics.Path path)  
    {  
      if  (path.StrokeThickness  ==  0)  
      {  
        path.StrokeThickness  =  5;  
      }  
    }  
  }  
}

Handle Exception Scenarios with Style

In some cases, the PDFViewer will fail to load the desired PDF document. The reason can be an invalid stream/inaccessible URL or invalid data in the document itself.

To handle these cases, use the SourceException event of the PDF Viewer:

private  void  PdfViewerSourceException(object sender,  SourceExceptionEventArgs e)  
{  
  var error = e.Exception.Message;  
}

The PdfViewer will display the error like this:

This message will be automatically localized as Localization is part of the PDFViewer’s features. However, if you need to change the text you can do it using the key PdfViewer_SourceExceptionMessage and follow the steps here.

Or you can change the whole UI that appears by using the SourceExceptionTemplate like this:

<telerik:RadPdfViewer  x:Name="pdfViewer"  SourceException="PdfViewerSourceException">  
  <telerik:RadPdfViewer.SourceExceptionTemplate>  
    <DataTemplate>  
      <Label  Text="Oops, something went wrong  ! We miss you and will be back soon ..."  
TextColor="Purple"  
HorizontalTextAlignment="Center"  
VerticalTextAlignment="Center"  
LineBreakMode="WordWrap"  />  
    </DataTemplate>  
  </telerik:RadPdfViewer.SourceExceptionTemplate>  
</telerik:RadPdfViewer>

Configure the Component: Busy Indicator, ToolBar & More

As you see, there are a lot of features to customize the look and behavior of the displayed document. Now, let’s see what else is hidden in the developer toolbox that enables you to configure the UI of the PDFViewer:

Busy Indicator

Although the Telerik PDF Viewer is optimized for performance, sometimes it is possible to load a document that needs time to render. For such cases, a busy indicator visualizes to offer a smooth user experience.

By default, it is:

You can customize its appearance by the BusyIndicatorTemplate property:

<telerik:RadPdfViewer  x:Name="pdfViewer">  
  <telerik:RadPdfViewer.BusyIndicatorTemplate>  
    <DataTemplate>  
      <telerik:RadBusyIndicator  AnimationType="Animation10"  
AnimationContentHeightRequest="100"  
AnimationContentWidthRequest="100"  
IsBusy="True"  />  
    </DataTemplate>  
  </telerik:RadPdfViewer.BusyIndicatorTemplate>  
</telerik:RadPdfViewer>

Toolbar

Telerik PDFViewer comes with the option to be displayed with or without the Toolbar, where all configurable options for visualizing the document and controlling the navigation are exposed to the end user. Let’s see how to do that:

Add the Toolbar

The important part here is that you need to create an instance of RadPDfViewerToolbar component outside the pdfview but use the toolbar’s PdfViewer property to associate with the PDFViewer component.

<telerik:RadPdfViewerToolbar  PdfViewer="{Binding Source={x:Reference pdfViewer}}">  
…
</telerik:RadPdfViewerToolbar>
  
<telerik:RadPdfViewer  x:Name="pdfViewer"  Grid.Row="1"  
Document="{Binding Document, Mode=OneWayToSource}"  />

Add Toolbar Items

Then you can define which features are good for your users to display. There are two ways to do that:

Use the Predefined Toolbar Items

PDFViewer’s toolbar offers predefined toolbar items that have assigned any of the Commands it offers:

PDFViewer commands with PDFViewer toolbar items:

• FitToWidthCommand: <telerik:PdfViewerFitToWidthToolbarItem />
• ZoomInCommand: <telerik:PdfViewerZoomInToolbarItem />
• ZoomInCommand:<telerik:PdfViewerZoomOutToolbarItem />
• NavigateToPreviousPageCommand: <telerik:PdfViewerNavigateToPreviousPageToolbarItem />
• NavigateToNextPageCommand: <telerik:PdfViewerNavigateToNextPageToolbarItem />

<telerik:RadPdfViewerToolbar **PdfViewer**="{Binding Source={x:Reference pdfViewer}}">
  <telerik:PdfViewerFitToWidthToolbarItem  />  
  <telerik:PdfViewerZoomInToolbarItem  />  
  <telerik:PdfViewerZoomOutToolbarItem  />  
  <telerik:PdfViewerNavigateToPreviousPageToolbarItem  />  
  <telerik:PdfViewerNavigateToNextPageToolbarItem  />
</telerik:RadPdfViewerToolbar>

Use Regular Toolbar Items

RadPdfViewer Toolbar is inherited from RadToolbar with one additional PdfViewer property used to associate the PDFViewer component. That is why you can add regular toolbar items to its items collection and mix PDF Viewer toolbar items with regular ones.

Let’s add a regular toolbaritem and associate it with a custom command or one of PDF Viewer commands:

<telerik:ButtonToolbarItem  Command="{Binding DisplayFileSizeCommand}">
  <telerik:ButtonToolbarItem.ImageSource>  
    <FontImageSource  Glyph="{x:Static telerik:TelerikFont.IconFile}"  
      FontFamily="{x:Static telerik:TelerikFont.Name}"  
      Size="16"/>  
  </telerik:ButtonToolbarItem.ImageSource>  
</telerik:ButtonToolbarItem>

The result so far, where the last item is a regular ButtonToolbarItem:

Style the Toolbar Items

Now, let’s style them a little bit differently. As the PDFViewerToolbar is based on the RadToolbar control, all toolbar items in the PDFViewer inherit from ButtonToolbarItem. All styling properties available for the ButtonToolbarItem are also applicable to the PDF toolbar items.

For example, to change the background of the items defined above we can define the following style:

<Style  TargetType="telerik:ButtonToolbarItemView"  x:Key="commonStyle">  
  <Setter  Property="MinimumWidthRequest"  Value="40"/>  
  <Setter  Property="BackgroundColor"  Value="#608660C5"/>  
</Style>

And set it to them like this:

<telerik:PdfViewerZoomInToolbarItem  Style="{StaticResource commonStyle}"/>

To read more details about Telerik Toolbar for .NET MAUI and see what else it can offer, read the blog about the Toolbar.

Migrating from Xamarin

Telerik PDFViewer for .NET MAUI shares the same API as Telerik PDFViewer for Xamarin, so no big changes here. Still there two things to have in mind:

• ToolbarItems now receive the Pdf prefix so as not to conflict with the brand new RadToolBar for .NET MAUI component.
• Namespace of the control is changed from Telerik.XamarinForms.PdfViewer to Telerik.Maui.Controls.

For more details, you can refer to the Telerik Migration from Xamarin article.

Some of the features that the Xamarin version has are still in development in the .NET MAUI component, such as Text Selection and Text Search. They are scheduled for the next version of Telerik UI for .NET coming this autumn. So stay tuned!

More to Explore

More examples illustrating the power of Telerik PDFViewer and the rest of the UI components for .NET MAUI can be found in Telerik SDK and Telerik Controls Samples.

More details about the API can be found in Telerik documentation.

Details about working with PDF documents programmatically are described in Document Processing Libraries - Telerik.

Тry It Now

Working with PDF documents is one of a thousand scenarios that Telerik UI for .NET MAUI can unlock for you.

Try it now and, if there is anything you need, do not hesitate to share your feedback or questions with the Telerik team.

Try Telerik UI for .NET MAUI

The Portable Document Format (PDF) file type has become ubiquitous in business and enabling users to view, and download a PDF document is a common application requirement. The PDFViewer component from Progress Telerik UI for ASP.NET Core provides many capabilities out of the box—allowing you to open, view, download and print PDF documents. The component renders the content of a PDF document in the browser as canvas.

There are two alternative ways to process PDFs in the PDFViewer: with the help of PDF.js or the Telerik Document Processing libraries. We will look at the configuration needed for the component to work in both scenarios.

Using PDF.js Processing

You can set up the PDFViewer to use the PDF.js client-side library for processing and rendering a PDF file. PDF.js is a community-driven library for parsing and rendering PDFs supported by Mozilla.

1. Load the pdf.js library in the application Layout, or in the view you will be using the PDFViewer in.

<script  src="https://cdnjs.cloudflare.com/ajax/libs/pdf.js/2.2.2/pdf.js"></script>

2. In the view (e.g., Index.cshtml), declare the PDFViewer and set up its PdfjsProcessing configuration:

@(Html.Kendo().PDFViewer()
  .Name("pdfviewer")
  .PdfjsProcessing(pdf => pdf.File(Url.Content("~/App_Data/sample.pdf")))
  .Height(900)
)

We want a specific file to be displayed when the page loads, so we’ve set the path to the sample.pdf file in the File option within the PdfjsProcessing configuration. In this example, the file is located in the App_Data sub-folder of the application’s wwwroot folder.

The result will look like this:

Apart from displaying a file initially, the PDFViewer allows you to open a different PDF file that exists in the file system through the “Open” button in the toolbar.

Using Telerik Document Processing

The alternative to using PDF.js for processing the PDFs is using the Telerik Document Processing libraries. These libraries process the PDF document on the server and pass the data to the PDFViewer for visualization on the client.

Follow the steps below to set up the PDFViewer with Telerik Document Processing:

1. Declare the component:

@(Html.Kendo().PDFViewer()
  .Name("pdfviewer1")
  .DplProcessing(dpl =>
    {
      dpl.Read(r => r.Url(Url.Action("GetInitialPdf", "Home")));
      dpl.Upload(upload => upload.Url(Url.Action("GetPdf", "Home")).SaveField("file"));
    })
  .Height(900)
)

We will display the sample.pdf file initially, which is why we need to set the Read option in the DplProcessing configuration. It points to the GetInitialPdf action in the Home controller.

The Upload option is for opening another file from the file system. The action responsible for that is called GetPdf. When the user opens a file, it is sent for processing to the GetPdf action and then the file data is passed back to the PDfViewer, which visualizes it.

2. Declare the GetInitialPdf and GetPdf actions in the Home controller.

public IActionResult GetInitialPdf(int? pageNumber)
{
  JsonResult jsonResult;
  byte[] file = System.IO.File.ReadAllBytes(@"wwwroot\App_Data\sample.pdf");
  FixedDocument doc = FixedDocument.Load(file, true);

  if (pageNumber == null)
  {
    jsonResult = Json(doc.ToJson());
  }
  else
  {
    jsonResult = Json(doc.GetPage((int)pageNumber));
  }
  return jsonResult;
}

[HttpPost]
public IActionResult GetPdf(IFormFile file)
{
  byte[] data;
  using (Stream inputStream = file.OpenReadStream())
  {
    MemoryStream memoryStream = inputStream as MemoryStream;
    if (memoryStream == null)
    {
      memoryStream = new MemoryStream();
      inputStream.CopyTo(memoryStream);
    }
    data = memoryStream.ToArray();
  }
  FixedDocument dox = FixedDocument.Load(data);
  return Json(dox.ToJson());
}

3. When you add the two actions, Visual Studio will prompt you for missing dependencies. The processing logic in the actions depends on the Telerik Document Processing assemblies, which come with the Telerik.Web.PDF NuGet package. To resolve the missing dependencies, install the Telerik.Web.PDF NuGet package from Visual Studio’s NuGet Package Manager and add the following “using” statement to the controller:

using Telerik.Web.PDF;

Toolbar Configuration and Customization

Toolbar Items Collection

Once you’ve chosen one of the available processing approaches, you can customize the PDFViewer’s toolbar and hide the tools you don’t need.

The PDFViewer displays a set of default tools in its toolbar. If your use case requires hiding some options, you can use the Toolbar configuration of the component and explicitly declare the tools that will be shown in the toolbar.

In the following exemplary toolbar configuration, the Toolbar.Items collection specifies the tools that will be shown.

Note that the “open” tool is not declared. As a result, the “Open” button will not appear in the toolbar and the user would only be able to view the PDF document you’ve chosen to load in the PDFViewer. They would not be able to open another file.

@(Html.Kendo().PDFViewer()
  .Name("pdfviewer")
  .PdfjsProcessing(pdf => pdf
    .File(Url.Content("~/Content/pdf/sample.pdf"))
  )
  .Toolbar(toolbar =>
    toolbar.Items(items =>
    {
      items.Add().Name("pager");
      items.Add().Name("spacer");
      items.Add().Name("zoom");
      items.Add().Name("zoomInOut");
      items.Add().Name("toggleSelection");
      items.Add().Name("spacer");
      items.Add().Name("search");
      items.Add().Name("download");
      items.Add().Name("print");
    })
  )
  .Height(900)
)

You will notice that the “spacer” tool is declared twice. Its purpose is to create an empty space between the tools. You can use it to group some of the tools or to isolate one tool from the rest.

You will get the following toolbar with the configuration posted above:

Toolbar Item Template

You can go even further in the customization of the PDFViewer’s toolbar and declare custom tools by using the Template option.

The example below shows a button added as a custom tool along with some of the default tools:

.Toolbar(toolbar =>
  toolbar.Items(items =>
  {
    items.Add().Name("pager");
    items.Add().Name("spacer");
    items.Add().Name("Custom").Template("<button class='k-button k-button-solid k-button-md k-rounded-md k-button-solid-base k-icon-button'><span class='k-button-icon k-icon k-i-cog'></span></button>");
    items.Add().Name("search");
    items.Add().Name("download");
    items.Add().Name("print");
  })
)

You can attach a “click” handler to the button and execute your custom logic in it.

Next, we will look at a different scenario that involves both customizing the PDFViewer’s toolbar and using the API of the component.

Taking Advantage of the API

You may have a requirement to disable the download of PDF files, until the user accepts a terms of use agreement. A message will ask the user to confirm that they accept the agreement and want to download the file by clicking on a button outside the PDFViewer.

To achieve this requirement, you can handle the button’s “click” event and initiate the download of the file that is currently displayed by the PDFViewer with the help of the available API.

1. Hide the “download” tool by not including it in the Toolbar.Items collection:

.Toolbar(toolbar =>
  toolbar.Items(items =>
  {
    items.Add().Name("pager");
    items.Add().Name("spacer");
    items.Add().Name("zoom");
    items.Add().Name("zoomInOut");
    items.Add().Name("toggleSelection");
    items.Add().Name("spacer");
    items.Add().Name("search");
    items.Add().Name("open");
    items.Add().Name("print");
  })
)

2. The button that the user will click to confirm the agreement and start the download could look like this:

<button class="k-button k-button-solid-base k-button-solid k-button-md k-rounded-md" onclick="onAgreeButtonClick()">Agree and Download PDF</button>

3. In the button’s click handler, the download is triggered by executing the “DownloadCommand” of the PDFViewer:

<script>
  function onAgreeButtonClick() {
    // get a reference to the PDFViewer
    var pdfviewer = $("#pdfviewer").data("kendoPDFViewer");
    // execute the Download command programmatically
    pdfviewer.execute({command:"DownloadCommand"});
  }
</script>

Working with Larger Files

Finally, we will use a feature of the PDFViewer that allows you to load a large PDF document without sacrificing performance and causing the page to become unresponsive.

In scenarios that involve loading large PDF documents, use the load-on-demand functionality of the PDFViewer. It is available when the component is configured to use Telerik Document Processing.

The following snippet shows how to enable the LoadOnDemand option:

@(Html.Kendo().PDFViewer()
  .Name("pdfviewer")
  .DplProcessing(dpl => {
    dpl.Read(r => r.Url(Url.Action("GetInitialPdf", "PdfViewer")));
    dpl.Upload(upload => upload.Url(Url.Action("GetPdf", "PdfViewer")).SaveField("file"));
    dpl.LoadOnDemand(true);
  })
  .Height(900)
)

With the LoadOnDemand option enabled, instead of requesting and visualizing all the pages of the document, the component requests and renders pages on demand, which improves performance by reducing the initial load time.

If you’re interested in learning more about the PDFViewer component, check out the folowing:

• ASP.NET Core PDFViewer product page
• ASP.NET Core PDFViewer demo
• ASP.NET Core PDFViewer documentation

Try out the Telerik UI for ASP.NET Core PDFViewer Today

If you like what you’ve read and want to start taking advantage of the ASP.NET Core PDFViewer, or any of the other 110+ ready-made components, we invite you to start a free trial today. Experience firsthand that building rich interactive applications for half the time is just a click away.

Try Telerik UI for ASP.NET Core

Sharing is Caring

Once you try the ASP.NET Core PDFViewer component, don’t forget to share your experience and ideas in the comments sections below or by visiting the Telerik UI for ASP.NET Core Feedback Portal. Your input makes a difference.

In the R3 2022 Release for RadWordsProccessing from Progress Telerik Document Processing Libraries, we introduced support for five new page numbering type fields: Page, PageRef, NumPages, SectionPages and Section.

They are commonly used fields for inserting page numbering and their evaluation requires calculating the layout of the document and the size of the document elements. That calculation is done by the NumberingFieldsProvider, which needs to be implemented in order to update the fields.

Inserting Fields

For the default implementation of the NumberingFieldsProvider to work, the Telerik.Documents.Flow.FormatProviders.Pdf.dll assembly should be referenced in the project we are working with.

When it comes to inserting the fields in the document, the easiest and recommended way of doing that is via the RadFlowDocumentEditor’s InsertField method.

We will incorporate all this functionality in a simple project for you to see, but before that here is a brief overview of all the newly added fields:

• The PAGE field inserts the current page number.

PAGE [*Format Switch]

• The PAGEREF field inserts the page number of a bookmark for cross-reference.

PAGEREF Bookmark [* Format Switch ] 

• The SECTION field inserts the number of the current section.

SECTION

• The SECTIONPAGES field inserts the total number of pages in a section.

SECTIONPAGES

• The NUMPAGES field inserts the total number of pages in the document.

NUMPAGES

Now let us go together through a couple of examples that demonstrate the implementation of some of those fields in an empty RadFlowDocument:

Example 1: Page & NumPages

The first thing we need to do is create an empty document and a RadFlowDocumentEditor instance for that document, and then register the NumberingFieldsProvider:

RadFlowDocument document = new RadFlowDocument();
RadFlowDocumentEditor editor = new RadFlowDocumentEditor(document);

FlowExtensibilityManager.NumberingFieldsProvider = new NumberingFieldsProvider();

From this point on, the implementation of the various page numbering fields is mostly similar, with a few differences in case we are utilizing the switches for formatting. For example, let’s add text that shows the current page number out of the total number of pages. For this we will need the PAGE and NUMPAGES fields:

editor.InsertText("Page ");
editor.InsertField("PAGE", "");
editor.InsertText(" of ");
editor.InsertField("NUMPAGES", "");

When you are ready with the modifications of the document, you must ensure that the fields are updated, otherwise nothing will be visualized in their place. We can do that by calling the UpdateFields method of the document:

document.UpdateFields();

And after exporting the document the result that the above-provided code snippet produces should be “Page 1 of 1.”

Example 2: PageRef

Let’s do the same thing but this time bring up the page number of a bookmark we have added. To achieve that, we will use the PAGEREF field with a formatting switch:

Bookmark bookmark = editor.InsertBookmark(“MyBookmark");

editor.InsertText("Bookmark Page: ");
editor.InsertField("PAGEREF MyBookmark \h", "");

document.UpdateFields();

The “\h” switch in this case creates a hyperlink to the bookmarked paragraph and the final result ends up being “Bookmark Page: 1.”

If you are curious and want to find out more about the capabilities and functionality of those recently introduced fields as well as some other examples, you can head to the WordsProccessing: Fields documentation and explore further.

Try These New Features out & Share Your Feedback with Us

Regardless if you are new to Telerik Document Processing or already a user, you can head over and download a free trial. Your Telerik Account provides access to the latest bits you might need, or you can just update the NuGet package references in your .NET solutions.

Each input we get, whether big or small, can make the huge difference we are looking for in our growth and progression. So please, feel welcome to look around and share your thoughts in our Feedback Portal or just leave a comment below about your experience.

In the world of digital signatures, the ability to sign PDF documents is a game changer. And with the RadSignature component from Progress Telerik UI for ASP.NET AJAX, this process has never been easier!

Read on to find out how to effortlessly save a signature within a PDF file using the Telerik Document Processing Libraries (DPL) and to present the signed document in the RadPdfViewer control.

Whether you’re a developer wanting to integrate a digital signature into your project, or just looking to explore the world of digital signatures, this blog post is the perfect starting point.

Join us as we show you how to:

• Extract applied signature as PDF
• Create a new PDF document that includes your signature
• Load the signed document in a PdfViewer

With the help of Telerik UI for ASP.NET AJAX, we’ll demonstrate how to convert the signature content to PDF and base64 string representation. And the best part—you can preview the PDF file using the built-in RadPdfViewer, and even save the new document with the click of a button. So why wait? Let’s dive into the world of digital signatures and explore the possibilities with RadSignature for ASP.NET AJAX.

Prerequisites

Let’s start with declaring the needed controls on the page:

1. RadSignature is needed to apply the signature that we want to transfer to the PDF file.

ASPX

<telerik:RadSignature  runat="server"  ID="RadSignature1"  Maximizable="false"  Height="150"  Width="100%"  Rounded="None"></telerik:RadSignature>

2. RadPdfViewer is needed to display the PDF file that we are currently working on while exposing some of its useful built-in features such as zoom, download, print, search, toggle selection and paging.

ASPX

<telerik:RadPdfViewer runat="server" ID="RadPdfViewer1" Height="700px">
    <PdfjsProcessingSettings>
        <FileSettings Url="Documents/Document.pdf" />
    </PdfjsProcessingSettings>
</telerik:RadPdfViewer>

In this sample, we are passing the unsigned PDF file by a relative path through the FileSettings of the PdfViewer. Yet, there are multiple other ways you can populate the Viewer. The most common ones you can find explained in the 5 Different Approaches of Setting up the Content in RadPdfViewer for ASP.NET AJAX blog post.

3. RadToolBar contains the needed buttons and color pickers which enable the users to customize the Signature appearance and align it to their personal preferences on their own.

ASPX

<telerik:RadToolBar runat="server" ID="RadToolBar1" AutoPostBack="false" OnClientButtonClicked="clientToolBarButtonClicked">
    <Items>
        ...
    </Items>
</telerik:RadToolBar>

The ToolBar is not under the spotlight now, so we will not dig into its details now. It is here just to sweeten the UX of the demo.

4. RadButton is needed to trigger the whole process prior to signing the document and previewing it.

ASPX

<telerik:RadButton  runat="server"  ID="RadButton1"  Text="Place Your Signature"  Icon-PrimaryIconCssClass="rbSave"  AutoPostBack="false"  Primary="true"  OnClientClicked="processSignature"  />

Not all heroes wear capes, right? Just like that, not all components are on the front stage—some stay behind the scenes but are still needed:

5. RadClientExportManager is required to export the applied signature into a PDF format and get its data as a base64 string.

ASPX

<telerik:RadClientExportManager  runat="server"  ID="RadClientExportManager1"  OnClientPdfExporting="clientPdfExporting"></telerik:RadClientExportManager>

6. RadAjaxManager is there to improve the user experience by performing AJAX requests for passing the signature to the server and the manipulated pdf back to the browser.

ASPX

<telerik:RadAjaxManager ID="RadAjaxManager1" runat="server" OnAjaxRequest="RadAjaxManager1_AjaxRequest" DefaultLoadingPanelID="RadAjaxLoadingPanel1">
    <AjaxSettings>
        <telerik:AjaxSetting AjaxControlID="RadAjaxManager1">
            <UpdatedControls>
                <telerik:AjaxUpdatedControl ControlID="RadPdfViewer1" />
            </UpdatedControls>
        </telerik:AjaxSetting>
    </AjaxSettings>
</telerik:RadAjaxManager>

7. RadAjaxLoadingPanel is needed to display a progress indicator graphic while processing the data on the server-side.

ASPX

<telerik:RadAjaxLoadingPanel  runat="server"  ID="RadAjaxLoadingPanel1"></telerik:RadAjaxLoadingPanel>

Alongside all the above-mentioned components, we will also need to reference the Telerik Document Processing Libraries (DPL) and specifically the RadPdfProcessing library assemblies necessary for manipulating the content of a PDF file. Find the list of the .dll files required for the RadPdfProcessing in the dedicated documentation page.

Once we have the components defined, the DPL referenced and the unsigned PDF loaded in the view, we can go ahead with the logic.

I bet you’ve noticed that the event handlers we are going to use are already defined in the control snippets above. So, let’s go through the process after the user has applied their signature and clicks the blue “Place Your Signature” button.

Extract Applied Signature as PDF

The OnClientClicked event of the button fires upon clicking the blue button. In its listener, we can get the canvas element with the applied signature with a bit of jQuery help, and also get the ClientExportManager client-side control. Via the exportToPdf() method of the export manager we can trigger exporting the canvas to a pdf:

JavaScript

processSignature = function (sender, args) {
    //get the ClientExportManager client-side control object
    var clientExportManager = $telerik.findControl(document, "RadClientExportManager1");
    //get the canvas element holding the applied signature
    var signatureElement = $(".k-signature-canvas > canvas");
    //trigger exporting to pdf procedure via the built-in method of the ExportManager
    clientExportManager.exportPDF(signatureElement);
}

After that, the OnClientPdfExporting event of the export manager fires. Here we can get the PDF representation of the signature as a base64string directly from the event arguments (get_dataURI()). Get the AJAX manager and send an AJAX request to the server with the signature data optionally along with a custom file name:

JavaScript

clientPdfExporting = function (sender, args) {
    //get the base64string of the pdf passed for exporting
    var dataRaw = args.get_dataURI();
    //get the RadAjaxManager control object
    var ajaxManager = $telerik.findControl(document, "RadAjaxManager1");
    var fileName = "signature.png";
    //send an ajax request to the server with the signature data and the filename
    ajaxManager.ajaxRequest(fileName + ";" + dataRaw);

    //prevent further execution of the built-in exporting logic of the ExportManager
    args.set_cancel(true);
}

Once the request reaches the server, the AjaxRequest event of the RadAjaxManager fires. There we can get the base64 string of the signature and pass it to the function responsible for generating a signed PDF. Finally, pass the base64 string representation of the signed PDF as content of the PdfViewer.

C#

protected void RadAjaxManager1_AjaxRequest(object sender, Telerik.Web.UI.AjaxRequestEventArgs e)
{
    var base64 = e.Argument.Split(',')[1];

    RadPdfViewer1.PdfjsProcessingSettings.FileSettings.Data = PreparePdf(base64);
}

Create a New PDF Document That Includes Your Signature

Let’s explore the exact purpose of the PreparePdf() method.

With the help of the Document Processing Libraries (DPL), we can easily generate an all-new copy of the unsigned PDF document that we have. Then we can append the signature content we already extracted into the new Pdf document at a desired position.

C#

public string PreparePdf(string pdfData)
{
    byte[] resultingBytes = null;
    byte[] finalBytes = null;

    //initialize a PdfFormatProvider that will be used for processing the pdf conent
    PdfFormatProvider provider = new PdfFormatProvider();

    byte[] renderedBytes = Convert.FromBase64String(pdfData);

    RadFixedDocument document1 = null;
    //generate a RadFixedDocument object holding the signature data
    RadFixedDocument document2 = provider.Import(renderedBytes);

    //import the existing unsigned pdf file in another RadFixedDocument 
    string filePath = Server.MapPath("Documents/Document.pdf");
    using (FileStream input = new FileStream(filePath, FileMode.Open, FileAccess.Read))
    {
        document1 = provider.Import(input);
    }

    //export the unsigned pdf as byte array
    using (MemoryStream ms = new MemoryStream())
    {
        provider.Export(document1, ms);
        resultingBytes = ms.ToArray();
    }

    //pass the byte array of the unsigned pdf and the RadFixedDocument with the applied signature to method that will combine them in a single byte array
    finalBytes = AppendContent(resultingBytes, document2);

    //convert the result to a base64 string and return it so it can be passed as content of the PdfViewer
    string result = Convert.ToBase64String(finalBytes);
    return result;
}

The actual manipulation of the PDF content happens in the AppendContent() method. Its logic heavily relies on the functionalities exposed by the RadPdfProcessing library:

C#

private byte[] AppendContent(byte[] resultingBytes, RadFixedDocument document2)
{
    RadFixedPage foregroundContentOwner = document2.Pages[0];

    MemoryStream ms = new MemoryStream();
    byte[] renderedBytes = null;
    using (MemoryStream stream = new MemoryStream(resultingBytes))
    {
        using (PdfFileSource fileSource = new PdfFileSource(stream))
        {
            using (PdfStreamWriter fileWriter = new PdfStreamWriter(ms, true))
            {
                foreach (PdfPageSource pageSource in fileSource.Pages)
                {
                    using (PdfPageStreamWriter pageWriter = fileWriter.BeginPage(pageSource.Size, pageSource.Rotation))
                    {
                        pageWriter.WriteContent(pageSource);

                        using (pageWriter.SaveContentPosition())
                        {
                            double xCenteringTranslation = (pageSource.Size.Width - foregroundContentOwner.Size.Width) - 320;
                            double yCenteringTranslation = (pageSource.Size.Height - foregroundContentOwner.Size.Height) - 110;
                            pageWriter.ContentPosition.Translate(xCenteringTranslation, yCenteringTranslation);
                            pageWriter.WriteContent(foregroundContentOwner);
                        }
                    }
                }
            }
        }
    }
    renderedBytes = ms.ToArray();
    return renderedBytes;
}

We will not go through each separate class and method of the DPL that is used, but I highly recommend spending some time getting familiar with the RadPdfProcessing Model and Concepts.

Everything written here is live and accessible in this demo. Go on and give it a try right away!

If you like what you see, you can further play with the RadSignature in the online demos or download its absolutely free and fully functional trial and give it a spin.

We value any feedback and the community voice, which you can share at the Feedback Portal too.

Start a Free Trial

Many of you requested us to provide you with the ability to export your documents or parts of them to images in .NET Standard/.NET Core applications. As we are always listening to your feedback, during the last release we worked hard to provide you with this functionality and I will present it in this blog post.

To make it possible for all platforms using the .NET Standard version of PdfProcessing to create images, the library uses a third-party tool for image generation—SkiaSharp. Multiple image formats are supported, and you can also choose whether to perform the exporting operation synchronously or asynchronously.

Let’s take a closer look at the API related to the new functionality. The entry point making all the magic is the SkiaImageFormatProvider class. If you are already using PdfProcessing, you should be familiar with the format providers and how they work. For all the rest, in short, the format providers expose Import and Export methods that enable you to parse a document into the internal model of the library or save the information from this model into a document file, respectively.

Let’s Create an Example

To better demonstrate the functionality and its usage, I will guide you step by step on creating an application that opens an existing PDF document and converts its pages into images.

First things first—I will create a console application and add the dependencies we need to use the PdfProcessing library. For more convenience, I will directly go with the Telerik.Documents.Fixed.FormatProviders.Image.Skia NuGet package that will download all of its dependencies automatically:

In case you prefer adding references to the .dll files, here is the list of required assemblies:

• Telerik.Documents.Core
• Telerik.Documents.Fixed
• Telerik.Zip
• Telerik.Documents.Fixed.FormatProviders.Image.Skia

As I mentioned earlier, the image exporting functionality depends on SkiaSharp, thus you will need to add dependencies to its binaries as well:

• The SkiaSharp NuGet package
• The SkiaSharp.NativeAssets.* NuGet package. This package may differ according to the used platform. There are versions for Windows, MacOS, Linux, WebAssembly, Android, iOS and others.

Once we are ready with the setup, we can continue to add some logic to our application. The first step we need to implement is to read the PDF document we already have:

byte[] fileBytes = File.ReadAllBytes("SampleDocument.pdf");
 
Telerik.Windows.Documents.Fixed.FormatProviders.Pdf.PdfFormatProvider pdfFormatProvider = new Telerik.Windows.Documents.Fixed.FormatProviders.Pdf.PdfFormatProvider();
Telerik.Windows.Documents.Fixed.Model.RadFixedDocument fixedDocument = pdfFormatProvider.Import(fileBytes);

After having the document imported, you can now convert its pages to images through the Export method. In this example, each page is saved in a separate file.

SkiaImageFormatProvider imageProvider = new SkiaImageFormatProvider();
 
foreach (RadFixedPage page in fixedDocument.Pages)
{
    byte[] resultImage = imageProvider.Export(page);
    int pageNumber = fixedDocument.Pages.IndexOf(page) + 1;
    File.WriteAllBytes(@"C:\Temp\Images " + pageNumber + ".png", resultImage);
}

That is all you need to do if you need to read an existing file and export its pages to images. Check out the SkiaImageFormatProvider documentation article if you are curious about other export settings. I hope you will enjoy the new functionality!

Try Out the New Feature & Share Your Feedback

Head over and download a free trial. If you are an active license holder, you can grab the latest bits from Your Telerik Account or update your NuGet package references to the latest ones directly in your .NET solutions.

Share your thoughts with us on our Feedback Portal and help us shape the future of Telerik Document Processing!

For a long time, we have supported creating files with the RadSpreadStreamProcessing library. This library is used particularly for large files. The key part is that it does not require all the data to be loaded in the application memory to create the document. This significantly reduces the memory usage of the application and allows for handling large amounts of data. This is achieved by directly writing the data in the file.

In the R3 2022 Release, we have added the ability for reading XLSX or CSV files with this library as well. This feature uses the same approach and reads the cells and properties consecutively (as they appear in the document structure). This way, only one cell is stored at a time in the application, which reduces the memory footprint.

Besides cell values, you can read the cell format and styles. You can read the Row/Column properties as well. Check out the Import section of the RadSpreadStreamProcessing online documentation.

An Example

In the example below, we will use both features (reading and writing). In this scenario, we will have a very large XLSX file, and we want to use only some of the data inside. We will get the data depending on some cell properties. As we are reading the data, we will simultaneously write it in a CSV file. The resulting file will contain only the filtered data.

using Telerik.Documents.SpreadsheetStreaming;
string source = @"..\..\..\source.xlsx";
string result = @"..\..\..\result.csv";

using (FileStream sourceFile = File.OpenRead(source))
{
    using (FileStream resultFile = File.OpenWrite(result))
    {
        using (IWorkbookImporter workBookImporter = SpreadImporter.CreateWorkbookImporter(SpreadDocumentFormat.Xlsx, sourceFile))
        {
            using (IWorkbookExporter workbookExporter = SpreadExporter.CreateWorkbookExporter(SpreadDocumentFormat.Csv, resultFile))
            {
                using (IWorksheetImporter worksheetImporter = workBookImporter.WorksheetImporters.First())
                {
                    using (IWorksheetExporter worksheetExporter = workbookExporter.CreateWorksheetExporter("My sheet"))
                    {
                        foreach (IRowImporter rowImporter in worksheetImporter.Rows)
                        {
                            // Skip the header rows  
                            List<string> values = new List<string>();

                            foreach (ICellImporter cellImporter in rowImporter.Cells)
                            {
                                if (cellImporter.RowIndex < 3)
                                {
                                    continue;
                                }

                                string value = cellImporter.Value;

                                if (cellImporter.ColumnIndex <= 6 && !string.IsNullOrEmpty(value))
                                {
                                    values.Add(value);
                                }

                                // Status column which is a color
                                else if (cellImporter.ColumnIndex == 7)
                                {
                                    var fill = cellImporter.Format.Fill as SpreadPatternFill;
                                    SpreadColor color = fill.BackgroundColor.LocalValue;

                                    // Export the rows with Green status only
                                    if (color.R == 142 && color.G == 188 && color.B == 0)
                                    {
                                        using (IRowExporter rowExporter = worksheetExporter.CreateRowExporter())
                                        {
                                            foreach (var item in values)
                                            {
                                                using (ICellExporter cellExporter = rowExporter.CreateCellExporter())
                                                {
                                                    cellExporter.SetValue(item);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

I hope this example is useful. Converting the opposite scenario (CSV to XLSX) is supported as well and can be easily achieved.

Try It and Share Your Feedback

No matter if you are already familiar with Telerik Document Processing or will meet the libraries for the first time, hurry up and get the latest bits so you can take advantage of the different document management possibilities they provide:

Download a Free Trial

And hopefully you know by now that your input is valuable—we do listen. So, do not be shy and drop us a line to share your feedback in the comments section below or directly in our Document Processing Libraries Feedback Portal.

As with every release, we are eager to share what the new updates are, so let’s jump right in! Hop to your favorite section:

• Telerik UI for WinUI
• Telerik UI for WPF
• Telerik UI for WinForms
• Telerik Document Processing Libraries
• Telerik UI for .NET MAUI
• Telerik UI for Xamarin
• Terlerik .NET Web, Desktop & Mobile Webinar & Twitch Sessions

What’s New in Telerik UI for WinUI 2.2.0

PropertyGrid

Announcing the RadPropertyGrid component for WinUI! The control provides an easy and versatile approach to processing data objects’ properties. Utilizing its auto-generation features and the intuitive custom editor capabilities, users will be able either to display data in a way that best fits their needs or modify it with minimal effort.

RadPropertyGrid can be bound to an item with just a single line of code, and you may start exploring or editing its properties. The proper editor controls are auto-generated—text fields for string properties, CheckBoxes for Boolean, DateTimePickers for dates, etc. In addition, PropertyGrid allows flexible manual setting and customization of editors and their layout via the standard WinUI styling and templating mechanisms. It is highly customizable, allowing the user to modify the default look in an easy and intuitive manner.

Check out the key features below:

• Automatic property generation – the control generates fields to read/write all public properties of the target object
• Built-in property editors – predefined editors UI for the different data types
• Nested properties support
• Customizable property fields – customize the property definitions and the corresponding data editors
• Keyboard support
• Grouping
• Filtering
• Data validation

For more information about the control, make sure to check out the PropertyGrid section in our online help documentation.

CollectionEditor & CollectionEditorPicker

RadCollectionEditor and RadCollectionEditorPicker are two small components used to visualize the items in a collection and generate editors for each property using the built-in PropertyGrid component. You can use the ItemTemplate of the control to specify how the items from the collection should appear. The difference between them is that the CollectionEditorPicker uses a dropdown to display the CollectionEditor.

For more details, check out the CollectionEditor section in our help documentation.

CollectionNavigator

RadCollectionNavigator is the next new control this release. A light component that provides seamless navigation and editing of a collection, it provides built-in customizable commands, predefined customizable buttons and more. For more details, make sure to check out the CollectionNavigator section from our online help documentation.

DataGrid: Export

Our DataGrid gets export support—thanks to the Telerik Document Processing Libraries that are included in the WinUI distribution. The new functionality provides methods to export the current dataset displayed in the control. You can export in a synchronous or an async manner, modify the exported data and the final document. Currently the built-in export supports the following formats:

• XLS
• XLSX
• PDF
• CSV

Hope this feature will be useful. For more details, check out the Export section from our DataGrid documentation.

RibbonView & Other: Updated Windows 11 Appearance

In this release, we did many improvements in the default styles of many controls to provide a better Windows 11 look and feel. Now I want to focus on the RibbonView control—we completely redesigned it to resemble the new Office 365 Experience! It looks totally awesome and I’m sure it will improve the overall appearance of your modern WinUI application.

Make sure to check out the controls in our refreshed WinUI examples application and play around with them.

Other Features

• SideDrawer: Added DrawerOpening and DrawerClosing
• SideDrawer: Introduced IsOpen property

Check Out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the release notes for the products below:

Telerik UI for WinUI (Release Notes)

Share Your Feedback

• Get in touch by email – drop us a line, for anything related to product or just to say hi at TelerikWinUI@progress.com
• Feedback Portal – share any feature request (or bug reports) that you might have
• Telerik Forums – if you need any technical assistance with the product, let us know and we will help

Get the Bits

Don’t wait—try out the latest:

Telerik UI for WinUI

In case you missed it, here are some of the updates from our previous release.

What’s New in Telerik UI for WPF With R3 2022

CircularProgressBar

Announcing our brand-new WPF CircularProgressBar component. CircularProgressBar is a control that will allow your customers to track the progress of different tasks in a circular manner. It provides many customization options that will allow you to achieve a lot of different scenarios. You have probably seen such components in many different places—from health tracking smartphone applications to automatic coffee machines. Now you can easily plug it in your Telerik WPF application as well!

Check out the list of the major features of the control below:

• Segments – CircularProgressBar can be split into numerous segments to indicate different types of progress.
• Color Ranges – CircularProgressBar supports defining ranges with different colors.
• Determinate and indeterminate states – The determinate state shows a specific amount of the progress. The indeterminate one plays an animation of the circular progress.
• Customizable content – CircularProgressBar supports complex implementation for the content of its progress.
• Radius manipulation – The control allows you to customize the indicator and track inner and outer radiuses.
• Angles – You can control the beginning and ending angles of the component for a more customized appearance.
• Secondary progress indicator – CircularProgressBar allows you to visualize an additional progress indicator.
• Indeterminate animation customization – You can modify the played animation when CircularProgressBar is in an indeterminate state.

I hope this control will be useful in various types of applications. For more information, check out our online CircularProgressBar help documentation.

PivotGrid: Configuring PivotGrid Without PivotFieldList

The most desired PivotGrid feature is finally here! It allows using the control without the additional PivotFieldList control. The new functionality provides support of all existing PivotFieldList features—directly accessible trough the UI of RadPivotGrid. Your customers will be able to filter, sort, modify the descriptions and more through the built-in dropdown menus, dialogs and buttons. The feature can be enabled by simply setting the attached FieldListBehavior.ShowInline property as shown below:

<pivot:RadPivotGrid  x:Name="pivotGrid"  pivot:FieldListBehavior.ShowInline="True"  />  

For more details, make sure to check out the Inline PivotFieldList section from our online help documentation.

SyntaxEditor: Word Wrapping

A new cool feature for the SyntaxEditor is Word Wrapping! When the feature is enabled, the horizontal scroll bar is removed and all the text is horizontally fit in the available space. We have also included an additional margin that holds the icons and can be removed if needed. I’m sure you have seen this view mode in many editors and IDEs, so I hope it will make your WPF applications more useful and user friendly.

For more info, check out the Word Wrap article from the SyntaxEditor help documentation.

ChartView: ErrorBar Series

We are adding a new ChartView series this release—ErrorBar Series! This type of series visualizes its data points using error bar shapes. The error bar shape allows you to display an error or uncertainty in the plotted data. The shape consists of a single line with caps at the two ends. An additional marker that shows the expected measure can be displayed too.

For more information about all of the setup and customization options of the new series, please check out the ErrorBar Series article from the ChartView help documentation.

Latest .NET 7 Preview Support

As always, we are up to date with the latest technology trends, and we are happy to announce that Telerik UI for WPF provides support for the latest .NET 7 Preview 7. The .NET 7 Preview binaries can be found in a separate zip archive in your account—download it and give it a try! They will be included in the NuGet packages and in full distribution once .NET 7 becomes official. Also we plan to remove the .NET 5 support with the .NET 7 introduction, so please consider upgrading your .NET 5 applications to newer .NET. (If such a change somehow affects your plans, please contact us and share more details.)

RibbonView: New Windows11 Theme Appearance

We improved the default RibbonView styling for the Windows 11 theme in order to resemble the new Office 365 Experience. Looks nice, doesn’t it?

If you want to see the theme in action, make sure to play around with our Color Theme Generator for WPF app! For more details about all the features of the Windows 11 theme, please check out this help article.

RichTextBox: Line Numbering

The latest RichTextBox feature enables you to display the appropriate number beside each line of text—this is useful for specific types of content, such as scripts, legal or medical documents. Through the intuitive API of this feature, you will be able to easily control how the numbering appears. You can change the initial number, the increment number, the distance between the numbering and the document content, and when the numbering should restart. For more information, check out the Line Numbering help article.

Spreadsheet: Repeat Specific Rows or Columns on Every Printed Page

This new Spreadsheet functionality allows you to specify a row or a column that will be repeated on every printed page. This functionality is useful when you need to print or export to PDF data spanning multiple pages and still allows the users to see the important information on the top/left side for better orientation. For more details, check out the Printing section of our Spreadsheet documentation.

Other Features

• SyntaxEditor: FontWeight and FontStyle of the highlighted words
• VirtualGrid: FontWeight and FontStyle of the cells
• RibbonWindow: Windows 11 Theme acrylic effect now can be enabled on all Windows 11 version, not only on the preview ones

Check Out the Detailed Release Notes

We have a lot more! To get an overview of all the latest features and improvements we’ve made, check out the release notes for the products below:

Telerik UI for WPF (Release Notes)
Telerik UI for Silverlight (Release Notes)

Share Your Feedback

Feel free to drop us a comment below sharing your thoughts. Or visit our Feedback Portals about UI for WPF, Silverlight and Document Processing Libraries and let us know if you have any suggestions or if you need any particular features/controls.

Try out the latest:

Telerik UI for WPF Telerik UI for Silverlight

In case you missed it, here are some of the updates from our last major release and previous Service Pack.

What’s New in Telerik UI for WinForms With R3 2022

Spreadsheet Charts

Hold up? Is that true? Yes, you read it right. Charts are coming to RadSpreadsheet control for Telerik WinForms. What could be a better improvement than visualizing your data beyond the RadSpreadsheet grid? Adding charts to a workbook can help you identify important statistics and trends in your data that may not be obvious when only looking at numbers. With RadSpreadsheet you can show charts as well as add, remove and manipulate chart objects in your spreadsheet documents.

Supported Chart Types

Different chart types give you the flexibility that your data requires. From Bar to Line, from Point to Bubble, from Pie to Area, show your users that you care. The Spreadsheet component for WinForms supports more than a dozen different types of charts allowing you to visualize categorical data, numerical data, time series data and more. You can get familiar with all supported types in the RadSpreadsheet Charts help article.

Splash Screen

What could be better to notify the end user that something big is loading than showing a splash screen form? Our newest reinforcement to the Telerik UI for the WinForms suite is here. Splash Screen allows you to display a Telerik themed control that notifies the user that the program is loading. You can customize the image of the splash screen, its animations and loading process visualization per your requirement.

Overlay and Flyout Screens

If you want something more to sample, just to say “give me a second to set up the data,” we have just the things for you. Overlay and Flyout Screens will fit perfectly in a case where you want to dim the content and show the end users to be patient. You could use the Overlay Screen to show only the loading indicator. However, there could be a case where you want to notify the user that he needs to reenter his credentials to continue working on the application. In this case, Flyout Screen is what you need. The Flyout can be used to display some content over the application or be used as an interactive control. The screen can be customized in a way that you can place input controls in it, while the Overlay does not accept such customization.

Overlay

Flyout

Changes to Distribution

As of R3 2022 in Telerik UI for WinForms, the .NET 2.0 distribution is removed. From this release, the suite offers .NET 4.8 distribution. With this release, you not only get the .NET Framework projects of the Telerik source code, but .NET Core projects as well.

Bug Fixes & Improvements

Our development team managed to fix/improve more than ONE HUNDRED bugs reported by our customers. We always listen to feedback and try to produce the top-notch controls on the market.

Share your feedback with us in the Feedback Portal!

Get the Bits

Don’t wait—try out the latest:

Telerik UI for WinForms

What’s New in Telerik Document Processing Libraries With R3 2022

PdfProcessing

Export PDF pages to images: We have added the ability to convert the pages of a PDF document to images. This feature uses the SkiaSharp library. It will work with the .NET Standard version and does not depend on any Windows libraries.

WordsProcessing

Page Numbering Fields: PAGE, PAGEREF, NUMPAGES, SECTIONPAGES and SECTION fields are now supported in our library. These are commonly used fields for inserting page numbering. We have added the ability to update the field values as well.

Shapes support: With this release, we have enabled users to preserve the shapes when importing and exporting a DOCX document. We will continue working on extending the functionality to allow you to insert and manipulate these objects in the next releases.

SpreadStreamProcessing

SpreadStreamProcessing Import: We have added support for reading XLSX and CSV files. This functionality allows you to easily get the data from large files without loading the entire document in the memory. It has great performance as well.

SpreadProcessing

Repeat specific rows or columns on every printed page: This feature allows you to specify a row or a column that will be repeated on every printed page.

What’s New in Telerik UI for .NET MAUI With R3 2022

Aloha, and welcome to another Telerik UI for .NET MAUI release! In addition to the mandatory support for the latest version of .NET MAUI, we are now shipping three brand-new controls as part of our growing Telerik UI for .NET MAUI suite—DataForm, AutoComplete and Expander components! We’ve also added many enhancements to our powerful DataGrid control. Let’s have a sneak peek at the most interesting stuff we have for you in this release.

Latest .NET MAUI & Visual Studio 2022 Support

We follow the Microsoft release cadence closely and have consistently offered early support for all new .NET MAUI versions—including Day-Zero support when the framework was released in General Availability. Since then, cross-platform developers have been able to use Telerik UI for .NET MAUI, the most comprehensive cross-platform development UI library on the market, together with the latest .NET MAUI features and fixes: an unbeatable combination.

Moreover, with .NET MAUI tooling getting formal support in Visual Studio 2022 17.3, Telerik UI for .NET MAUI is now also tightly integrated with the latest VS version. Developers can also take advantage of dedicated Visual Studio Extensions with .NET MAUI templates for project creation and a UI Toolbox.

.NET MAUI DataForm

I’d like to introduce you to the new DataForm control in Telerik UI for .NET MAUI. This powerful control helps you to automatically create a form for collecting or editing data. For example, using the RadDataForm, you can easily create form-over-data UI for both mobile and desktop, like these:

Desktop:

Mobile:

The component supports different commit modes, allowing you to commit property values one by one or to commit the whole form at once. It’s also very easy to add validation to your forms and group UI elements to make large forms more manageable.

With the DataForm control, you can not only build the needed UI by using the rich set of editors that are provided out of the box, but you can easily customize those forms through the flexible styling API.

Here are some of the key features you get in the new DataForm:

• Built-in editors: The DataForm provides a set of built-in editors for the available primitive types such as numeric, string, boolean, enumerations, DateTime and TimeSpan. The control detects the types of the data object’s properties and automatically displays the appropriate editor.
• Validation support: You can use the built-in validation support that gives you full control over the data collected through the control.
• Commit modes: DataForm provides editing support with three types of commit modes to determine when the edited value should be synchronized with the business object.
• Grouping support: This allows you to easily group the form’s editors.
• Data Annotations support: You can decorate the data models using Data Annotations attributes which specify validation conditions to be applied to a specific field in the DataForm. You can use different annotations like Requires, DataType, Display, RegularExpression and more.
• Different layouts: You can arrange the editors and the groups by using different layouts such as stack, grid and more.
• Commands support: You can execute your validation logic or commit/cancel all pending changes in the form by using the built-in commands for these actions.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI DataForm control.

AutoComplete Joins the Family

The AutoComplete component is a popular control for various mobile and desktop applications and use cases. Especially useful when you have to display a long, predefined list to choose from, such as a list of airports or a list of known recipients. Your app users expect this in modern apps, and now you can deliver it out of the box.

Some of the main features of the .NET MAUI AutoComplete are:

• Tokens support: You can enable the users of your application to search for and select several items from the source of the AutoComplete. These items appear as tokens that can easily be deselected using their close button.
• Filtering options: You can define the filtering behavior to display all the matches that either “StartsWith” or “Contains” the typed symbols.
• Different suggest modes support: RadAutoComplete exposes three different modes (Suggest, Append, SuggestAppend) for providing suggestions.
• Placeholder: This is used to give guidance to the end user on what should be entered in the text input.
• NoResults message: NoResults message appears in the popup used for the list of suggestions whenever the control cannot find any matching items. Read more about this here.
• Visualized text formatting: You can modify the displayed details of the selected item by using DisplayTextFormatter property of AutoComplete.
• Custom templates: If any of the default templates do not fit a particular scenario, you can easily define a custom template.
• Highlight customization: This gives you the ability to highlight the text inside the custom template.
• Nested properties support: This allows binding of a complex object to the RadAutoComplete’s TextSearchPath property.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI AutoComplete control.

.NET MAUI Expander

RadExpander is a flexible control that helps you save space and achieve easier navigation through your app. You can place the Expander anywhere on your page and embed any content inside the dropdown area. The Expander control also gives you control over its ExpandDirection to let you adjust the control as per your custom layout.

Here are some of the features the Expander control ships with:

• Collapsed and Expanded States: The control hosts the content in an expandable container that can be easily expanded/collapsed by tapping on its header.
• Animation: The RadExpander control provides a property that allows you to enable or disable the animation when the content is collapsed/expanded. If you want to enable/disable the animation, you need to use the IsAnimationEnabled property.
• Customization Options: The rich API for customization of the Expander component allows you to customize the visual appearance of the control in a variety of ways. You can manipulate the Animation’s duration and easing, the header of the control and its border styles.

Visit our product documentation for more information on getting started with the Telerik UI for .NET MAUI Expander control.

DataGrid Just Got a New Grouping UI

With our latest release, our powerful DataGrid component has evolved. The new enchantment is the so-called Grouping UI.

This area is called the DataGridServicePanel and allows the user to drag and drop column headers into the panel in order to group the data in the RadDataGrid at runtime.

The user is not limited to group just a single column—they are allowed to drag several columns into the panel, or rearrange the grouping. Grouping in this manner gives the user power to control how they want to view the data and reduces the coding part for the developer.

If you want to restrict the user from grouping the data or limit the grouping to certain columns, you can do it by using DataGrid’s intuitive API for that.

More information about this feature can be found in DataGrid’s product documentation.

DataGrid Footers

Column Footers
The new addition to the DataGrid control—the Column Footers functionality—allows you to display additional information which applies to the columns in a specific row placed at the bottom of the control. This row consists of individual footer cells for each column. It is of type object, so you are not limited to just using plain text in it.

By default, column footers are hidden, so if you want to make them visible you have to set the DataGrid’s ShowColumnFooters property to True.

More information about this feature can be found in DataGrid’s product documentation.

Group Footers
DataGrid exposes the Group Footers feature, which provides the option to render a footer under each group in the data grid component. Group footers contain footer cells that correspond to data columns and can display group summaries.

This footer row is also hidden by default. If you want to take advantage of this feature, you will have to enable it by setting the ShowGroupFooters property of the DataGrid to True.

More information about this feature can be found in DataGrid’s product documentation.

DataGrid Aggregate Functions

There are situations when displaying numbers in the DataGrid in which users would like to be able to see the results from aggregate calculations at the bottom of the DataGrid’s groups or columns. Now, this can be easily achieved with the new addition to the DataGrid control—aggregate functions support. It allows you to display aggregated information for the data in the column’s footer, in the group’s header or in the group’s footer.

DataGrid offers built-in support for the most popular aggregate functions: Average, Count, Sum, Min, Max and Count. All you need to do is to add a PropertyAggregateDescriptors into DataGrid’s AggregateDescriptors with the needed function:

<telerikGrid:RadDataGrid>
  <telerikGrid:RadDataGrid.AggregateDescriptors>
    <telerikCore:PropertyAggregateDescriptor  PropertyName="Points" Function=
                                            "Average"/>
                                                </telerikGrid:RadDataGrid.AggregateDescriptors>
                                                </telerikGrid:RadDataGrid>
                                                
                                                        

If you have a more complex scenario, you are also covered—there is an option for creating a custom aggregate function by using a DelegateAggregateDescriptor.

More information about this feature can be found in DataGrid’s product documentation.

Sign Up for a Trial

If you’re interested in starting to play with .NET MAUI, or if you’re already actively working with .NET MAUI to develop applications, I encourage you to check out Telerik UI for .NET MAUI.

To get the bits, you just need to sign up for our free 30-day trial, which gives you access to the components as well as our legendary technical support. Head to the Telerik UI for .NET MAUI overview page or click the button below and sign up for a trial today!

Try Telerik UI For .NET MAUI

Share Your Feedback

Please share your feedback, ideas and suggestions, either by commenting below or by visiting our Feedback Portal about Telerik UI for .NET MAUI. Let us know if you have any suggestions and submit your features/controls requests.

What’s New in Telerik UI for Xamarin With R3 2022

Xamarin DataGrid Aggregates

With the new aggregate functions in the Xamarin DataGrid, you can display aggregated information for the data in the group’s header, or in the group/column’s footer.

The new feature comes with built-in support for the most popular aggregate functions: Average, Count, Sum, Min, Max and Count. You can easily set up the aggregates by adding PropertyAggregateDescriptors into DataGrid’s AggregateDescriptors with the desired function:

<telerikGrid:RadDataGrid>
  <telerikGrid:RadDataGrid.AggregateDescriptors>
    <telerikCore:PropertyAggregateDescriptor  PropertyName="Points"  Function="Average"/>
  </telerikGrid:RadDataGrid.AggregateDescriptors>
</telerikGrid:RadDataGrid>

The aggregates also support multiple types of complex scenarios through the extensibility point for defining a custom descriptor—DelegateAggregateDescriptor.

Visit our product documentation for more information on the Telerik UI for Xamarin Data Grid control and Aggregates.

Xamarin DataGrid Column Footers

The new addition to the DataGrid control—the Column Footers functionality—allows you to display additional information which applies to the columns in a specific row placed at the bottom of the control. This row consists of individual footer cells for each column. It is of type object, so you are not limited to just using plain text in it.

By default, column footers are hidden, so if you want to make them visible, you have to set the DataGrid’s ShowColumnFooters property to True.

Visit our product documentation for more information on the Telerik UI for Xamarin Data Grid control and Column Footers.

Xamarin DataGrid Group Footers

With the current release, you have the ability to render a footer under each group inside the DataGrid component. The footer cells correspond to data columns and you can use them to display group summaries.

All you need to do to use this functionality is set the DataGrid.ShowGroupFooters property to true.

Visit our product documentation for more information on getting started with the Telerik UI for Xamarin Data Grid control.

New IsLooping Property Now Available for All Xamarin Date and Time Pickers

With the latest release of Telerik UI for Xamarin, you can easily stop the looping functionality in the Date, Time, DateTime, Time and TimeSpan Pickers using just a single property—IsLooping. When IsLooping is True, which is by default, the items of each spinner can loop infinitely unless that spinner is restricted to show only a subset of the available values.

Picker with disabled looping                         Picker with enabled looping
    

Visit our product documentation for more information on the Telerik UI for Xamarin DatePicker control IsLooping property.

Get the Latest & Let Us Know Your Feedback

Please share your feedback, ideas and suggestions, either by commenting below or by visiting our Feedback Portal about Telerik UI for Xamarin.

Don’t hesitate to check out the latest:

Try Telerik UI For Xamarin

Telerik .NET Web, Desktop & Mobile Products Webinar & Twitch Session

Wednesday, September 21, 2022 | 11:00 a.m. – 1:00 p.m. ET
Discover all updates across Telerik UI for Blazor, UI for ASP.NET Core, UI for ASP.NET MVC, UI for ASP.NET AJAX, UI for WPF, UI for WinForms, UI for WinUI, UI for Xamarin and UI for .NET MAUI.

Save Your Seat

Join Us on Twitch Today

Live from Devreach’22 @ Progress360: Join the live community session from the Progress360 Streaming Studio on September 14 from 10 a.m. – 11:30 a.m. ET to hear the release highlights and celebrate the DevReach spirit with us at our Livestream Release Party.

And the Best Part About the Release Webinars?

The live webinars and Twitch sessions are a great opportunity for you to ask questions before and during the webinars. We’ll be waiting to hear from you on Twitter—just use the #heyTelerik and #heyKendoUI hashtags.

Another great option is the live chat during our release session on CodeItLive, our Twitch channel.