2. With Parameters, No Return — "Act on Given Data"

static void EmailInvoice(int invoiceId, string email) 
{
    // Send invoice to the given email
    Console.WriteLine($"Invoice {invoiceId} sent to {email}");
}
        

Use For: Commands like sending emails, writing logs, saving records.

Example: Send SMS notification after ticket booking.

Watch For: Failures — consider returning status or throwing exceptions.

3. No Parameters, With Return — "Get a Value From State"

static DateTime GetServerTime() 
{
    return DateTime.UtcNow;
}
        

Use For: Read-only queries like fetching system information.

Example: Get current server time for logging or display purposes.

Watch For: Hidden states or time dependencies — hard to test deterministically.

4. With Parameters, With Return — "Compute From Inputs"

static decimal CalculateGst(decimal amount, decimal rate) 
{
    return amount * rate;
}
        

Use For: Pure calculations, financial formulas, data processing.

Example: Calculate discount price, tax amount, or loan EMI.

Watch For: Input validation for nulls or invalid ranges.

using System;
using System.Linq;
using System.Threading.Tasks;

class Program
{
    static void Welcome() => Console.WriteLine("Welcome to Methods!");
    static void PrintStars(int count) {
        if (count < 0) throw new ArgumentOutOfRangeException(nameof(count));
        Console.WriteLine(new string('*', count));
    }
    static DateTime GetNowUtc() => DateTime.UtcNow;
    static decimal Net(decimal mrp, decimal discount) => mrp - discount;
    static void Increment(ref int x) => x++;
    static bool TryDivide(int a, int b, out int result) {
        if (b == 0) { result = 0; return false; }
        result = a / b; return true;
    }
    static int LengthOf(in string s) => s?.Length ?? 0;
    static int Sum(params int[] numbers) => numbers.Sum();
    static decimal Price(decimal basePrice, decimal tax = 0m, bool roundUp = false) {
        var p = basePrice + tax;
        return roundUp ? Math.Ceiling(p) : p;
    }
    static (int sum, double avg) Stats(params int[] xs) {
        if (xs.Length == 0) return (0, 0);
        var sum = xs.Sum();
        var avg = sum / (double)xs.Length;
        return (sum, avg);
    }
    static async Task FetchCountAsync() {
        await Task.Delay(10);
        return 42;
    }

    static async Task Main() {
        Welcome();
        PrintStars(5);
        Console.WriteLine($"UTC now: {GetNowUtc():u}");
        Console.WriteLine($"Net: {Net(1000m, 125m)}");

        int n = 10;
        Increment(ref n);
        Console.WriteLine($"After Increment: {n}");

        if (TryDivide(10, 2, out int q))
            Console.WriteLine($"10/2 = {q}");

        Console.WriteLine($"LengthOf(\"hello\") = {LengthOf("hello")}");
        Console.WriteLine($"Sum(1..5) = {Sum(1,2,3,4,5)}");

        var rounded = Price(99.2m, tax: 0.8m, roundUp: true);
        Console.WriteLine($"Rounded price = {rounded}");

        var (sum, avg) = Stats(10, 20, 30);
        Console.WriteLine($"sum={sum}, avg={avg}");

        Console.WriteLine($"Async count = {await FetchCountAsync()}");
    }
}

Welcome to Methods!
*****
UTC now: 2025-08-22 10:00:00Z
Net: 875
After Increment: 11
10/2 = 5
LengthOf("hello") = 5
Sum(1..5) = 15
Rounded price = 100
sum=60, avg=20
Async count = 42

This program demonstrates all major method features in C#:

• No params & no return: Welcome() → simple actions.
• Params & no return: PrintStars(count) → commands.
• No params & with return: GetNowUtc() → queries.
• Params & with return: Net(mrp, discount) → pure computations.
• ref / out / in: Pass variables by reference or output results safely.
• params & optional: Flexible argument count & defaults.
• Tuple returns: Return multiple values without custom classes.
• Async methods: Handle asynchronous operations with Task.

Using Visual Studio:

1. Open Visual Studio.
2. Create Console App (.NET Core) project.
3. Paste the code in Program.cs.
4. Press F5 to run → Output appears in the console.

Using Command-line:

1. Save file as AdvancedMethodsDemo.cs.
2. Open Command Prompt / Terminal.
3. Navigate to file directory.
4. Run → csc AdvancedMethodsDemo.cs (compile).
5. Run → AdvancedMethodsDemo (execute).

using System;

namespace School
{
    class Student
    {
        private string name; // private field

        // Property for Name
        public string Name
        {
            get { return name; }
            set
            {
                if (!string.IsNullOrEmpty(value))
                    name = value;
            }
        }

        public void DisplayStudentInfo()
        {
            Console.WriteLine("Student Name: " + Name);
        }
    }

    class Program
    {
        static void Main()
        {
            Student s = new Student();
            s.Name = "Megha";       // using property to set value
            s.DisplayStudentInfo(); // output student name
        }
    }
}

Student Name: Megha
        

This program demonstrates the use of Properties in C# for data encapsulation.

• private string name: Field is private for security.
• public string Name {get; set;}: Property to read/write name safely.
• DisplayStudentInfo(): Prints the student's name.
• Main(): Creates a student object, sets the property, and displays the name.

Advantages:

• No need for separate Get/Set methods.
• Cleaner and more readable code.
• Validation logic can be added inside set.

Using Visual Studio:

1. Open Visual Studio.
2. Create a Console App project.
3. Paste the code into Program.cs.
4. Press F5 to run → Output shows in console.

Using Command-line:

1. Save file as StudentPropertyDemo.cs.
2. Open Command Prompt.
3. Navigate to file folder.
4. Run → csc StudentPropertyDemo.cs
5. Run → StudentPropertyDemo