In C# (How It Works For Developers)

Operator Name, Description, Example

For instance, consider the basic arithmetic operations:

• Addition (+): Adds two operands. Example: int x = 5 + 3;
• Subtraction (-): Subtracts the right-hand operand or value from the left-hand operand. Example: int y = x - 2;
• Multiplication (): Multiplies two operands. Example: int z = x y;
• Division (/): Divides the left-hand operand/ variable by the right-hand operand. Example: int d = z / 2;

These are straightforward, with the operands being the values or variables involved in the operation, such as x, y, and z in the examples above.

Numeric Negation

An interesting unary arithmetic operator is numeric negation (-), which reverses the sign of a numeric operand. For example, if we have int x = 5;, then -x would result in -5.

Understanding Operator Precedence with an Example

Consider the following example: int result = 3 + 4 2;. Here, the multiplication operation has higher precedence than addition, so 4 2 is evaluated first, followed by adding 3 to the result, yielding 11.

Example

class Program
{
    static void Main(string[] args)
    {
        int? x = null; // nullable int, initialized to null
        int y = x ?? -1; // using null coalescing operator to provide a default value
        Console.WriteLine("The value of y is: " + y); // outputs: The value of y is: -1
    }
}

class Program
{
    static void Main(string[] args)
    {
        int? x = null; // nullable int, initialized to null
        int y = x ?? -1; // using null coalescing operator to provide a default value
        Console.WriteLine("The value of y is: " + y); // outputs: The value of y is: -1
    }
}

In this example, y would be -1 because x is null. The null coalescing operator simplifies checks for null values, especially when working with nullable types.

Demonstrating Null Coalescing Assignment Expression

int? a = null; // nullable int, initialized to null
a ??= 10; // Assigns 10 to a since it is null

int? a = null; // nullable int, initialized to null
a ??= 10; // Assigns 10 to a since it is null

Here, a would be 10 after the operation because it was initially null. This operator streamlines code by reducing the need for explicit null checks and assignments.

Lambda Declaration Example

Lambda expressions in C# use the lambda operator (=>) to create inline functions. For instance:

Func<int, int, int> add = (x, y) => x + y; // Lambda function to add two integers
int sum = add(5, 3); // Calls the lambda expression with 5 and 3, returns 8

Func<int, int, int> add = (x, y) => x + y; // Lambda function to add two integers
int sum = add(5, 3); // Calls the lambda expression with 5 and 3, returns 8

This code snippet defines a simple function to add two integer values using a lambda expression.

Type Testing with the 'is' Operator

Type testing is performed using the is operator, allowing you to check the type at runtime. For example:

object obj = "Hello World"; // obj is a string
if (obj is string s) {
    Console.WriteLine(s); // Outputs: Hello World
}

object obj = "Hello World"; // obj is a string
if (obj is string s) {
    Console.WriteLine(s); // Outputs: Hello World
}

This checks if obj is of type string and assigns it to s if true.

Installing IronPDF

Before diving into the capabilities of IronPDF, the first step is to integrate the library into your project. IronPDF can be easily added via NuGet, a popular package manager for .NET. By using the NuGet Package Manager, you can include IronPDF in your project with minimal effort.

To install IronPDF, you can use the Package Manager Console command:

Install-Package IronPdf

Alternatively, you can use the NuGet Package Manager UI in Visual Studio by searching for "IronPdf" and installing it directly into your project.

Example: Generating a PDF Document with Arithmetic Operations

Once IronPDF is added to your project, you can start utilizing its features to generate and manipulate PDF documents. Here's a simple example demonstrating how to create a PDF document that includes the result of arithmetic operations, tying back to our discussion on operators.

using IronPdf;

public class PdfGenerationExample
{
    public static void CreatePdfWithArithmeticOperations()
    {
        // Create a new PDF document
        var pdf = new HtmlToPdf();
        // HTML content with embedded C# arithmetic
        var htmlContent = @"
            <html>
                <body>
                    <h1>Arithmetic Operations Result</h1>
                    <p>Result of 3 + 4: " + (3 + 4).ToString() + @"</p>
                    <p>Result of 10 * 2: " + (10 * 2).ToString() + @"</p>
                    <p>Result of 50 / 5: " + (50 / 5).ToString() + @"</p>
                </body>
            </html>";

        // Convert HTML to PDF
        var document = pdf.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to a file
        document.SaveAs("ArithmeticOperations.pdf");
    }
}

using IronPdf;

public class PdfGenerationExample
{
    public static void CreatePdfWithArithmeticOperations()
    {
        // Create a new PDF document
        var pdf = new HtmlToPdf();
        // HTML content with embedded C# arithmetic
        var htmlContent = @"
            <html>
                <body>
                    <h1>Arithmetic Operations Result</h1>
                    <p>Result of 3 + 4: " + (3 + 4).ToString() + @"</p>
                    <p>Result of 10 * 2: " + (10 * 2).ToString() + @"</p>
                    <p>Result of 50 / 5: " + (50 / 5).ToString() + @"</p>
                </body>
            </html>";

        // Convert HTML to PDF
        var document = pdf.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to a file
        document.SaveAs("ArithmeticOperations.pdf");
    }
}

In this example, we create a simple HTML template that includes the results of various arithmetic operations, similar to what we discussed earlier. IronPDF renders this HTML content into a PDF document, showcasing how seamlessly C# code and HTML can be combined to generate dynamic documents.