diff --git a/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-large-pdf.md b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-large-pdf.md
new file mode 100644
index 000000000..e5b9c41f3
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-large-pdf.md
@@ -0,0 +1,188 @@
+---
+layout: post
+title: Document Handling in ASP.NET Core Pdfviewer component | Syncfusion
+description: This page helps you to learn about how to Open PDF from URL, Base64, Blob, Stream, Cloud storage in Syncfusion ASP.NET Core Pdfviewer component.
+control: PDF Viewer
+platform: document-processing
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# Load Large PDF Files in ASP.NET Core PDF Viewer
+
+This article explains how to efficiently load and view large PDF files using the Syncfusion ASP.NET Core PDF Viewer. It includes recommended best practices and performance tips for documents ranging from **50 MB to 2 GB**.
+
+## Why Large PDFs Need Special Handling
+
+Large PDF files often contain thousands of embedded objects such as images, compressed streams, digital signatures, form fields, annotations, vector graphics, and complex page structures. Rendering such heavy documents requires more processing time and memory.
+
+The **Syncfusion ASP.NET Core PDF Viewer is fully optimized for these heavy workloads**, and it delivers excellent performance even when working with very large files.
+
+### Viewer Capability Highlights
+- **Smooth performance for PDFs up to 1 GB**
+- **Supports viewing files up to ~2 GB**
+- **1 GB PDFs typically load within 5–6 seconds**
+- **Optimized incremental page loading** for faster interaction
+
+Performance may vary if the user’s system is heavily loaded or low on available RAM. In such cases, enabling the recommended optimizations below ensures maximum performance.
+
+## Best Practices for Loading Large PDFs
+
+### 1. Load PDFs Using Blob (Recommended)
+
+Blob loading provides the fastest and most efficient performance for large PDFs.
+
+#### Why Blob Loading Is Better
+
+When a large PDF (for example, 1 GB) is loaded directly via `documentPath` (URL):
+
+- The browser must **download the full document first**
+- Only after the full download completes, the viewer starts parsing and rendering
+- This causes delay for large files
+
+But when the PDF is fetched as a **Blob**:
+
+- The file is downloaded first in an optimized stream
+- A Blob URL is created and passed to the viewer
+- The viewer can begin rendering faster
+- Improves load time, memory usage, and overall responsiveness
+
+#### Example: Load a PDF as Blob
+```js
+fetch('https://your-api/large-file.pdf')
+ .then(response => response.blob())
+ .then(blob => {
+ const blobUrl = URL.createObjectURL(blob);
+ viewer.load(blobUrl, null);
+ })
+ .catch(error => console.error('Error loading PDF:', error));
+```
+
+Blob loading is highly recommended for all PDFs above **200 MB**, especially when working with 500 MB – 1 GB files.
+
+### 2. Viewer Performance Range
+
+The Syncfusion PDF Viewer is optimized to handle:
+
+- **Up to 1 GB** → very smooth
+- **Up to ~2 GB**
+
+This suits enterprise workflows involving large engineering drawings, client records, scanned books, and multi‑page financial reports.
+
+### 3. Minimize Injected Modules
+
+The PDF Viewer internally uses background workers for text processing, thumbnail generation, image rendering, and metadata extraction. Disabling modules that are not needed helps reduce background activity and improves performance.
+
+#### 3.1 Text Search & Text Selection
+
+Modules:
+- [`Text Search`](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/asp-net-core/text-search)
+- [`Text Selection`](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/asp-net-core/textselection)
+
+These features require **continuous background text extraction and indexing**.
+
+For large PDFs:
+
+- Text extraction runs longer
+- Consumes additional CPU and memory
+- Increases initial load time
+
+If these features are not required in your application:
+
+- Disable them to reduce background tasks
+- Improve page rendering speed
+- Provide a smoother experience for large documents
+
+#### 3.2 Thumbnail View & Organize Pages
+
+Modules:
+- [`Organize Pages`](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/asp-net-core/organize-pdf)
+- [`Thumbnail View`](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/asp-net-core/interactive-pdf-navigation/page-thumbnail)
+
+These rely on **background thumbnail rendering**, where the viewer renders small preview images of every page.
+For PDFs with hundreds or thousands of pages, this becomes heavy.
+
+If thumbnails or page reordering are not essential:
+
+- Disable these modules
+- Prevent background thumbnail rendering
+- Reduce memory usage
+- Improve navigation responsiveness
+
+#### Example (remove unnecessary modules)
+```js
+
+```
+
+{% tabs %}
+{% highlight cshtml tabtitle="Standalone" %}
+
+
+
+
+{% endhighlight %}
+{% endtabs %}
+
+### 4. Enable Local Storage for Large PDFs With Many Form Fields or Annotations
+
+PDFs with a high number of:
+
+- Form fields (textbox, dropdown, signatures, etc.)
+- Annotations (highlight, shapes, comments)
+
+require more storage for:
+
+- Field values
+- Annotation metadata
+- Interaction states
+- Undo/redo data
+
+Enabling local storage in the PDF Viewer can improve performance and smoothness when working with large files. This allows the viewer to cache document data locally, reducing repeated network requests and memory spikes.
+
+Use the [`enableLocalStorage`](https://ej2.syncfusion.com/asp-net-core/documentation/api/pdfviewer/index-default#enablelocalstorage) property to control this behavior. When set to `true`, session data is stored in memory for the current session; when `false` (default), browser session storage is used.
+
+**How the viewer stores this data by default**
+
+By default, the viewer uses **sessionStorage** to store interactive session data. For heavy PDFs with many form fields/annotations, sessionStorage can get filled more quickly and may cause slower interactions or instability when navigating across many pages.
+
+**Why enabling localStorage helps**
+
+- Provides more storage capacity than session storage
+- Avoids storage overflow for annotation‑heavy PDFs
+- Improves saving/loading of form values
+- Enhances stability when navigating large documents
+- Reduces repeated processing for form/annotation‑heavy pages
+
+#### Enable Local Storage
+{% tabs %}
+{% highlight cshtml tabtitle="Standalone" %}
+
+
+
+
+{% endhighlight %}
+{% endtabs %}
+
+This is highly recommended when working with legal documents, tax forms, interactive applications, or PDFs containing thousands of annotations.
+
+### 5. Reduce Unnecessary Background System Processes
+
+For the best large‑PDF experience:
+
+- Close unused applications
+- Avoid multiple heavy tasks running in parallel
+- Minimize other browser tabs
+- Avoid opening multiple large PDFs simultaneously
+
+This ensures the viewer receives enough system resources.
+
+## See Also
+
+- [Load PDF (GitHub Sample)](https://github.com/SyncfusionExamples/asp-core-pdf-viewer-examples/tree/master)
\ No newline at end of file
diff --git a/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-password-pdf.md b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-password-pdf.md
new file mode 100644
index 000000000..17165c29c
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-password-pdf.md
@@ -0,0 +1,82 @@
+---
+layout: post
+title: Load Password Protected PDFs in ASP.NET Core PDF Viewer | Syncfusion
+description: Learn how to open password-protected PDF files in the Syncfusion ASP.NET Core PDF Viewer by providing the password in the documentPath object.
+control: PDF Viewer
+platform: document-processing
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# Load a Password-Protected PDF
+
+This article explains how to open password-protected PDF files in the Syncfusion ASP.NET Core PDF Viewer. The viewer supports both user‑interactive loading (Open File dialog) and programmatic loading using APIs.
+
+## 1. Opening a Password-Protected PDF Using the **Open File** Dialog
+
+When the user selects a password-protected PDF using the built‑in **Open File** option:
+
+- The viewer detects that the document is encrypted
+
+
+
+- A **password input popup** is automatically displayed
+
+
+
+- The user enters the password
+
+- The document is decrypted and loaded
+
+No additional configuration or code is required.
+
+This approach works for all password-protected PDFs opened locally by the user.
+
+## 2. Opening a Password-Protected PDF Programmatically
+
+If you load a password-protected PDF from a URL or through custom logic, the viewer provides two behaviors depending on how the file is loaded.
+
+### 2.1 Load the Document Using `viewer.load(url, password)`
+
+You can directly pass the password in the [`load`](https://ej2.syncfusion.com/aspnetcore/documentation/api/pdfviewer/index-default#load) method:
+
+```js
+viewer.load(
+ 'https://your-api/password-protected.pdf',
+ 'Password'
+);
+```
+
+- If the password is correct → the PDF loads immediately
+- If the password is incorrect → the viewer displays the incorrect password popup
+- If no password is provided → the password popup is shown automatically
+
+This is useful when the password is known beforehand.
+
+### 2.2 Loading a Password-Protected Document's URL Using `documentPath`
+
+If the [`documentPath`](https://ej2.syncfusion.com/aspnetcore/documentation/api/pdfviewer/index-default#documentpath) points to a password-protected PDF:
+
+{% tabs %}
+{% highlight cshtml tabtitle="Standalone" %}
+
+
+
+
+{% endhighlight %}
+{% endtabs %}
+
+The viewer will:
+
+- Detect encryption
+- Show the **password popup automatically**
+- Allow the user to enter the correct password
+- Then load the PDF
+
+
+
+N> No password should be passed inside `documentPath`.
\ No newline at end of file
diff --git a/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/preprocess-pdf.md b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/preprocess-pdf.md
new file mode 100644
index 000000000..619de0e46
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/preprocess-pdf.md
@@ -0,0 +1,233 @@
+---
+layout: post
+title: Preprocess PDF Document in ASP.NET Core PDF Viewer | Syncfusion
+description: Learn how to preprocess PDF documents using Syncfusion PDF Library before displaying them in the ASP.NET Core PDF Viewer.
+control: PDF Viewer
+platform: document-processing
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# Pre-process PDF Document Before Displaying in ASP.NET Core PDF Viewer
+
+This section explains why preprocessing is useful, what operations you can perform using the Syncfusion PDF Library, and how to load the processed document in the ASP.NET Core PDF Viewer.
+
+## Why Preprocessing Is Needed
+Preprocessing a PDF before sending it to the viewer helps you:
+- Reduce file size and improve load time
+- Merge multiple documents into one
+- Extract only required pages for faster loading
+- Flatten form fields and annotations for performance & security
+- Apply branding elements such as watermarks or stamps
+
+These enhancements ensure a better, faster, and more controlled viewing experience.
+
+## Merge PDF Documents
+### UI-Level Merging
+You can visually merge pages in the **Organize Pages** UI inside the PDF Viewer. Users can import another PDF, insert its pages into the current file, reorder pages, or delete unwanted pages.
+
+
+
+### Programmatically Merge PDFs
+Using the Syncfusion PDF Library, you can merge documents before loading them into the viewer.
+```js
+import { PdfDocument } from '@syncfusion/ej2-pdf';
+
+const document1 = await PdfDocument.load('file1.pdf');
+const document2 = await PdfDocument.load('file2.pdf');
+
+document1.merge(document2);
+const mergedBytes = await document1.save();
+```
+You can then load the merged PDF into the viewer using Blob or Base64.
+
+## Extract Pages
+### UI-Level Extraction
+Using the Viewer’s [**Organize Pages**](../organize-pages/overview) window, users can select and extract required pages and download them separately.
+
+
+
+### Programmatically Extract Pages
+```js
+import { PdfDocument } from '@syncfusion/ej2-pdf';
+
+const original = await PdfDocument.load('sample.pdf');
+const extracted = original.extractPages([2,3,4]);
+const resultBytes = await extracted.save();
+```
+This reduces file size and improves performance when loading large documents.
+
+## Flatten Form Fields & Annotations
+### Why Flattening Helps
+- Prevents users from editing form fields
+- Improves rendering speed
+- Ensures consistent appearance across all devices
+
+### Programmatic Flattening
+```js
+import { PdfDocument } from '@syncfusion/ej2-pdf';
+
+const doc = await PdfDocument.load('form.pdf');
+doc.formFields.flattenAllFields();
+doc.annotations.flattenAllAnnotations();
+const bytes = await doc.save();
+```
+
+### Flatten on Load
+
+Use the following ASP.NET Core `cshtml` snippet when you want uploaded PDFs to be flattened before they are loaded into the viewer.
+
+{% tabs %}
+{% highlight cshtml tabtitle="Standalone" %}
+
+
+
+
+
+
+
+
+
+{% endhighlight %}
+{% endtabs %}
+
+```csharp
+ [HttpPost]
+ public IActionResult Flatten(IFormFile file)
+ {
+ if (file == null)
+ return BadRequest();
+ using MemoryStream inputStream = new MemoryStream();
+ file.CopyTo(inputStream);
+ inputStream.Position = 0;
+ // ✅ Load PDF
+ PdfLoadedDocument document = new PdfLoadedDocument(inputStream);
+ // ✅ Flatten form fields
+ if (document.Form != null)
+ {
+ document.Form.Flatten = true;
+ }
+ // ✅ Flatten annotations
+ document.FlattenAnnotations();
+ // ✅ Save flattened PDF
+ using MemoryStream outputStream = new MemoryStream();
+ document.Save(outputStream);
+ document.Close(true);
+ outputStream.Position = 0;
+ return File(outputStream.ToArray(), "application/pdf");
+ }
+```
+N> Refer to the [Flatten on Download](../annotation/flatten-annotation#how-to-flatten-annotations) section for more information about flattening documents on download.
+
+## Add Watermark or Stamp
+### UI-Level Stamps
+The PDF Viewer toolbar allows users to:
+- Add [standard stamps](../annotation/stamp-annotation#add-stamp-annotations-to-the-pdf-document) (Approved, Draft, etc.)
+- Insert [custom image stamps](../annotation/stamp-annotation#add-a-custom-stamp)
+
+
+
+### Programmatically Add a Watermark
+```js
+import { PdfDocument, PdfGraphics, PdfBrushes } from '@syncfusion/ej2-pdf';
+
+const doc = await PdfDocument.load('input.pdf');
+const page = doc.getPage(0);
+const g = page.graphics;
+
+g.drawString('CONFIDENTIAL', {
+ x: 150,
+ y: 300,
+ fontSize: 48,
+ brush: PdfBrushes.gray,
+ opacity: 0.3,
+ rotateAngle: 45
+});
+
+const outputBytes = await doc.save();
+```
+
+## How-To Guide: Load the Preprocessed PDF in the Viewer
+You can load the processed PDF using **Blob**, **Base64**, or a **URL**.
+
+### Load Using Blob (Recommended)
+```js
+fetch('/api/processed-pdf')
+ .then(res => res.blob())
+ .then(blob => {
+ const url = URL.createObjectURL(blob);
+ viewer.load(url);
+ });
+```
+Best for large or dynamically processed PDFs.
+
+### Load Using Base64
+```js
+viewer.load('data:application/pdf;base64,BASE64_STRING');
+```
+Use for small files.
+
+### Load Using URL
+```js
+viewer.load('https://yourdomain.com/files/doc.pdf');
+```
+Ideal for stored/static files.
diff --git a/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/retrieve-loadedDoc.md b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/retrieve-loadedDoc.md
new file mode 100644
index 000000000..94de04a1d
--- /dev/null
+++ b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/retrieve-loadedDoc.md
@@ -0,0 +1,207 @@
+---
+layout: post
+title: Retrieve the Loaded Document in ASP.NET Core PDF Viewer | syncfusion
+description: Learn how to access the loaded PDF document instance in the ASP.NET Core PDF Viewer using refs and the documentLoad event.
+platform: document-processing
+documentation: ug
+domainurl: ##DomainURL##
+---
+
+# Retrieve the Loaded Document Instance in ASP.NET Core PDF Viewer
+
+This page explains how to access the ASP.NET Core PDF Viewer instance using an ASP.NET Core ref, listen for the [`documentLoad`](https://help.syncfusion.com/cr/aspnetcore-js2/syncfusion.ej2.pdfviewer.pdfviewer.html#Syncfusion_EJ2_PdfViewer_PdfViewer_DocumentLoad) life-cycle event, and retrieve document information, page details, and metadata—so you can safely invoke viewer APIs after the PDF is loaded.
+
+## Explanation: Why access the loaded document instance?
+
+- The viewer instance (via **ASP.NET Core ref**) gives you a stable handle to call APIs such as [`zoom`](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/asp-net-core/magnification), [`print`](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/asp-net-core/print), [`download`](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/asp-net-core/download), and [`navigation`](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/asp-net-core/navigation).
+- The **document load event** (fires after the PDF is parsed and pages are ready) is the correct moment to read **document information** (title, author, page count, etc.) and **page metrics**, and to trigger post‑load UI logic.
+- Accessing the instance too early (before load completes) may cause null/undefined errors or incomplete information.
+
+## Reference: What you can access/call after load
+
+After the PDF is loaded you can:
+
+- **Read document information**: title, author, subject, keywords (metadata), page count.
+- **Read page details**: total pages, current page, page size(s).
+- **Call Viewer APIs** (typical examples):
+ - **Zoom / Fit**: `zoomTo(125)`; fit to page/width
+ - **Navigation**: go to a specific page
+ - **Interactions**: enable/disable features (based on injected services)
+ - **Export**: `download()`, `print()`
+
+> Always invoke these after the `documentLoad` event fires, or from user actions that occur after load. Guard calls with optional chaining or readiness flags.
+
+## How‑to: Get the instance with a ref and read details on load
+
+Below is a focused snippet showing:
+1) Creating a **ref** for the viewer,
+2) Wiring the **`documentLoad`** event, and
+3) Reading basic **document info** and **page count**, then calling **viewer APIs** safely.
+
+{% tabs %}
+{% highlight cshtml tabtitle="Standalone" %}
+
+
+
+
+
+
+
+
+{% endhighlight %}
+{% endtabs %}
+
+**Notes**
+- The event name is `documentLoad` (the callback receives load args).
+- The exact event args and public methods available on the component may vary with the package version and injected services. Use `console.log(args)` once to see what’s present in your build.
+- Always guard calls with optional chaining (e.g., `viewer?.magnification?.zoomTo(125)`).
+
+## Tutorial: End‑to‑End — Read metadata & call APIs after load
+
+This example demonstrates a complete flow:
+- Setting up a **viewer ref**
+- Subscribing to `documentLoad`
+- Extracting **metadata** and **pages**
+- Exposing **buttons** to call viewer APIs only after load
+
+{% tabs %}
+{% highlight cshtml tabtitle="Standalone" %}
+
+
+ Status:
+ Loading…
+
+
File:
+
Pages:
+
Author:
+
Title:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{% endhighlight %}
+{% endtabs %}
+
+## See also
+- ASP.NET Core PDF Viewer – [API Reference](https://help.syncfusion.com/cr/aspnetcore-js2/syncfusion.ej2.pdfviewer.pdfviewer.html) ([methods](https://ej2.syncfusion.com/javascript/documentation/api/pdfviewer/index-default#methods), [events](https://ej2.syncfusion.com/javascript/documentation/api/pdfviewer/index-default#events), [properties](https://help.syncfusion.com/cr/aspnetcore-js2/syncfusion.ej2.pdfviewer.pdfviewer.html#properties))
+- Events: [`documentLoad`](https://help.syncfusion.com/cr/aspnetcore-js2/syncfusion.ej2.pdfviewer.pdfviewer.html#Syncfusion_EJ2_PdfViewer_PdfViewer_DocumentLoad) and related argument shape (check your package version)
+- [Modules and Services](https://help.syncfusion.com/document-processing/pdf/pdf-viewer/asp-net-core/feature-module) (e.g., Magnification, Navigation, Print) — ensure the features you call are injected
From 4ac64ad517fb64e3622bf3d23642e265754b60df Mon Sep 17 00:00:00 2001
From: Priyadharshini-SF3813
<105636788+Priyadharshini-SF3813@users.noreply.github.com>
Date: Mon, 20 Apr 2026 13:58:05 +0530
Subject: [PATCH 2/3] 1022918: Fixed the Link issue
---
.../asp-net-core/document-handling/load-large-pdf.md | 2 +-
.../document-handling/load-password-pdf.md | 12 ++++++------
2 files changed, 7 insertions(+), 7 deletions(-)
diff --git a/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-large-pdf.md b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-large-pdf.md
index e5b9c41f3..ee4930979 100644
--- a/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-large-pdf.md
+++ b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-large-pdf.md
@@ -143,7 +143,7 @@ require more storage for:
Enabling local storage in the PDF Viewer can improve performance and smoothness when working with large files. This allows the viewer to cache document data locally, reducing repeated network requests and memory spikes.
-Use the [`enableLocalStorage`](https://ej2.syncfusion.com/asp-net-core/documentation/api/pdfviewer/index-default#enablelocalstorage) property to control this behavior. When set to `true`, session data is stored in memory for the current session; when `false` (default), browser session storage is used.
+Use the [`enableLocalStorage`](https://help.syncfusion.com/cr/aspnetcore-js2/syncfusion.ej2.pdfviewer.pdfviewer.html#Syncfusion_EJ2_PdfViewer_PdfViewer_EnableLocalStorage) property to control this behavior. When set to `true`, session data is stored in memory for the current session; when `false` (default), browser session storage is used.
**How the viewer stores this data by default**
diff --git a/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-password-pdf.md b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-password-pdf.md
index 17165c29c..14ad71596 100644
--- a/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-password-pdf.md
+++ b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/load-password-pdf.md
@@ -8,7 +8,7 @@ documentation: ug
domainurl: ##DomainURL##
---
-# Load a Password-Protected PDF
+# Load a Password-Protected PDF in ASP.NET CORE
This article explains how to open password-protected PDF files in the Syncfusion ASP.NET Core PDF Viewer. The viewer supports both user‑interactive loading (Open File dialog) and programmatic loading using APIs.
@@ -18,11 +18,11 @@ When the user selects a password-protected PDF using the built‑in **Open File*
- The viewer detects that the document is encrypted
-
+
- A **password input popup** is automatically displayed
-
+
- The user enters the password
@@ -38,7 +38,7 @@ If you load a password-protected PDF from a URL or through custom logic, the vie
### 2.1 Load the Document Using `viewer.load(url, password)`
-You can directly pass the password in the [`load`](https://ej2.syncfusion.com/aspnetcore/documentation/api/pdfviewer/index-default#load) method:
+You can directly pass the password in the [`load`](https://ej2.syncfusion.com/javascript/documentation/api/pdfviewer/index-default#load) method:
```js
viewer.load(
@@ -55,7 +55,7 @@ This is useful when the password is known beforehand.
### 2.2 Loading a Password-Protected Document's URL Using `documentPath`
-If the [`documentPath`](https://ej2.syncfusion.com/aspnetcore/documentation/api/pdfviewer/index-default#documentpath) points to a password-protected PDF:
+If the [`documentPath`](https://help.syncfusion.com/cr/aspnetcore-js2/syncfusion.ej2.pdfviewer.pdfviewer.html#Syncfusion_EJ2_PdfViewer_PdfViewer_DocumentPath) points to a password-protected PDF:
{% tabs %}
{% highlight cshtml tabtitle="Standalone" %}
@@ -77,6 +77,6 @@ The viewer will:
- Allow the user to enter the correct password
- Then load the PDF
-
+
N> No password should be passed inside `documentPath`.
\ No newline at end of file
From 9bbb6fe1ee2077ca6381fa68e068ff5f72656cd5 Mon Sep 17 00:00:00 2001
From: Priyadharshini-SF3813
<105636788+Priyadharshini-SF3813@users.noreply.github.com>
Date: Tue, 21 Apr 2026 10:51:23 +0530
Subject: [PATCH 3/3] 1022918: Updated the review changes
---
.../asp-net-core/document-handling/preprocess-pdf.md | 10 +++++-----
.../document-handling/retrieve-loadedDoc.md | 4 ++--
2 files changed, 7 insertions(+), 7 deletions(-)
diff --git a/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/preprocess-pdf.md b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/preprocess-pdf.md
index 619de0e46..4fa83078f 100644
--- a/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/preprocess-pdf.md
+++ b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/preprocess-pdf.md
@@ -159,16 +159,16 @@ Use the following ASP.NET Core `cshtml` snippet when you want uploaded PDFs to b
using MemoryStream inputStream = new MemoryStream();
file.CopyTo(inputStream);
inputStream.Position = 0;
- // ✅ Load PDF
+ // Load PDF
PdfLoadedDocument document = new PdfLoadedDocument(inputStream);
- // ✅ Flatten form fields
+ // Flatten form fields
if (document.Form != null)
{
document.Form.Flatten = true;
}
- // ✅ Flatten annotations
+ // Flatten annotations
document.FlattenAnnotations();
- // ✅ Save flattened PDF
+ // Save flattened PDF
using MemoryStream outputStream = new MemoryStream();
document.Save(outputStream);
document.Close(true);
@@ -184,7 +184,7 @@ The PDF Viewer toolbar allows users to:
- Add [standard stamps](../annotation/stamp-annotation#add-stamp-annotations-to-the-pdf-document) (Approved, Draft, etc.)
- Insert [custom image stamps](../annotation/stamp-annotation#add-a-custom-stamp)
-
+
### Programmatically Add a Watermark
```js
diff --git a/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/retrieve-loadedDoc.md b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/retrieve-loadedDoc.md
index 94de04a1d..31dc1246f 100644
--- a/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/retrieve-loadedDoc.md
+++ b/Document-Processing/PDF/PDF-Viewer/asp-net-core/document-handling/retrieve-loadedDoc.md
@@ -58,7 +58,7 @@ Below is a focused snippet showing:
viewer = document.getElementById('container').ej2_instances[0];
};
- // ✅ ASP.NET Core: onDocumentLoad
+ // ASP.NET Core: onDocumentLoad
window.onDocumentLoad = function (args) {
if (!viewer) return;
@@ -150,7 +150,7 @@ This example demonstrates a complete flow:
viewer = document.getElementById('pdfViewer').ej2_instances[0];
};
- // ✅ ASP.NET Core: handleDocumentLoad
+ // ASP.NET Core: handleDocumentLoad
window.onDocumentLoad = function (args) {
if (!viewer) return;
docInfo.name = args && args.documentName;