Methods and reusable logic · Lesson 20 About 85 min with practice

C# Methods and Return Values: Name Work and Reuse Results

A method gives work a name and a clear contract. Learn how calls transfer control, how a returned value differs from printed output, and how to separate a calculation from the code that presents it.

What you will understand

Distinguish a method declaration from a call.
Read a static helper inside an explicit Program and Main structure.
Follow execution into a method and back to its caller.
Choose void for an action or a typed result for a calculation.
Store and reuse returned values instead of assuming output is a result.
Introduce explicit parameters and arguments without hidden caller-local dependencies.
Supply a result on every continuing path of a value-returning method.
Refactor a receipt calculation and display into separate responsibilities.

Give repeated work a name and call it deliberately

A method is a named operation with a body of statements. Its declaration makes the operation available; a call causes it to run. Extracting work into a method lets a reader follow the main flow before inspecting the implementation of every step.

Use names that describe an action or result, such as PrintReceipt or CalculateTotal. A small method should have a clear responsibility. Moving an entire program into a vaguely named helper does not automatically make the design easier to understand.

This lesson uses an explicit class Program with static void Main as the entry point. The helper declarations are ordinary static methods inside the same class. Earlier lessons often used top-level statements; both forms are supported, but you must not add a second competing Main entry point to one example. Each editor here is a complete program.

C# · .NET 10 COMPILER

Program.cs · Declare once and call twice

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        PrintHeading();
        PrintHeading();
    }

    static void PrintHeading()
    {
        Console.WriteLine("Practice report");
    }
}

using System;

class Program
{
    static void Main()
    {
        PrintHeading();
        PrintHeading();
    }

    static void PrintHeading()
    {
        Console.WriteLine("Practice report");
    }
}

Standard input · optional

INPUT BEFORE EXECUTIONProvide all input before selecting Run. Each line is sent to standard input; the stream then ends. This is not an interactive terminal, and input is not automatically echoed in the output. Reset restores the example source and input.

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Practice report
Practice report

The declaration names the reusable work. A call with parentheses runs that work; two calls produce two messages. void says no result value is returned. The explicit Program and Main structure keeps these helpers as ordinary static methods rather than top-level local functions.

C# · .NET 10 COMPILER

Program.cs · A declaration alone does not perform the work

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Only Main ran.");
    }

    static void PrintHeading()
    {
        Console.WriteLine("This helper was called.");
    }
}

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Only Main ran.");
    }

    static void PrintHeading()
    {
        Console.WriteLine("This helper was called.");
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Only Main ran.

PrintHeading exists but is never called, so its message does not appear. A method is an available operation, not a block that automatically runs as the file is read. Call sites determine when its statements are executed.

Read the declaration and follow the call

In static void PrintHeading(), void is the return type, PrintHeading is the name, and the empty parentheses mean this method takes no parameters. Braces contain the statements to run. static lets these examples call the helper without creating a Program object; object and instance behavior are covered later.

Execution begins in Main, enters a helper at a call, then resumes after that call when the helper finishes. The declaration can appear below its caller in the source. File order is not a sequence that automatically executes every method body.

Console.WriteLine is already a method you have used many times. You are now declaring your own operations rather than only calling library methods. Keep the difference between declaration and invocation visible: a name followed by parentheses at a call site invokes the operation.

C# · .NET 10 COMPILER

Program.cs · Follow control into a method and back

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Before call");
        PrintHeading();
        Console.WriteLine("After call");
    }

    static void PrintHeading()
    {
        Console.WriteLine("Inside method");
    }
}

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Before call");
        PrintHeading();
        Console.WriteLine("After call");
    }

    static void PrintHeading()
    {
        Console.WriteLine("Inside method");
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Before call
Inside method
After call

Execution starts in Main, enters PrintHeading at its call, then resumes at the next caller statement after the method finishes. The helper’s physical position below Main is not its execution order. Declaring a method is not a call.

Returning a value and printing a message are different jobs

A return type such as int or decimal promises a result that the caller can use. return expression sends that result back and exits the current method. The caller can assign it to a variable, pass it to another operation or use it in a comparison.

void means the method returns no value. It can still perform work such as printing, but the output is not a result value available for arithmetic. A printed 37.50 cannot be assigned to a decimal merely because its digits look numeric.

Calling a value-returning method does not automatically print or store the result. If you ignore the returned value, it is discarded. Separating a calculation from its display makes the value useful beyond one particular console message.

C# · .NET 10 COMPILER

Program.cs · Store the returned value in the caller

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        int minutes = GetSessionMinutes();
        Console.WriteLine($"Session: {minutes} minutes");
        Console.WriteLine($"Two sessions: {minutes * 2} minutes");
    }

    static int GetSessionMinutes()
    {
        return 25;
    }
}

using System;

class Program
{
    static void Main()
    {
        int minutes = GetSessionMinutes();
        Console.WriteLine($"Session: {minutes} minutes");
        Console.WriteLine($"Two sessions: {minutes * 2} minutes");
    }

    static int GetSessionMinutes()
    {
        return 25;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Session: 25 minutes
Two sessions: 50 minutes

The return type int promises an integer result. return 25 passes that value to the caller, where it is stored and reused. The method does not print anything. Producing a numeric result and displaying a message are different responsibilities.

C# · .NET 10 COMPILER

Program.cs · Returning a value does not automatically print it

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        CalculateSubtotal(12.50m, 3);
        Console.WriteLine("Calculation call finished.");
    }

    static decimal CalculateSubtotal(decimal unitPrice, int quantity)
    {
        return unitPrice * quantity;
    }
}

using System;

class Program
{
    static void Main()
    {
        CalculateSubtotal(12.50m, 3);
        Console.WriteLine("Calculation call finished.");
    }

    static decimal CalculateSubtotal(decimal unitPrice, int quantity)
    {
        return unitPrice * quantity;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Calculation call finished.

The calculation runs, but the returned decimal is ignored. A returned result is not automatically stored, printed or written back into an argument. Use an assignment or put the call inside another appropriate expression when the result matters.

C# · .NET 10 COMPILER

Program.cs · A printed amount is not a returned decimal

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal subtotal = PrintSubtotal(12.50m, 3);
        Console.WriteLine(subtotal);
    }

    static void PrintSubtotal(decimal unitPrice, int quantity)
    {
        Console.WriteLine(unitPrice * quantity);
    }
}

using System;

class Program
{
    static void Main()
    {
        decimal subtotal = PrintSubtotal(12.50m, 3);
        Console.WriteLine(subtotal);
    }

    static void PrintSubtotal(decimal unitPrice, int quantity)
    {
        Console.WriteLine(unitPrice * quantity);
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected behavior · intentional compilation failure

Compilation fails: a void result cannot be assigned to decimal.

PrintSubtotal performs output and returns no value. Its printed digits cannot be assigned as a calculation result. Change the design to return a decimal when the caller needs a decimal; printing more text will not repair this type mismatch.

Pass the values that the calculation needs

Parameters are named, typed inputs in a method declaration. Arguments are the actual values supplied by a call. In CalculateSubtotal(12.50m, 3), the first argument supplies the decimal unit price and the second supplies the integer quantity.

The same method can calculate different results for different calls because its parameter values belong to that invocation. Main’s local variable names do not become visible inside a separate static helper. Pass the needed input rather than depending on a hidden caller local.

This lesson introduces only enough parameter syntax to make reusable calculations practical. The next lesson studies arguments, value passing and reference values in depth. For now, keep types and ordering explicit and document the input assumptions instead of silently inventing validation.

C# · .NET 10 COMPILER

Program.cs · Give a calculation explicit inputs

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal subtotal = CalculateSubtotal(12.50m, 3);
        Console.WriteLine($"Subtotal: {subtotal:F2}");
    }

    static decimal CalculateSubtotal(decimal unitPrice, int quantity)
    {
        return unitPrice * quantity;
    }
}

using System;

class Program
{
    static void Main()
    {
        decimal subtotal = CalculateSubtotal(12.50m, 3);
        Console.WriteLine($"Subtotal: {subtotal:F2}");
    }

    static decimal CalculateSubtotal(decimal unitPrice, int quantity)
    {
        return unitPrice * quantity;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Subtotal: 37.50

unitPrice and quantity are parameters declared by the method. 12.50m and 3 are arguments supplied by this call, in the declared order. This is a small preview of the next parameters lesson. The method assumes a nonnegative price and quantity; it does not validate real commerce input.

C# · .NET 10 COMPILER

Program.cs · Call the same rule with different inputs

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal first = CalculateSubtotal(12.50m, 3);
        decimal second = CalculateSubtotal(8m, 2);
        Console.WriteLine($"First: {first:F2}");
        Console.WriteLine($"Second: {second:F2}");
    }

    static decimal CalculateSubtotal(decimal unitPrice, int quantity)
    {
        return unitPrice * quantity;
    }
}

using System;

class Program
{
    static void Main()
    {
        decimal first = CalculateSubtotal(12.50m, 3);
        decimal second = CalculateSubtotal(8m, 2);
        Console.WriteLine($"First: {first:F2}");
        Console.WriteLine($"Second: {second:F2}");
    }

    static decimal CalculateSubtotal(decimal unitPrice, int quantity)
    {
        return unitPrice * quantity;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

First: 37.50
Second: 16.00

Each call has its own parameter values and its own returned result. Reuse means both calls follow one calculation rule, not that they must produce the same answer. Keep inputs explicit rather than making the helper depend on hidden caller variables.

C# · .NET 10 COMPILER

Program.cs · A helper cannot read a caller’s local by its name

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        int quantity = 3;
        Console.WriteLine(CalculateSubtotal());
    }

    static decimal CalculateSubtotal()
    {
        return 12.50m * quantity;
    }
}

using System;

class Program
{
    static void Main()
    {
        int quantity = 3;
        Console.WriteLine(CalculateSubtotal());
    }

    static decimal CalculateSubtotal()
    {
        return 12.50m * quantity;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected behavior · intentional compilation failure

Compilation fails: quantity is not in scope in this static helper.

quantity belongs to Main. A separate static method does not capture that local variable. Supply the needed value through a parameter. This differs from a non-static local function nested inside a method, which can capture surrounding state; these examples deliberately use ordinary class methods.

A return exits the current method and must fit its contract

A bare return in a void method exits that method early. Its caller can still continue afterward. This is why return inside PrintQuantity behaves differently from a top-level return that ended the whole example run in earlier lessons.

A non-void method must not reach its end without producing the promised result. The compiler checks the definition, including paths not taken by one sample call. Returning in one if branch does not cover the other continuing path.

Give each valid path its meaningful result, or define a deliberate failure policy. The completed delivery helper uses one early return and one final return. The method’s types establish what values can flow, while the written application requirement establishes which result is correct.

C# · .NET 10 COMPILER

Program.cs · Return leaves the helper, not its caller

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        PrintQuantity(0);
        Console.WriteLine("Caller continues.");
    }

    static void PrintQuantity(int quantity)
    {
        if (quantity <= 0)
        {
            Console.WriteLine("Quantity must be positive.");
            return;
        }
        Console.WriteLine($"Quantity: {quantity}");
    }
}

using System;

class Program
{
    static void Main()
    {
        PrintQuantity(0);
        Console.WriteLine("Caller continues.");
    }

    static void PrintQuantity(int quantity)
    {
        if (quantity <= 0)
        {
            Console.WriteLine("Quantity must be positive.");
            return;
        }
        Console.WriteLine($"Quantity: {quantity}");
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Quantity must be positive.
Caller continues.

The bare return ends PrintQuantity, then Main resumes after its call. It does not end Main. In a top-level program a return in the entry point ended the run; the scope of return is always the current method, not every caller above it.

C# · .NET 10 COMPILER

Program.cs · A value-returning method needs a result on each continuing path

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(GetDeliveryFee(25m));
    }

    static decimal GetDeliveryFee(decimal subtotal)
    {
        if (subtotal >= 50m)
        {
            return 0m;
        }
    }
}

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(GetDeliveryFee(25m));
    }

    static decimal GetDeliveryFee(decimal subtotal)
    {
        if (subtotal >= 50m)
        {
            return 0m;
        }
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected behavior · intentional compilation failure

Compilation fails: not all code paths return a value.

A subtotal below fifty reaches the end without producing the promised decimal. The compiler rejects this definition. Add the meaningful other result or design a deliberate failure path; do not invent an unrelated zero merely to satisfy the return type.

C# · .NET 10 COMPILER

Program.cs · Return a result from each valid branch

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine($"Small order: {GetDeliveryFee(25m):F2}");
        Console.WriteLine($"Threshold order: {GetDeliveryFee(50m):F2}");
    }

    static decimal GetDeliveryFee(decimal subtotal)
    {
        if (subtotal >= 50m)
        {
            return 0m;
        }
        return 5m;
    }
}

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine($"Small order: {GetDeliveryFee(25m):F2}");
        Console.WriteLine($"Threshold order: {GetDeliveryFee(50m):F2}");
    }

    static decimal GetDeliveryFee(decimal subtotal)
    {
        if (subtotal >= 50m)
        {
            return 0m;
        }
        return 5m;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Small order: 5.00
Threshold order: 0.00

The first return exits immediately when the threshold is met; the final return supplies the other case. No else is required after a branch that already returns. This illustrative fee rule assumes a nonnegative subtotal and is distinct from earlier three-band delivery exercises.

Keep computation separate from presentation

A calculation that returns a number can be tested against several inputs without parsing console output. A printing method can receive that number and choose labels and formatting. This separation prevents a presentation change from unnecessarily changing the calculation.

Names are not proof of correctness. A method called CalculateTotal can still multiply a delivery amount by a unit price. Verify the formula, units and assumptions inside the body. Refactoring should preserve behavior when intended and make any deliberate bug fix explicit.

A method boundary is not automatically a validation or security boundary. These examples assume fixed nonnegative inputs that fit decimal. A real purchase flow would need authoritative validation, persistence and provider integration; the practice receipt only prints a report.

Test the returned result and the caller’s use of it

For a calculation, choose a normal input, zero where the domain permits it, and another quantity or charge that changes the expected result. Check the numeric returned amount separately from its formatted representation. Two display digits do not define a complete currency-rounding policy.

For control flow, check that an early helper return still reaches the caller’s next statement. For structure, check that declarations are not mistaken for calls and that no required result is discarded. Three intentional compiler failures in this lesson expose void assignment, missing return paths and local scope.

In the lab, Main should read like a short description: calculate the total, then print the receipt. Keep one copy of the formula in the calculation helper. The display method should accept its result rather than reaching backward for the original price and quantity.

Guided repair: return the intended total

CalculateTotal returns 87.50 instead of 41.50 because it treats a delivery amount as part of the item count. Repair the numeric formula while keeping calculation free of console output.

C# · .NET 10 COMPILER

Program.cs · A delivery charge is not another item count

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal total = CalculateTotal(12.50m, 3, 4m);
        Console.WriteLine($"Total: {total:F2}");
    }

    static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery)
    {
        return unitPrice * (quantity + delivery);
    }
}

using System;

class Program
{
    static void Main()
    {
        decimal total = CalculateTotal(12.50m, 3, 4m);
        Console.WriteLine($"Total: {total:F2}");
    }

    static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery)
    {
        return unitPrice * (quantity + delivery);
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Total: 87.50

The method returns a decimal successfully but computes the wrong formula. It treats the delivery amount as part of a count before multiplication. A method name and return type do not prove that the calculation matches the requirement.

Repair checkpoints

Calculate unitPrice * quantity as the subtotal.
Add delivery once after multiplication.
Return the decimal total and leave formatting to Main.
12.50m, 3 and 4m must return 41.50m.
With quantity 0, expect the delivery amount under this exercise’s stated formula; that does not establish an accepted zero-item order.

Reveal the repair and explanation

C# · .NET 10 COMPILER

Program.cs · Return the calculation and let the caller display it

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal total = CalculateTotal(12.50m, 3, 4m);
        Console.WriteLine($"Total: {total:F2}");
    }

    static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery)
    {
        decimal subtotal = unitPrice * quantity;
        return subtotal + delivery;
    }
}

using System;

class Program
{
    static void Main()
    {
        decimal total = CalculateTotal(12.50m, 3, 4m);
        Console.WriteLine($"Total: {total:F2}");
    }

    static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery)
    {
        decimal subtotal = unitPrice * quantity;
        return subtotal + delivery;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Total: 41.50

CalculateTotal produces a numeric amount using named intermediate work and no console output. Main decides the display format. The same numeric result could later be compared or combined without parsing a printed message. The fixed inputs are nonnegative and within decimal range.

Independent lab: separate a receipt calculation and display

Refactor the correct practice receipt into two helpers. One method calculates and returns the numeric total; another prints the already-calculated result. Main should only connect those steps.

Acceptance checklist

Declare static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery).
Keep the subtotal and total formula in that method and return the result.
Declare static void PrintReceipt(decimal total) for the two output lines.
Have Main store CalculateTotal(12.50m, 3, 4m), then pass the result to PrintReceipt.
Preserve Practice receipt and Total: 41.50 output for the reference inputs.
Do not duplicate the price formula in PrintReceipt or print inside CalculateTotal.
Assume nonnegative inputs within decimal range; this is a report rather than a payment or saved order.

C# · .NET 10 COMPILER

Program.cs · Receipt refactoring starter

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal unitPrice = 12.50m;
        int quantity = 3;
        decimal delivery = 4m;
        decimal total = unitPrice * quantity + delivery;
        Console.WriteLine("Practice receipt");
        Console.WriteLine($"Total: {total:F2}");
    }

    // Extract the calculation and display into named methods.
}

using System;

class Program
{
    static void Main()
    {
        decimal unitPrice = 12.50m;
        int quantity = 3;
        decimal delivery = 4m;
        decimal total = unitPrice * quantity + delivery;
        Console.WriteLine("Practice receipt");
        Console.WriteLine($"Total: {total:F2}");
    }

    // Extract the calculation and display into named methods.
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Practice receipt
Total: 41.50

The reference arithmetic is correct, but calculation and presentation are combined in Main. Refactor while preserving behavior. The lab asks for one returned calculation result and a separate void display operation rather than duplicating the formula inside printing code.

Show hints

The calculation returns decimal; the printer returns void.
A parameter lets the printer receive a result without accessing Main’s local variables.
Keep all helper declarations inside Program and outside Main.

Reveal the reference solution

C# · .NET 10 COMPILER

Program.cs · Receipt reference solution

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal total = CalculateTotal(12.50m, 3, 4m);
        PrintReceipt(total);
    }

    static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery)
    {
        decimal subtotal = unitPrice * quantity;
        return subtotal + delivery;
    }
    
    static void PrintReceipt(decimal total)
    {
        Console.WriteLine("Practice receipt");
        Console.WriteLine($"Total: {total:F2}");
    }
}

using System;

class Program
{
    static void Main()
    {
        decimal total = CalculateTotal(12.50m, 3, 4m);
        PrintReceipt(total);
    }

    static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery)
    {
        decimal subtotal = unitPrice * quantity;
        return subtotal + delivery;
    }
    
    static void PrintReceipt(decimal total)
    {
        Console.WriteLine("Practice receipt");
        Console.WriteLine($"Total: {total:F2}");
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Practice receipt
Total: 41.50

Main states the two steps, CalculateTotal returns the numeric result, and PrintReceipt formats it. The calculation contains no output and the printer contains no duplicate price formula. A printed practice receipt is not a saved order, a charge or an email.

Changed-input checks

8m, 2 and 0m produce total 16.00.
0.10m, 3 and 0m produce total 0.30.
12.50m, 0 and 4m produce 4.00 under the fixed formula.
Changing the receipt label should not change the numeric formula.
Calling CalculateTotal twice with different inputs must not overwrite the earlier stored result.

Recap: read the operation’s contract

Identify the inputs, returned result or action, and where control resumes. Keep the numeric calculation separate from the presentation that uses it.

method declaration: Define the named operation and its body; it does not invoke itself.
MethodName(arguments): Call the operation with the required supplied values.
void: No returned value; the method can still perform an action such as output.
decimal / int return type: Promise a compatible numeric result to the caller.
return expression;: Return a value and exit the current method.
return; in void: Exit this helper early while its caller can continue.
parameters / arguments: Declared input names and types versus values supplied by a call.
calculation then presentation: Return the numeric result, then format it in a separate operation.

Frequently asked questions

Does declaring a method run its body?

No. Its body executes when it is called. Main is the entry point invoked when the program starts.

Is a printed number the same as a returned number?

No. Printing writes a message; returning supplies a typed value to a caller. A calculation often needs the latter so its result can be reused.

Why use static in these examples?

The helpers can be called from static Main without creating a Program object. Instance methods and object state are covered in later lessons.

Can I omit return from a value-returning method?

It cannot reach its end without producing its promised value. Define every continuing path; void methods can simply finish without an explicit return.

Can a helper read a local variable from Main?

A separate ordinary static method cannot access that local by name. Pass the needed value as a parameter. Nested local functions have different capture rules.

Does return in a helper end the whole program?

It exits that helper. The caller resumes after the call unless another control transfer or failure prevents it.

Next step and references

Methods name work and make inputs and results explicit. A call transfers control to a body and back, while a returned value remains separate from printed output. Test the formula, every return path and the caller’s use of the result.

Next is C# Method Parameters and Arguments. You will examine how supplied values reach a method, how value passing and references behave, and when named or optional arguments clarify a call.

Official references

Original SovranCode explanations, examples and exercises. Technical details were checked against these references.

Last updated: 27 October 2026.

Methods and reusable logic · Lesson 20 About 85 min with practice

C# Methods and Return Values: Name Work and Reuse Results

A method gives work a name and a clear contract. Learn how calls transfer control, how a returned value differs from printed output, and how to separate a calculation from the code that presents it.

What you will understand

Distinguish a method declaration from a call.
Read a static helper inside an explicit Program and Main structure.
Follow execution into a method and back to its caller.
Choose void for an action or a typed result for a calculation.
Store and reuse returned values instead of assuming output is a result.
Introduce explicit parameters and arguments without hidden caller-local dependencies.
Supply a result on every continuing path of a value-returning method.
Refactor a receipt calculation and display into separate responsibilities.

Give repeated work a name and call it deliberately

C# · .NET 10 COMPILER

Program.cs · Declare once and call twice

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        PrintHeading();
        PrintHeading();
    }

    static void PrintHeading()
    {
        Console.WriteLine("Practice report");
    }
}

using System;

class Program
{
    static void Main()
    {
        PrintHeading();
        PrintHeading();
    }

    static void PrintHeading()
    {
        Console.WriteLine("Practice report");
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Practice report
Practice report

C# · .NET 10 COMPILER

Program.cs · A declaration alone does not perform the work

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Only Main ran.");
    }

    static void PrintHeading()
    {
        Console.WriteLine("This helper was called.");
    }
}

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Only Main ran.");
    }

    static void PrintHeading()
    {
        Console.WriteLine("This helper was called.");
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Only Main ran.

Read the declaration and follow the call

C# · .NET 10 COMPILER

Program.cs · Follow control into a method and back

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Before call");
        PrintHeading();
        Console.WriteLine("After call");
    }

    static void PrintHeading()
    {
        Console.WriteLine("Inside method");
    }
}

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Before call");
        PrintHeading();
        Console.WriteLine("After call");
    }

    static void PrintHeading()
    {
        Console.WriteLine("Inside method");
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Before call
Inside method
After call

Returning a value and printing a message are different jobs

C# · .NET 10 COMPILER

Program.cs · Store the returned value in the caller

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        int minutes = GetSessionMinutes();
        Console.WriteLine($"Session: {minutes} minutes");
        Console.WriteLine($"Two sessions: {minutes * 2} minutes");
    }

    static int GetSessionMinutes()
    {
        return 25;
    }
}

using System;

class Program
{
    static void Main()
    {
        int minutes = GetSessionMinutes();
        Console.WriteLine($"Session: {minutes} minutes");
        Console.WriteLine($"Two sessions: {minutes * 2} minutes");
    }

    static int GetSessionMinutes()
    {
        return 25;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Session: 25 minutes
Two sessions: 50 minutes

C# · .NET 10 COMPILER

Program.cs · Returning a value does not automatically print it

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        CalculateSubtotal(12.50m, 3);
        Console.WriteLine("Calculation call finished.");
    }

    static decimal CalculateSubtotal(decimal unitPrice, int quantity)
    {
        return unitPrice * quantity;
    }
}

using System;

class Program
{
    static void Main()
    {
        CalculateSubtotal(12.50m, 3);
        Console.WriteLine("Calculation call finished.");
    }

    static decimal CalculateSubtotal(decimal unitPrice, int quantity)
    {
        return unitPrice * quantity;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Calculation call finished.

C# · .NET 10 COMPILER

Program.cs · A printed amount is not a returned decimal

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal subtotal = PrintSubtotal(12.50m, 3);
        Console.WriteLine(subtotal);
    }

    static void PrintSubtotal(decimal unitPrice, int quantity)
    {
        Console.WriteLine(unitPrice * quantity);
    }
}

using System;

class Program
{
    static void Main()
    {
        decimal subtotal = PrintSubtotal(12.50m, 3);
        Console.WriteLine(subtotal);
    }

    static void PrintSubtotal(decimal unitPrice, int quantity)
    {
        Console.WriteLine(unitPrice * quantity);
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected behavior · intentional compilation failure

Compilation fails: a void result cannot be assigned to decimal.

Pass the values that the calculation needs

C# · .NET 10 COMPILER

Program.cs · Give a calculation explicit inputs

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal subtotal = CalculateSubtotal(12.50m, 3);
        Console.WriteLine($"Subtotal: {subtotal:F2}");
    }

    static decimal CalculateSubtotal(decimal unitPrice, int quantity)
    {
        return unitPrice * quantity;
    }
}

using System;

class Program
{
    static void Main()
    {
        decimal subtotal = CalculateSubtotal(12.50m, 3);
        Console.WriteLine($"Subtotal: {subtotal:F2}");
    }

    static decimal CalculateSubtotal(decimal unitPrice, int quantity)
    {
        return unitPrice * quantity;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Subtotal: 37.50

C# · .NET 10 COMPILER

Program.cs · Call the same rule with different inputs

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal first = CalculateSubtotal(12.50m, 3);
        decimal second = CalculateSubtotal(8m, 2);
        Console.WriteLine($"First: {first:F2}");
        Console.WriteLine($"Second: {second:F2}");
    }

    static decimal CalculateSubtotal(decimal unitPrice, int quantity)
    {
        return unitPrice * quantity;
    }
}

using System;

class Program
{
    static void Main()
    {
        decimal first = CalculateSubtotal(12.50m, 3);
        decimal second = CalculateSubtotal(8m, 2);
        Console.WriteLine($"First: {first:F2}");
        Console.WriteLine($"Second: {second:F2}");
    }

    static decimal CalculateSubtotal(decimal unitPrice, int quantity)
    {
        return unitPrice * quantity;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

First: 37.50
Second: 16.00

C# · .NET 10 COMPILER

Program.cs · A helper cannot read a caller’s local by its name

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        int quantity = 3;
        Console.WriteLine(CalculateSubtotal());
    }

    static decimal CalculateSubtotal()
    {
        return 12.50m * quantity;
    }
}

using System;

class Program
{
    static void Main()
    {
        int quantity = 3;
        Console.WriteLine(CalculateSubtotal());
    }

    static decimal CalculateSubtotal()
    {
        return 12.50m * quantity;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected behavior · intentional compilation failure

Compilation fails: quantity is not in scope in this static helper.

A return exits the current method and must fit its contract

C# · .NET 10 COMPILER

Program.cs · Return leaves the helper, not its caller

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        PrintQuantity(0);
        Console.WriteLine("Caller continues.");
    }

    static void PrintQuantity(int quantity)
    {
        if (quantity <= 0)
        {
            Console.WriteLine("Quantity must be positive.");
            return;
        }
        Console.WriteLine($"Quantity: {quantity}");
    }
}

using System;

class Program
{
    static void Main()
    {
        PrintQuantity(0);
        Console.WriteLine("Caller continues.");
    }

    static void PrintQuantity(int quantity)
    {
        if (quantity <= 0)
        {
            Console.WriteLine("Quantity must be positive.");
            return;
        }
        Console.WriteLine($"Quantity: {quantity}");
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Quantity must be positive.
Caller continues.

C# · .NET 10 COMPILER

Program.cs · A value-returning method needs a result on each continuing path

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(GetDeliveryFee(25m));
    }

    static decimal GetDeliveryFee(decimal subtotal)
    {
        if (subtotal >= 50m)
        {
            return 0m;
        }
    }
}

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(GetDeliveryFee(25m));
    }

    static decimal GetDeliveryFee(decimal subtotal)
    {
        if (subtotal >= 50m)
        {
            return 0m;
        }
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected behavior · intentional compilation failure

Compilation fails: not all code paths return a value.

C# · .NET 10 COMPILER

Program.cs · Return a result from each valid branch

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine($"Small order: {GetDeliveryFee(25m):F2}");
        Console.WriteLine($"Threshold order: {GetDeliveryFee(50m):F2}");
    }

    static decimal GetDeliveryFee(decimal subtotal)
    {
        if (subtotal >= 50m)
        {
            return 0m;
        }
        return 5m;
    }
}

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine($"Small order: {GetDeliveryFee(25m):F2}");
        Console.WriteLine($"Threshold order: {GetDeliveryFee(50m):F2}");
    }

    static decimal GetDeliveryFee(decimal subtotal)
    {
        if (subtotal >= 50m)
        {
            return 0m;
        }
        return 5m;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Small order: 5.00
Threshold order: 0.00

Keep computation separate from presentation

Test the returned result and the caller’s use of it

Guided repair: return the intended total

CalculateTotal returns 87.50 instead of 41.50 because it treats a delivery amount as part of the item count. Repair the numeric formula while keeping calculation free of console output.

C# · .NET 10 COMPILER

Program.cs · A delivery charge is not another item count

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal total = CalculateTotal(12.50m, 3, 4m);
        Console.WriteLine($"Total: {total:F2}");
    }

    static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery)
    {
        return unitPrice * (quantity + delivery);
    }
}

using System;

class Program
{
    static void Main()
    {
        decimal total = CalculateTotal(12.50m, 3, 4m);
        Console.WriteLine($"Total: {total:F2}");
    }

    static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery)
    {
        return unitPrice * (quantity + delivery);
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Total: 87.50

Repair checkpoints

Calculate unitPrice * quantity as the subtotal.
Add delivery once after multiplication.
Return the decimal total and leave formatting to Main.
12.50m, 3 and 4m must return 41.50m.
With quantity 0, expect the delivery amount under this exercise’s stated formula; that does not establish an accepted zero-item order.

Reveal the repair and explanation

C# · .NET 10 COMPILER

Program.cs · Return the calculation and let the caller display it

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal total = CalculateTotal(12.50m, 3, 4m);
        Console.WriteLine($"Total: {total:F2}");
    }

    static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery)
    {
        decimal subtotal = unitPrice * quantity;
        return subtotal + delivery;
    }
}

using System;

class Program
{
    static void Main()
    {
        decimal total = CalculateTotal(12.50m, 3, 4m);
        Console.WriteLine($"Total: {total:F2}");
    }

    static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery)
    {
        decimal subtotal = unitPrice * quantity;
        return subtotal + delivery;
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Total: 41.50

Independent lab: separate a receipt calculation and display

Refactor the correct practice receipt into two helpers. One method calculates and returns the numeric total; another prints the already-calculated result. Main should only connect those steps.

Acceptance checklist

Declare static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery).
Keep the subtotal and total formula in that method and return the result.
Declare static void PrintReceipt(decimal total) for the two output lines.
Have Main store CalculateTotal(12.50m, 3, 4m), then pass the result to PrintReceipt.
Preserve Practice receipt and Total: 41.50 output for the reference inputs.
Do not duplicate the price formula in PrintReceipt or print inside CalculateTotal.
Assume nonnegative inputs within decimal range; this is a report rather than a payment or saved order.

C# · .NET 10 COMPILER

Program.cs · Receipt refactoring starter

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal unitPrice = 12.50m;
        int quantity = 3;
        decimal delivery = 4m;
        decimal total = unitPrice * quantity + delivery;
        Console.WriteLine("Practice receipt");
        Console.WriteLine($"Total: {total:F2}");
    }

    // Extract the calculation and display into named methods.
}

using System;

class Program
{
    static void Main()
    {
        decimal unitPrice = 12.50m;
        int quantity = 3;
        decimal delivery = 4m;
        decimal total = unitPrice * quantity + delivery;
        Console.WriteLine("Practice receipt");
        Console.WriteLine($"Total: {total:F2}");
    }

    // Extract the calculation and display into named methods.
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Practice receipt
Total: 41.50

Show hints

The calculation returns decimal; the printer returns void.
A parameter lets the printer receive a result without accessing Main’s local variables.
Keep all helper declarations inside Program and outside Main.

Reveal the reference solution

C# · .NET 10 COMPILER

Program.cs · Receipt reference solution

Predict the result, edit Program.cs, then run your program.

using System;

class Program
{
    static void Main()
    {
        decimal total = CalculateTotal(12.50m, 3, 4m);
        PrintReceipt(total);
    }

    static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery)
    {
        decimal subtotal = unitPrice * quantity;
        return subtotal + delivery;
    }
    
    static void PrintReceipt(decimal total)
    {
        Console.WriteLine("Practice receipt");
        Console.WriteLine($"Total: {total:F2}");
    }
}

using System;

class Program
{
    static void Main()
    {
        decimal total = CalculateTotal(12.50m, 3, 4m);
        PrintReceipt(total);
    }

    static decimal CalculateTotal(decimal unitPrice, int quantity, decimal delivery)
    {
        decimal subtotal = unitPrice * quantity;
        return subtotal + delivery;
    }
    
    static void PrintReceipt(decimal total)
    {
        Console.WriteLine("Practice receipt");
        Console.WriteLine($"Total: {total:F2}");
    }
}

Standard input · optional

TERMINAL OUTPUT

Select Run code to compile and execute this program.

Expected output · follow the call and result

Practice receipt
Total: 41.50

Changed-input checks

8m, 2 and 0m produce total 16.00.
0.10m, 3 and 0m produce total 0.30.
12.50m, 0 and 4m produce 4.00 under the fixed formula.
Changing the receipt label should not change the numeric formula.
Calling CalculateTotal twice with different inputs must not overwrite the earlier stored result.

Recap: read the operation’s contract

Identify the inputs, returned result or action, and where control resumes. Keep the numeric calculation separate from the presentation that uses it.

method declaration: Define the named operation and its body; it does not invoke itself.
MethodName(arguments): Call the operation with the required supplied values.
void: No returned value; the method can still perform an action such as output.
decimal / int return type: Promise a compatible numeric result to the caller.
return expression;: Return a value and exit the current method.
return; in void: Exit this helper early while its caller can continue.
parameters / arguments: Declared input names and types versus values supplied by a call.
calculation then presentation: Return the numeric result, then format it in a separate operation.

Frequently asked questions

Does declaring a method run its body?

No. Its body executes when it is called. Main is the entry point invoked when the program starts.

Is a printed number the same as a returned number?

No. Printing writes a message; returning supplies a typed value to a caller. A calculation often needs the latter so its result can be reused.

Why use static in these examples?

The helpers can be called from static Main without creating a Program object. Instance methods and object state are covered in later lessons.

Can I omit return from a value-returning method?

It cannot reach its end without producing its promised value. Define every continuing path; void methods can simply finish without an explicit return.

Can a helper read a local variable from Main?

A separate ordinary static method cannot access that local by name. Pass the needed value as a parameter. Nested local functions have different capture rules.

Does return in a helper end the whole program?

It exits that helper. The caller resumes after the call unless another control transfer or failure prevents it.

Next step and references

Next is C# Method Parameters and Arguments. You will examine how supplied values reach a method, how value passing and references behave, and when named or optional arguments clarify a call.

Official references

Original SovranCode explanations, examples and exercises. Technical details were checked against these references.

Last updated: 27 October 2026.

Your first C# program

Values, expressions, and input

Decisions, repetition, and arrays

Methods and reusable logic

Classes, objects, and initialization

Encapsulation and reusable design

Named states, files, and failures

C# Methods and Return Values: Name Work and Reuse Results

What you will understand

Give repeated work a name and call it deliberately

Read the declaration and follow the call

Returning a value and printing a message are different jobs

Pass the values that the calculation needs

A return exits the current method and must fit its contract

Keep computation separate from presentation

Test the returned result and the caller’s use of it

Guided repair: return the intended total

Repair checkpoints

Independent lab: separate a receipt calculation and display

Acceptance checklist

Changed-input checks

Recap: read the operation’s contract

Frequently asked questions

Next step and references

Official references

Your first C# program

Values, expressions, and input

Decisions, repetition, and arrays

Methods and reusable logic

Classes, objects, and initialization

Encapsulation and reusable design

Named states, files, and failures

C# Methods and Return Values: Name Work and Reuse Results

What you will understand

Give repeated work a name and call it deliberately

Read the declaration and follow the call

Returning a value and printing a message are different jobs

Pass the values that the calculation needs

A return exits the current method and must fit its contract

Keep computation separate from presentation

Test the returned result and the caller’s use of it

Guided repair: return the intended total

Repair checkpoints

Independent lab: separate a receipt calculation and display

Acceptance checklist

Changed-input checks

Recap: read the operation’s contract

Frequently asked questions

Next step and references

Official references