IronPdf.License.LicenseKey = "YourLicenseKey";
ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderUrlAsPdf("https://www.wikipedia.org/");
pdf.SaveAs("wiki.pdf");

// Set your IronPDF license key to unlock all features
IronPdf.License.LicenseKey = "YourLicenseKey";

// Create an instance of the Chrome PDF renderer
ChromePdfRenderer pdfRenderer = new ChromePdfRenderer();

// Render the Wikipedia homepage to a PDF document
PdfDocument document = pdfRenderer.RenderUrlAsPdf("https://www.wikipedia.org/");

// Save the rendered PDF to a file named 'wiki.pdf'
document.SaveAs("wiki.pdf");

IronPdf.License.LicenseKey = "YourLicenseKey";
ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Welcome to IronPdf</h1>");
pdf.SaveAs("ExampleFromHtmlString.pdf");

IronPdf.License.LicenseKey = "YourLicenseKey";
ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Hello IronPdf</h1>");
pdf.SaveAs("HtmlString.pdf");

// Assign your license key
IronPdf.License.LicenseKey = "YourLicenseKey";

// Initialize the Chrome-based PDF renderer
ChromePdfRenderer pdfRenderer = new ChromePdfRenderer();

// Create a PDF from HTML string
PdfDocument newPdfDocument = pdfRenderer.RenderHtmlAsPdf("<h1>Hello IronPdf</h1>");

// Save the generated PDF to a file
newPdfDocument.SaveAs("HtmlString.pdf");

3. Enhance the `ClientModel` class by marking the attributes 'name,' 'phone,' and 'email' as mandatory. Ensure this by applying the `Required` attribute to each field as shown below:

public class ClientInformation
{
    [Required]
    public string Name { get; set; }  // Client's name must be provided
    [Required]
    public string Phone { get; set; } // Client's phone is necessary
    [Required]
    public string Email { get; set; } // Email address is required
}

public class ClientServices
{
    private static ClientModel _clientData;
    public static void RegisterClient(ClientModel client)
    {
        _clientData = client;
    }
    public static ClientModel RetrieveClient()
    {
        return _clientData;
    }
}

@model IronPdfMVCHelloWorld.Models.ClientModel
@{
  ViewBag.Title = "Book Ticket";
}
<h2>Index</h2>
@using (Html.BeginForm())
{
  <div class="form-horizontal">
    @Html.ValidationSummary(true, "", new { @class = "text-danger" })
    <div class="form-group">
      @Html.LabelFor(model => model.Name, htmlAttributes: new { @class = "control-label col-md-2" })
      <div class="col-md-10">
        @Html.EditorFor(model => model.Name, new { htmlAttributes = new { @class = "form-control" } })
        @Html.ValidationMessageFor(model => model.Name, "", new { @class = "text-danger" })
      </div>
    </div>
    <div class="form-group">
      @Html.LabelFor(model => model.Phone, htmlAttributes: new { @class = "control-label col-md-2" })
      <div class="col-md-10">
        @Html.EditorFor(model => model.Phone, new { htmlAttributes = new { @class = "form-control" } })
        @Html.ValidationMessageFor(model => model.Phone, "", new { @class = "text-danger" })
      </div>
    </div>
    <div class="form-group">
      @Html.LabelFor(model => model.Email, htmlAttributes: new { @class = "control-label col-md-2" })
      <div class="col-md-10">
        @Html.EditorFor(model => model.Email, new { htmlAttributes = new { @class = "form-control" } })
        @Html.ValidationMessageFor(model => model.Email, "", new { @class = "text-danger" })
      </div>
    </div>
    <div class="form-group">
      <div class="col-md-10 pull-right">
        <button type="submit" value="Save" class="btn btn-sm">
          <i class="fa fa-plus"></i>
          <span>Save</span>
        </button>
      </div>
    </div>
  </div>
}

@model IronPdfMVCHelloWorld.Models.ClientModel
@{
  ViewBag.Title = "Ticket Reservation";
}
<h2>Booking Form</h2>
@using (Html.BeginForm())
{
  <div class="form-horizontal">
    @Html.ValidationSummary(true, "", new { @class = "text-danger" })
    <div class="form-group">
      @Html.LabelFor(model => model.Name, htmlAttributes: new { @class = "control-label col-md-2" })
      <div class="col-md-10">
        @Html.EditorFor(model => model.Name, new { htmlAttributes = new { @class = "form-control" } })
        @Html.ValidationMessageFor(model => model.Name, "", new { @class = "text-danger" })
      </div>
    </div>
    <div class="form-group">
      @Html.LabelFor(model => model.Phone, htmlAttributes: new { @class = "control-label col-md-2" })
      <div class="col-md-10">
        @Html.EditorFor(model => model.Phone, new { htmlAttributes = new { @class = "form-control" } })
        @Html.ValidationMessageFor(model => model.Phone, "", new { @class = "text-danger" })
      </div>
    </div>
    <div class="form-group">
      @Html.LabelFor(model => model.Email, htmlAttributes: new { @class = "control-label col-md-2" })
      <div class="col-md-10">
        @Html.EditorFor(model => model.Email, new { htmlAttributes = new { @class = "form-control" } })
        @Html.ValidationMessageFor(model => model.Email, "", new { @class = "text-danger" })
      </div>
    </div>
    <div class="form-group">
      <div class="col-md-10 push-right">
        <button type="submit" class="btn btn-small">
          <i class="fa fa-save"></i>
          <span>
            Register
          </span>
        </button>
      </div>
    </div>
  </div>
}

[HttpPost]
public ActionResult Index(ClientModel clientDetails)
{
    // Check if the submitted model data is valid
    if (ModelState.IsValid)
    {
        // If valid, add the client details to the services
        ClientServices.AddClient(clientDetails);
        // Redirect to the TicketView action to proceed
        return RedirectToAction("TicketView");
    }
    // If data is invalid, reload the Index view with the current model data
    return View(clientDetails);
}

// Detailed instructions for creating a Ticket model within the Models directory:
// Begin by defining the TicketModel class with necessary properties.
public class TicketModel : ClientModel
{
    // Required attribute enforces the necessity of the following field
    [Required]
    public int TicketNumber { get; set; }

    // Required attribute for the date field to ensure it's provided
    [Required]
    public DateTime TicketDate { get; set; }
}

public class TicketModel : ClientModel
{
    public int TicketNumber { get; set; } // Stores the unique number for the ticket.
    public DateTime TicketDate { get; set; } // Records the issue date of the ticket.
}

public ActionResult DisplayTicket()
{
    // Generate a random ticket number
    Random randomNumberGenerator = new Random();
    
    // Retrieve current client information
    ClientModel currentClient = ClientServices.GetClient();
    
    // Create a new ticket with unique details
    TicketModel newTicket = new TicketModel()
    {
        TicketNumber = randomNumberGenerator.Next(100000, 999999), // Random ticket number
        TicketDate = DateTime.Now, // Set the date to current date and time
        Email = currentClient.Email, // Client's email
        Name = currentClient.Name, // Client's name
        Phone = currentClient.Phone // Client's phone number
    };

    // Return the populated view with the ticket details
    return View(newTicket);
}

[HttpPost]
public ActionResult TicketView(TicketModel model)
{
    IronPdf.Installation.TempFolderPath = $@"{Directory.GetParent}/irontemp/";
    IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = true;

    // Asynchronously render the HTML partial view to a string
    var htmlContent = this.RenderViewAsync("_TicketPdf", model).Result;

    // Initialize the PDF renderer
    var pdfRenderer = new IronPdf.ChromePdfRenderer();

    // Convert the HTML content to a PDF document
    using var pdfDocument = pdfRenderer.RenderHtmlAsPdf(htmlContent, @"wwwroot/css");

    // Return the generated PDF file
    return File(pdfDocument.Stream.ToArray(), "application/pdf");
}

[HttpPost]
public ActionResult DisplayTicket(TicketModel ticketData)
{
    // Set the temporary folder path for IronPDF operations
    IronPdf.Installation.TempFolderPath = $@"{Directory.GetParent}/temp-pdf-storage/";

    // Automatically configure dependencies for Docker and Linux environments
    IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = true;

    // Render the "_TicketPdf" view asynchronously and capture the HTML content
    var htmlContent = this.RenderViewAsync("_TicketPdf", ticketData);

    // Initialize a new PDF renderer
    var pdfRenderer = new IronPdf.ChromePdfRenderer();

    // Generate a PDF from the rendered HTML and specify the CSS path
    using var generatedPdf = pdfRenderer.RenderHtmlAsPdf(htmlContent.Result, @"wwwroot/css");

    // Return the generated PDF as a file download
    return File(generatedPdf.Stream.ToArray(), "application/pdf");
}

IronPdf.License.LicenseKey = "YourLicenseKey"; // License key for IronPDF
ChromePdfRenderer pdfRenderer = new ChromePdfRenderer(); // Initialize Chrome based PDF Renderer

// Configure basic rendering options
pdfRenderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4; // Set the size of the PDF paper to A4
pdfRenderer.RenderingOptions.PaperOrientation = IronPdf.Rendering.PdfPaperOrientation.Portrait; // Set the orientation of the PDF paper to Portrait

// Convert an HTML file to a PDF and save it
pdfRenderer.RenderHtmlFileAsPdf(@"testFile.html").SaveAs("GeneratedFile.pdf");

IronPdf.License.LicenseKey = "YourLicenseKey";

// Load a standard PDF
PdfDocument standardPdf = PdfDocument.FromFile("exampleFile.pdf");

// Load a password-protected PDF
PdfDocument protectedPdf = PdfDocument.FromFile("secureFile.pdf", "MySecretPassword");

IronPdf.License.LicenseKey = "YourLicenseKey";
List<PdfDocument> PdfFiles = new List<PdfDocument>();
PdfFiles.Add(PdfDocument.FromFile("file1.pdf"));
PdfFiles.Add(PdfDocument.FromFile("file2.pdf"));
PdfFiles.Add(PdfDocument.FromFile("file3.pdf"));

using PdfDocument mergedPdf = PdfDocument.Merge(PdfFiles);
mergedPdf.SaveAs("CombinedPdf.pdf");

foreach (PdfDocument pdf in PdfFiles)
{
    pdf.Dispose();
}

IronPdf.License.LicenseKey = "YourLicenseKey";
PdfDocument mainPdf = PdfDocument.FromFile("file1.pdf");
PdfDocument additionalPdf = PdfDocument.FromFile("file2.pdf");

// Append another PDF to the end of the current PDF
mainPdf.AppendPdf(additionalPdf);
mainPdf.SaveAs("ExpandedPdf.pdf");

// Insert a PDF at a specific index
mainPdf.InsertPdf(additionalPdf, 0);
mainPdf.SaveAs("InsertedPdf.pdf");

IronPdf.License.LicenseKey = "YourLicenseKey";
PdfDocument pdf = PdfDocument.FromFile("existingFile.pdf");

TextHeaderFooter header = new TextHeaderFooter()
{
    CenterText = "PDF Header",
    LeftText = "{date} {time}",
    RightText = "{page} of {total-pages}",
    DrawDividerLine = true,
    FontSize = 10
};

pdf.AddTextHeaders(header);
pdf.SaveAs("HeaderAdded.pdf");

HtmlHeaderFooter footer = new HtmlHeaderFooter()
{
    HtmlFragment = "<span style='text-align:right'>Page {page} of {totalpages}</span>",
    DrawDividerLine = true,
    MaxHeight = 10 //mm
};

pdf.AddHtmlFooters(footer);
pdf.SaveAs("CompleteWithHeaderFooter.pdf");

IronPdf.License.LicenseKey = "YourLicenseKey";
ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
{
    CenterText = "PDF Header",
    LeftText = "{date} {time}",
    RightText = "{page} of {total-pages}",
    DrawDividerLine = true,
    FontSize = 10
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<span style='text-align:right'> page {page} of {totalpages}</span>",
    DrawDivider Line = true,
    MaxHeight = 10
};
PdfDocument pdf = renderer.RenderHtmlFileAsPdf("yourFile.html");
pdf.SaveAs("DecoratedPDF.pdf");

IronPdf.License.LicenseKey = "YourLicenseKey";

// Load a standard unencrypted PDF file
PdfDocument regularPdf = PdfDocument.FromFile("testFile.pdf");

// Load a secured PDF file with a specified password
PdfDocument securedPdf = PdfDocument.FromFile("testFile2.pdf", "MyPassword");

IronPdf.License.LicenseKey = "YourLicenseKey";
List<PdfDocument> PDFs = new List<PdfDocument>();
PDFs.Add(PdfDocument.FromFile("1.pdf"));
PDFs.Add(PdfDocument.FromFile("2.pdf"));
PDFs.Add(PdfDocument.FromFile("3.pdf"));
using PdfDocument finalPDF = PdfDocument.Merge(PDFs);
finalPDF.SaveAs("mergedFile.pdf");
foreach (PdfDocument doc in PDFs)
{
    doc.Dispose();
}

IronPdf.License.LicenseKey = "YourLicenseKey"; // Initiate your license
PdfDocument pdf = PdfDocument.FromFile("1.pdf"); // Load the original PDF
PdfDocument pdf2 = PdfDocument.FromFile("2.pdf"); // Load the PDF to append
pdf.AppendPdf(pdf2); // Append the second PDF to the first
pdf.SaveAs("appendedFile.pdf"); // Save the combined PDF

// Initialize IronPdf with your unique license key
IronPdf.License.LicenseKey = "YourLicenseKey";

// Load the first PDF document
PdfDocument mainPdf = PdfDocument.FromFile("1.pdf");

// Load the second PDF document to be appended
PdfDocument additionalPdf = PdfDocument.FromFile("2.pdf");

// Append the second PDF to the first PDF
mainPdf.AppendPdf(additionalPdf);

// Save the combined PDF to a new file
mainPdf.SaveAs("appendedFile.pdf");

IronPdf.License.LicenseKey = "YourLicenseKey";
PdfDocument primaryPdf = PdfDocument.FromFile("1.pdf");
PdfDocument secondaryPdf = PdfDocument.FromFile("2.pdf");

// Insert secondary PDF at the start of the primary PDF
primaryPdf.InsertPdf(secondaryPdf, 0);
primaryPdf.SaveAs("InsertAtSpecificIndex.pdf");

// Apply your licensing key from IronPdf
IronPdf.License.LicenseKey = "YourLicenseKey";

// Load a PDF document from the specified path
PdfDocument mainPdf = PdfDocument.FromFile("1.pdf");

// Load another PDF document to be inserted
PdfDocument secondaryPdf = PdfDocument.FromFile("2.pdf");

// Insert the secondary PDF into the beginning of the main PDF document
mainPdf.InsertPdf(secondaryPdf, index: 0);

// Save the modified PDF with a new file name
mainPdf.SaveAs("InsertIntoSpecificIndex.pdf");

// Initialize the IronPDF license and create a new PDF document from a file
IronPdf.License.LicenseKey = "YourLicenseKey";
PdfDocument document = PdfDocument.FromFile("testFile.pdf");

// Define the text-based header with alignment and formatting options
TextHeaderFooter textHeader = new TextHeaderFooter()
{
    CenterText = "Pdf Header",
    LeftText = "{date} {time}",
    RightText = "{page} of {total-pages}",
    DrawDividerLine = true,
    FontSize = 10
};

// Add the defined text header to the PDF document
document.AddTextHeaders(textHeader);

// Save the document with the text header added
document.SaveAs("withHeader.pdf");

// Define the HTML footer to use in the PDF
HtmlHeaderFooter htmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<span style='text-align:right'> page {page} of {totalpages}</span>",
    DrawDividerLine = true,
    MaxHeight = 10 // in millimeters
};

// Add the HTML footer to the PDF document
document.AddHtmlFooters(htmlFooter);

// Save the document with both the text header and the HTML footer added
document.SaveAs("withHeaderAndFooters.pdf");

IronPdf.License.LicenseKey = "YourLicenseKey";
ChromePdfRenderer renderer = new ChromePdfRenderer();

// Configuration for headers
renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
{
    CenterText = "PDF Header",
    LeftText = "{date} {time}",
    RightText = "{page} of {total-pages}",
    DrawDividerLine = true,
    FontSize = 12
};

// Configuration for footers
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<span style='text-align:right'>Page {page} of {totalpages}</span>",
    DrawDividerLine = true,
    MaxHeight = 12
};

PdfDocument pdf = renderer.RenderHtmlFileAsPdf("example.html");
pdf.SaveAs("createdWithHeadersFooters.pdf");

// Assign your license key
IronPdf.License.LicenseKey = "YourLicenseKey";

// Create a new instance of the PDF renderer
ChromePdfRenderer pdfRenderer = new ChromePdfRenderer();

// Configure the header for the PDF
pdfRenderer.RenderingOptions.TextHeader = new TextHeaderFooter {
    CenterText = "Pdf Header", // Text centered at the top of the page
    LeftText = "{date} {time}", // The date and time on the left
    RightText = "{page} of {total-pages}", // Page numbering on the right
    DrawDividerLine = true, // Draws a line under the header
    FontSize = 10 // Set font size to 10
};

// Configure the footer using HTML formatting
pdfRenderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter {
    HtmlFragment = "<span style='text-align:right'> page {page} of {totalpages}</span>", // Right-aligned footer with page numbering
    DrawDividerLine = true, // Include a divider line above the footer
    MaxHeight = 10 // Maximum height of the footer is 10mm
};

// Render an HTML file to a PDF document
PdfDocument pdfDocument = pdfRenderer.RenderHtmlFileAsPdf("test.html");

// Save the generated PDF file
pdfDocument.SaveAs("generatedFile.pdf");

// Set your license key
IronPdf.License.LicenseKey = "YourLicenseKey";

// Load an existing PDF file
PdfDocument pdfDocument = PdfDocument.FromFile("testFile.pdf");

// Update PDF metadata
pdfDocument.MetaData.Author = "john smith";
pdfDocument.MetaData.Keywords = "SEO, Friendly";
pdfDocument.MetaData.ModifiedDate = DateTime.Now;

// Configure security settings to make the PDF read-only and disable copying and printing
// The secret-key acts as the owner password
pdfDocument.SecuritySettings.RemovePasswordsAndEncryption();
pdfDocument.SecuritySettings.MakePdfDocumentReadOnly("secret-key");
pdfDocument.SecuritySettings.AllowUserAnnotations = false;
pdfDocument.SecuritySettings.AllowUserCopyPasteContent = false;
pdfDocument.SecuritySettings.AllowUserFormData = false;
pdfDocument.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.FullPrintRights;

// Set or change the PDF document password
pdfDocument.Password = "123";

// Save the PDF with updated settings
pdfDocument.SaveAs("secured.pdf");

IronPdf.License.LicenseKey = "YourLicenseKey";
PdfDocument pdf = PdfDocument.FromFile("testFile.pdf");
pdf.Sign(new PdfSignature("cert123.pfx", "password"));
pdf.SaveAs("signed.pdf");

IronPdf.License.LicenseKey = "YourLicenseKey";
PdfDocument pdf = PdfDocument.FromFile("testFile.pdf");
IronPdf.Signing.PdfSignature signature = new IronPdf.Signing.PdfSignature("cert123.pfx", "123");

// Optional customization of the signing procedure
signature.SigningContact = "support@ironsoftware.com";
signature.SigningLocation = "Chicago, USA";
signature.SigningReason = "To demonstrate PDF signing";

// Applying the signature to the PDF
pdf.Sign(signature);

// Enter the license key for IronPdf to unlock its features
IronPdf.License.LicenseKey = "YourLicenseKey";

// Load a PDF document from the specified file
PdfDocument document = PdfDocument.FromFile("testFile.pdf");

// Digitally sign the PDF using a specified certificate and password
document.Sign(new PdfSignature("cert123.pfx", "password"));

// Save the signed PDF with a new file name
document.SaveAs("signed.pdf");

IronPdf.License.LicenseKey = "YourLicenseKey";
PdfDocument pdf = PdfDocument.FromFile("testFile.pdf");
IronPdf.Signing.PdfSignature signature = new IronPdf.Signing.PdfSignature("cert123.pfx", "123");

// Setting optional parameters for signing
signature.SigningContact = "support@ironsoftware.com";
signature.SigningLocation = "Chicago, USA";
signature.SigningReason = "To demonstrate the process of signing a PDF";

// Applying the signature to the PDF. You can use multiple signatures if needed
pdf.Sign(signature);

// Assign the license key provided by IronPDF to activate your product
IronPdf.License.LicenseKey = "YourLicenseKey";

// Load an existing PDF document from a specified file path
PdfDocument pdfDocument = PdfDocument.FromFile("testFile.pdf");

// Create a new digital signature using certificate file and password
IronPdf.Signing.PdfSignature digitalSignature = new IronPdf.Signing.PdfSignature("cert123.pfx", "123");

// You can set optional properties for the digital signature
// Specify the contact email for any signature verification inquiries
digitalSignature.SigningContact = "support@ironsoftware.com";
// Indicate the geographic location where the signature was applied
digitalSignature.SigningLocation = "Chicago, USA";
// Assign a purpose or reason for applying the digital signature to the document
digitalSignature.SigningReason = "To show how to sign a PDF";

// Apply the digital signature to the PDF document. This can support multiple signatures.
pdfDocument.Sign(digitalSignature);

IronPdf.License.LicenseKey = "YourLicenseKey";
PdfDocument pdf = PdfDocument.FromFile("testFile.pdf");

// Extract all text content from the PDF
var allText = pdf.ExtractAllText();

// Retrieve text from a specific page
var pageText = pdf.ExtractTextFromPage(0);

// Pull all images from the PDF
var images = pdf.ExtractAllImages();

// Extract images from a specified page
var pageImages = pdf.ExtractImagesFromPage(0);

IronPdf.License.LicenseKey = "YourLicenseKey";
PdfDocument pdf = PdfDocument.FromFile("testFile.pdf");

// Specify the pages to convert to images
List<int> pagesToConvert = new List<int>() { 1, 2 };

// Convert the designated pages into image files
pdf.RasterizeToImageFiles("*.png", pagesToConvert);

IronPdf.License.LicenseKey = "YourLicenseKey";
PdfDocument pdf = PdfDocument.FromFile("testFile.pdf");

// Extract text from the entire PDF
var extractedText = pdf.ExtractAllText();

// Extract text from a specific page in the PDF
var textFromFirstPage = pdf.ExtractTextFromPage(0);

// Retrieve all images from the PDF
var imagesFromPDF = pdf.ExtractAllImages();

// Extract images from a specified page in the PDF
var imagesFromPageOne = pdf.ExtractImagesFromPage(0);

// Assign your IronPDF license key
IronPdf.License.LicenseKey = "YourLicenseKey";

// Load an existing PDF from a file
PdfDocument pdfDoc = PdfDocument.FromFile("testFile.pdf");

// Retrieve all text content from the PDF
pdfDoc.ExtractAllText(); // Fetches text from the entire document
pdfDoc.ExtractTextFromPage(0); // Fetches text from the first page specifically

// Fetch all the images present within the entire PDF document
var ImagesInPdf = pdfDoc.ExtractAllImages();

// Retrieve images from the first page of the PDF
var PageOneImages = pdfDoc.ExtractImagesFromPage(0);

IronPdf.License.LicenseKey = "YourLicenseKey";
PdfDocument pdf = PdfDocument.FromFile("testFile.pdf");

List<int> pagesToConvert = new List<int>() { 1, 2 };

pdf.RasterizeToImageFiles("*.png", pagesToConvert);

// Set your IronPDF license key
IronPdf.License.LicenseKey = "YourLicenseKey";

// Load an existing PDF document into the application
PdfDocument document = PdfDocument.FromFile("testFile.pdf");

// Specify the list of pages that will be converted into images
List<int> pagesToConvert = new List<int>() { 1, 2 };

// Convert the specified pages to PNG images and save them locally
document.RasterizeToImageFiles("*.png", pagesToConvert);

// Initialize IronPDF Chrome Renderer
IronPdf.License.LicenseKey = "YourLicenseKey";
ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderUrlAsPdf("https://www.nuget.org/packages/IronPdf");

// Apply a simple text watermark to every page
pdf.ApplyWatermark("<h2 style='color:red'>SAMPLE</h2>", 30, IronPdf.Editing.VerticalAlignment.Middle, IronPdf.Editing.HorizontalAlignment.Center);
pdf.SaveAs("Watermarked.pdf");

// Prepare a new PDF document with HTML content
IronPdf.License.LicenseKey = "YourLicenseKey";
ChromePdfRenderer htmlRenderer = new ChromePdfRenderer();
PdfDocument htmlPdf = htmlRenderer.RenderHtmlAsPdf("<div>test text </div>");

// Configure and apply an HTML watermark
HtmlStamper watermark = new HtmlStamper()
{
    Html = "<h2 style='color:red'>Copyright 2018 ironpdf.com</h2>",
    MaxWidth = new Length(20),
    MaxHeight = new Length(20),
    Opacity = 50,
    Rotation = -45,
    IsStampBehindContent = true,
    VerticalAlignment = IronPdf.Editing.VerticalAlignment.Middle
};

htmlPdf.ApplyStamp(watermark);
htmlPdf.SaveAs("stamped.pdf");

// Assigning the license key to IronPDF
IronPdf.License.LicenseKey = "YourLicenseKey";

// Initializing the PDF renderer instance, ChromePdfRenderer
ChromePdfRenderer pdfRenderer = new ChromePdfRenderer();

// Generating a PDF from a URL
PdfDocument generatedPdf = pdfRenderer.RenderUrlAsPdf("https://www.nuget.org/packages/IronPdf");

// Adding a watermark to the generated PDF
generatedPdf.ApplyWatermark("<h2 style='color:red'>SAMPLE</h2>", 30, IronPdf.Editing.VerticalAlignment.Middle, IronPdf.Editing.HorizontalAlignment.Center);

// Saving the watermarked PDF to a file named "Watermarked.pdf"
generatedPdf.SaveAs("Watermarked.pdf");

// Assign your license key to activate IronPDF
IronPdf.License.LicenseKey = "YourLicenseKey";

// Initialize a PDF renderer
ChromePdfRenderer pdfRenderer = new ChromePdfRenderer();

// Render a PDF from a simple HTML string
PdfDocument generatedPdf = pdfRenderer.RenderHtmlAsPdf("<div>Sample Text</div>");

// Set up the HTML watermark with custom styling
HtmlStamper watermark = new HtmlStamper()
{
    Html = "<h2 style='color:red'>© 2018 ironpdf.com</h2>",
    MaxWidth = new Length(20), // Width of the watermark
    MaxHeight = new Length(20), // Height of the watermark
    Opacity = 50, // Watermark opacity for transparency
    Rotation = -45, // Angle of rotation for the watermark
    IsStampBehindContent = true, // Place watermark behind the main content
    VerticalAlignment = VerticalAlignment.Middle // Align vertically in the middle
};

// Apply the watermark to the PDF
generatedPdf.ApplyStamp(watermark);

// Save the final PDF with the watermark
generatedPdf.SaveAs("stamped.pdf");