Converting PDF files to images is a common requirement for applications that involve document previews, thumbnails generation, or PDF content archiving. For .NET developers, the Spire.PDF library offers a robust and efficient way to achieve this PDF to image conversion with high fidelity. Its key advantages include:

• High-Fidelity Rendering: Preserve original layouts and graphics.
• Multi-Format Support: Export to PNG, JPEG, BMP, TIFF, and more.
• Cross-Platform: Works with .NET Framework, .NET Core, and .NET 6+.

In this guide, you’ll learn how to use the Spire.PDF for .NET library to convert PDF to JPG or PNG images in C#, with installation guide, practical code snippets, and conversion optimization tips.

• Install the PDF to Image Converter Library
• Convert PDF to JPG Images in C#: Basic Example
• Advanced PDF to Image Conversion Options
  • Set Image Resolution
  • Convert an Entire PDF File to Images
  • Convert to Different Image Formats
  • Using MemoryStream
• Performance Optimization Tips
• FAQs (PDF to TIFF, PDF to SVG)

Install the PDF to Image Converter Library

Before you can start using C# to convert PDF to PNG or PDF to JPG, it’s necessary to install the Spire.PDF for .NET library first. You can do this via NuGet Package Manager:

• Open your project in Visual Studio
• Go to “Tools > NuGet Package Manager > Manage NuGet Packages for Solution”
• Search for "Spire.PDF"
• Select and install the package

Alternatively, use the Package Manager Console:

PM> Install-Package Spire.PDF

Once installed, you're ready to start writing code to handle PDF to image conversions.

Convert PDF to JPG Images in C#: Basic Example

The SaveAsImage(int pageIndex, PdfImageType type) method of the PdfDocument class can be used to convert a specified PDF page to an image. The two parameters are:

1. pageIndex (Int32)

• Description: The index of the PDF page to be converted (page index starts from 0).
• Example:
  • 0 = First page
  • 1 = Second page

1. type (PdfImageType)

• Description: Specifies the type of the PdfImage.
• Enum Values:
  • Bitmap
  • Metafile

The following code demonstrates how to convert the first page of a PDF to a JPEG image using Spire.PDF:

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;
using System.Drawing.Imaging;

namespace PDFtoJPG
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a PdfDocument instance
            PdfDocument pdf = new PdfDocument();

            // Load a sample PDF document
            pdf.LoadFromFile("input.pdf");

            // Convert the first page to a bitmap image
            Image image = pdf.SaveAsImage(0, PdfImageType.Bitmap);

            // Save the image as a JPG file
            image.Save("PdfToJPG.jpg", ImageFormat.Jpeg);

            // Disposes PDF resources
            pdf.Dispose();
        }
    }
}

Advanced PDF to Image Conversion Options

1. Set Image Resolution

Spire.PDF offers another overload of the SaveAsImage() method that takes four parameters: the page index, image type, horizontal (dpiX) and vertical (dpiY) resolution. This allows you to control the quality and size of the output image by customizing the DPI settings.

The following code example converts the first page of a PDF to a high-resolution PNG image (300 DPI):

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;
using System.Drawing.Imaging;

namespace PDFtoImage
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a PdfDocument instance
            PdfDocument pdf = new PdfDocument();

            // Load a sample PDF document
            pdf.LoadFromFile("input.pdf");

            // Convert the first page to an image and with specified image resolution
            Image image = pdf.SaveAsImage(0, PdfImageType.Bitmap, 300, 300);

            // Save the image as a PNG file
            image.Save("PdfToPNG.png", ImageFormat.Png);

            // Disposes PDF resources
            pdf.Dispose();

        }
    }
}

Note: Higher DPI improves image quality but slow down conversion.

2. Convert an Entire PDF File to Images

Loop through all pages in the PDF and then convert each one to a separate image.

// Loop through all pages in the PDF
for (int i = 0; i < pdf.Pages.Count; i++)
{
    // Convert each page to an image and set the image Dpi
    Image image = pdf.SaveAsImage(i, PdfImageType.Bitmap, 300, 300);

    // Save the image as PNG format to a specified folder
    string file = string.Format("Image\\ToImage-{0}.png", i);
    image.Save(file, ImageFormat.Png);
}

3. Convert to Different Image Formats

By changing the ImageFormat parameter of the Image.Save() method, you can convert PDF to JPG, PNG, BMP, or Gif formats:

// Save to JPEG format
image.Save("PDFtoJPG.jpg", ImageFormat.Jpeg);

// Save to PNG format
image.Save("PDFtoPNG.png", ImageFormat.Png);

// Save to BMP format
image.Save("PDFtoBMP.bmp", ImageFormat.Bmp);

// Save to EMF format
image.Save("PDFtoEMF.emf", ImageFormat.Emf);

// Save to GIF format
image.Save("PDFtoGIF.gif", ImageFormat.Gif);

4. Using MemoryStream

For scenarios requiring stream handling, use the following code:

// Create a MemoryStream object
MemoryStream ms = new MemoryStream();

// Convert the first page to an image with specified dpi
Image image = pdf.SaveAsImage(0, PdfImageType.Bitmap, 300, 300);

// Save the image to stream in PNG format
image.Save(ms, ImageFormat.Png);

// Write the Stream object to a byte array for further processing
byte[] imageBytes = ms.ToArray();

Performance Optimization Tips

• Memory Management: Convert pages one by one to avoid memory overload for large PDFs.
• DPI Optimization: High DPI settings improve image quality, but also increase file size and processing time.
• Dispose Resources: Call the Dispose() method of PdfDocument class to free resources.

Conclusion

Spire.PDF provides a straightforward and efficient way to convert PDF files to images in C#. With its rich feature set, high-quality rendering, and support for multiple image formats, it’s a reliable choice for both simple and complex PDF-to-image conversion tasks. By following the examples in this article, you can quickly implement PDF converter functionality in your .NET applications.

FAQs

Q1: How to remove the watermarks on the output images?

A: You can request a free 30-day trial license here to remove the red watermark and fully evaluate the Spire.PDF library. Or you can use its Free version (with certain page limitations).

Q2: Can I convert PDFs to multi-page TIFF files with Spire.PDF?

A: Yes! A detailed guide for this can be found at: Convert PDF to TIFF in C#

Q3: Can I convert PDF to SVG using Spire.PDF?

A: Yes! Spire.PDF for .NET offers the SaveToFile(String, FileFormat.SVG) method to convert a PDF file to a SVG file. You can check out the article for a comprehensive guide.

Q4. Where can I find additional documentation or support?

• Spire.PDF Documentation
• Spire.PDF API Reference
• E-iceblue Support Forum

Using stream operations in C#, developers can dynamically create, load, and save Excel files, enabling flexible and efficient data handling. This approach eliminates the need for physical file storage, improving application performance and responsiveness. Ideal for real-time data manipulation or environments with storage limitations, it streamlines data exchange and system integration. This article demonstrates how to create, load, modify, and save Excel files using streams in C# with Spire.XLS for .NET, offering agile and scalable data management solutions.

• Dynamically Create an Excel File and Save It to Stream
• Load and Read Excel Files from Stream with C#
• Modify an Excel File in Stream with C#

Install Spire.XLS for .NET

To begin with, you need to add the DLL files included in the Spire.XLS for .NET package as references in your .NET project. The DLL files can be either downloaded from this link or installed via NuGet.

PM> Install-Package Spire.XLS

Dynamically Create an Excel File and Save It to Stream

Using Spire.XLS for .NET, developers can dynamically create Excel files in memory by initializing a Workbook object, populating it with data and formatting, and then saving the workbook to a stream using the Workbook.SaveToStream() method. This approach eliminates the need for physical file storage, enhancing both application performance and responsiveness.

Below are the steps for creating an Excel file and saving it to a stream with C#:

• Create an instance of the Workbook class to generate a new Excel workbook, which includes three default worksheets.
• Retrieve a specific worksheet using the Workbook.Worksheets[] property.
• Define the data to write to the worksheet, such as using a DataTable to organize the data.
• Insert the data into the worksheet using the Worksheet.InsertDataTable() method or the Worksheet.Range[].Value property for individual cell values.
• Format the worksheet cells, applying styles like colors, fonts, and borders, or adjusting column widths as needed.
• Save the workbook to a memory stream using the Workbook.SaveToStream() method. The stream can then be used for further processing, such as saving it to a file or transmitting it over a network.

using Spire.Xls;
using System.Data;
using System.Drawing;

namespace CreateExcelStream
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a new workbook instance
            Workbook workbook = new Workbook();

            // Access the first worksheet in the workbook
            Worksheet sheet = workbook.Worksheets[0];

            // Create and populate a DataTable with sample data
            DataTable dataTable = new DataTable("Data");
            dataTable.Columns.Add("ID", typeof(int));
            dataTable.Columns.Add("Name", typeof(string));
            dataTable.Columns.Add("Age", typeof(int));
            dataTable.Columns.Add("Country", typeof(string));
            dataTable.Columns.Add("Salary ($)", typeof(decimal));
            dataTable.Rows.Add(101, "John Smith", 28, "USA", 54000m);
            dataTable.Rows.Add(102, "Maria Garcia", 34, "Spain", 65500m);
            dataTable.Rows.Add(103, "Liam Johnson", 22, "Canada", 48000m);
            dataTable.Rows.Add(104, "Emma Brown", 30, "Australia", 72300m);
            dataTable.Rows.Add(105, "Wei Zhang", 40, "China", 58700m);
            dataTable.Rows.Add(106, "Sofia Lopez", 26, "Mexico", 45200m);

            // Insert data from the DataTable into the worksheet
            sheet.InsertDataTable(dataTable, true, 1, 1);

            // Format the worksheet
            // Style the header row
            sheet.Rows[0].Style.Color = Color.LightGreen;
            sheet.Rows[0].Style.Font.FontName = "Arial";
            sheet.Rows[0].Style.Font.Size = 12f;
            sheet.Rows[0].BorderAround(); // Apply borders around the header row
            sheet.Rows[0].Borders.Color = Color.Blue;

            // Style the data rows
            for (int i = 1; i < sheet.AllocatedRange.Rows.Count(); i++)
            {
                sheet.Rows[i].Style.Color = Color.LightGray;
                sheet.Rows[i].Style.Font.FontName = "Arial";
                sheet.Rows[i].Style.Font.Size = 11f;
            }

            // Adjust the column widths to fit the content
            for (int j = 1; j <= sheet.AllocatedRange.Columns.Count(); j++)
            {
                sheet.AutoFitColumn(j);
            }

            // Save the workbook to a memory stream
            MemoryStream stream = new MemoryStream();
            workbook.SaveToStream(stream, FileFormat.Version2016);

            // Write the stream content to a file
            File.WriteAllBytes("output/CreateExcelByStream.xlsx", stream.ToArray());

            // Release resources
            workbook.Dispose();
        }
    }
}

Load and Read Excel Files from Stream with C#

Spire.XLS for .NET simplifies loading Excel files directly from a stream using the Workbook.LoadFromStream() method. Once the file is loaded, developers can easily access and read cell data, optimizing memory usage and enabling fast, flexible data processing without requiring file I/O operations.

The steps for loading and reading Excel files from streams with C# are as follows:

• Create a Workbook instance.
• Create a MemoryStream or FileStream object.
• Use the Workbook.LoadFromStream() method to load the Excel file from the stream into the workbook.
• Retrieve the first worksheet using the Workbook.Worksheets[] property.
• Loop through the rows and columns of the worksheet to extract the cell through the Worksheet.AllocatedRange[].Value property.
• Print the extracted data, or use the data for further operations.

using Spire.Xls;

namespace LoadExcelStream
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create an instance of the Workbook class
            Workbook workbook = new Workbook();

            // Create a memory stream
            MemoryStream stream = new MemoryStream();
            File.OpenRead("Sample.xlsx").CopyTo(stream);

            // Load the Excel file from the stream
            workbook.LoadFromStream(stream);

            // Access the first worksheet in the workbook
            Worksheet sheet = workbook.Worksheets[0];

            // Initialize a list to store the data retrieved from the worksheet
            List<List<string>> data = new List<List<string>>();
            for (int i = 0; i < sheet.AllocatedRange.Rows.Count(); i++)
            {
                // Create a list to hold each row of data
                List<string> lines = new List<string>();
                for (int j = 0; j < sheet.AllocatedRange.Columns.Count(); j++)
                {
                    // Retrieve the cell text and add it to the row
                    lines.Add(sheet.AllocatedRange[i + 1, j + 1].Text);
                }
                // Add the row to the data list
                data.Add(lines);
            }

            // Print the retrieved data or use it for further operations
            foreach (List<string> lines in data)
            {
                Console.WriteLine(string.Join(" | ", lines));
            }
        }
    }
}

Modify an Excel File in Stream with C#

With Spire.XLS for .NET, developers can modify an Excel file in memory by first loading it into a Workbook object with the LoadFromStream() method. After making updates (such as changing cell values or formatting), the file can be saved back to a stream using the Workbook.SaveToStream() method. This approach allows seamless real-time changes without relying on physical storage.

Follow the steps below to modify Excel files in streams with C#:

• Create a Workbook instance to represent the Excel file.
• Create a MemoryStream or FileStream instance.
• Use the Workbook.LoadFromStream() to load the Excel file from the stream.
• Access the first worksheet through the Workbook.Worksheets[] property.
• Modify the header row and the data rows' styles (font, size, background color, etc.) through the properties in CellRange.Style.
• Autofit the columns to adjust their width based on the content using the Worksheet.AutoFitColumn() method.
• Save the changes to the stream using the Workbook.SaveToStream() method.

using Spire.Xls;
using System.Drawing;

namespace ModifyExcelStream
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a new instance of the Workbook class
            Workbook workbook = new Workbook();

            // Create a memory stream
            MemoryStream stream = new MemoryStream();
            File.OpenRead("Sample.xlsx").CopyTo(stream);

            // Load the Excel file from the stream
            workbook.LoadFromStream(stream);

            // Access the first worksheet in the workbook
            Worksheet sheet = workbook.Worksheets[0];

            // Modify the style of the header row
            CellRange headerRow = sheet.AllocatedRange.Rows[0];
            headerRow.Style.Font.FontName = "Times New Roman";
            headerRow.Style.Font.Size = 12f;
            headerRow.Style.Color = Color.LightBlue;

            // Modify the style of the data rows
            for (int i = 1; i < sheet.AllocatedRange.Rows.Count(); i++)
            {
                CellRange dataRow = sheet.AllocatedRange.Rows[i];
                dataRow.Style.Font.FontName = "Arial";
                dataRow.Style.Font.Size = 10f;
                dataRow.Style.Color = Color.LightGray;
                // Alternate row coloring (even rows)
                if (i % 2 == 0)
                {
                    dataRow.Style.Color = Color.LightSlateGray;
                }
            }

            // Autofit columns to adjust their width based on content
            for (int k = 1; k <= sheet.AllocatedRange.Columns.Count(); k++)
            {
                sheet.AutoFitColumn(k);
            }

            // Change the border color
            sheet.AllocatedRange.Style.Borders.Color = Color.White;

            // Save the modified workbook back to the stream
            workbook.SaveToStream(stream);

            // Write the stream content to a new file
            File.WriteAllBytes("output/ModifyExcelByStream.xlsx", stream.ToArray());

            // Release resources
            workbook.Dispose();
        }
    }
}

Apply for a Temporary License

If you'd like to remove the evaluation message from the generated documents, or to get rid of the function limitations, please request a 30-day trial license for yourself.

XPS (XML Paper Specification) is a fixed-layout document format designed to preserve document fidelity and provide device-independent document appearance. It is similar to PDF, but is based on XML rather than PostScript. If you want to save a Word document to a fixed-layout file format, XPS would be an option. This article will demonstrate how to convert Word documents to XPS in C# and VB.NET using Spire.Doc for .NET.

Install Spire.Doc for .NET

To begin with, you need to add the DLL files included in the Spire.Doc for.NET package as references in your .NET project. The DLL files can be either downloaded from this link or installed via NuGet.

PM> Install-Package Spire.Doc

Convert Word to XPS in C# and VB.NET

The following are the detailed steps to convert a Word document to XPS using Spire.Doc for .NET:

• Initialize an instance of Document class.
• Load a Word document using Document.LoadFromFile() method.
• Save the Word document to XPS using Document.SaveToFile(string filePath, FileFormat fileFormat) method.

using Spire.Doc;
namespace ConvertWordToXps
{
    class Program
    {
        static void Main(string[] args)
        {
            //Create a Document instance
            Document doc = new Document();
            //Load a Word document
            doc.LoadFromFile("Sample.docx");
            //convert the document to XPS
            doc.SaveToFile("ToXPS.xps", FileFormat.XPS);
        }
    }
}

Imports Spire.Doc

Namespace ConvertWordToXps
    Friend Class Program
        Private Shared Sub Main(ByVal args As String())
            'Create a Document instance
            Dim doc As Document = New Document()
            'Load a Word document
            doc.LoadFromFile("Sample.docx")
            'convert the document to XPS
            doc.SaveToFile("ToXPS.xps", FileFormat.XPS)
        End Sub
    End Class
End Namespace

Apply for a Temporary License

If you'd like to remove the evaluation message from the generated documents, or to get rid of the function limitations, please request a 30-day trial license for yourself.

XPS is short for XML Paper Specification developed by Microsoft, which is a specification for a page description language and a fixed-document format. It comes out by Microsoft’s initiative to associate file creation with reading in its Windows operating system. Like PDF, XPS plays a loyal role to preserve document with offering device-independent document appearance. Editing in XPS or in PDF seems difficult.

As a flexible and professional component, Spire.PDF for .NEToffers a large variety conversion, among which the conversion from XPS to PDF is one of its popular feature. In addition, Spire.PDF for .NET can be applied in WinForm, ASP.NET and Console Application.

The following code example shows how to convert XPS files to PDF document.

Step 1: Introduce a class named pdfDocument which is used to initialize a Spire.PDF.PdfDocument, and load a XPS file by calling the method of LoadForm File.

PdfDocument doc = new PdfDocument();
doc.LoadFromFile(xpsFile,FileFormat.XPS);

Step 2: Only needs one row of simple code. Call the SavetoFile method of Spire.PDF.pdfDocument to save all the data as PDF formart.

doc.SaveToFile(pdfFile, FileFormat.PDF);

After this code, run this application and you will see the PDF converted from XPS.

Screenshot before converting XPS to PDF:

Screenshot after converting XPS to PDF:

Spire.BarCode for .NET is a professional barcode component specially designed for .NET developers (C#, VB.NET, ASP.NET) to generate, read 1D & 2D barcodes. Developers and programmers can use Spire.BarCode to add Enterprise-Level barcode formats to their .net applications (ASP.NET, WinForms) quickly and easily. Below is how to use Spire.BarCode for .NET.

Step 1: Create Project

Create a C#/VB.NET Windows Forms Application project in visual studio, name it Barcode.

Step 2: Add Spire.Barcode.dll

• In Toolbox, right-click the blank area, select "Add Tab", name it "Spire.Barcode Controls".
• Right-click "Spire.Barcode Controls", select "Choose Items", select ".NET Framework Components", Click "Browse", find the Spire.Barcode.dll and double-click it.
• Then you will see "BarCodeControl" shown in "Spire.Barcode Controls" in Toolbox.

Step 3: Add Controls

Here is what the window looks like:

Step 4: Generate Barcode Image

btnCreate_Click is the method to generate barcode image. There are two import classes-BarCodeControl and BarCodeGenerator in this method. BarCodeControl stores information about barcode.

Here are some introductions about some of its properties:

BarCodeGenerator is the class to generate barcode image. Its constructor takes one parameter – a BarCodeControl instance. It has a method called GenerateImage() whose return value is Image object to generate image.

//Generate the barcode based on the this.barCodeControl1
BarCodeGenerator generator = new BarCodeGenerator(this.barCodeControl1);
Image barcode = generator.GenerateImage();
            
//save the barcode as an image
barcode.Save("barcode.png");

'Generate the barcode based on the barCodeControl1
Dim generator As New BarCodeGenerator(barCodeControl1)
Dim barcode As Image = generator.GenerateImage()

'save the barcode as an image
barcode.Save("barcode.png")

Step 5: Scan Barcode Image

BarcodeScanner is the class to scan barcode image. Call its method Scan with the Bitmap object containing the barcode image, it returns a string [] value where the scanning result is stored.

And btnScan_Click uses the class BarcodeScanner to scan barcode image in its code.

Here is the code in btnScan_Click.

private void btnScan_Click(object sender, EventArgs e)
{
//scan the barcode
string[] datas = Spire.Barcode.BarcodeScanner.Scan("barcode.png");

//show the scan result
this.TextB_ScanResult.Text = datas[0];
}

Private Sub btnScan_Click(ByVal sender As Object, ByVal e As EventArgs) Handles btnScan.Click
'scan the barcode
Dim datas() As String = Spire.Barcode.BarcodeScanner.Scan("barcode.png")

'show the scan result
Me.TextB_ScanResult.Text = datas(0)
End Sub

Step 6. Running

Run the project. You will see a window opened.

Put in some settings and click the button "Create". You will see the generated barcode image.

Click the button "Scan". You will see the barcode text shown in TextB_ScanResult.