Lesson 28 - Creating and Calling Simple Helper Methods

Tutorial Series: Free C# Fundamentals via ASP.NET Web Apps

Previous Article  |  Next Article

Get GitHub Code

Up to this point, we have mainly been calling or utilizing built-in helper methods available to us via the .NET framework. However, now you will learn how to define, and call, simple helper methods of your own making. To put it simply, a method is a named block of code that executes, in full, whenever you reference it elsewhere by calling it by name followed by the invocation parentheses. For example, string.Format(), int.Parse(), and random.Next() are just a few of the built-in methods we have already worked with thus far.

Step 1: Creating Helper Methods for Abstraction

There's a few reasons for why you would ever create your own helper method. One reason is simply code reuse; wrapping up a common code block into a named method whenever you see it required in two or more places. This allows you to avoid unnecessary redundant code throughout your program. Another reason is to abstract away complicated code, breaking it up into methods that commit a certain process without requiring you to always to look at the details of that process.


There's an old saying that your code should “read like a story.” In other words, if you have a complex problem that is housed within a single method, it becomes monolithic and difficult to read. However, if you split it up into smaller code blocks - and give each of those code blocks a descriptive name of what that code block is attempting to do - then you can read it out, line-by-line, focusing on what is generally happening, rather than every banal detail of how it’s happening.

Step 2: Create a New Project

It’s often typical for programmers to first tackle a problem by writing all of the code in a single method, not worrying about breaking it up into individual methods right away. Breaking up monolithic code, after-the-fact, is a technique called “refactoring”. You’ll be seeing this in action shortly, but first, start this lesson by creating a new ASP.NET project called “CS-ASP_028” with the following Server Controls and Programmatic IDs:

  1. quantityTextBox

  2. fromCupsRadio

  3. fromPintsRadio

  4. fromQuartsRadio

  5. fromGallonsRadio

  6. resultLabel


Step 3: Enable the AutoPostBack Property

This is going to be a simple application that converts between various measurement formats and displays the results in real-time. Notice that there is no button to PostBack to the server, and that’s because the RadioButtons and TextBoxes should have a property called “AutoPostBack.” Be sure to change this property for each of the Controls mentioned. This will effectively PostBack to the server when each element is changed:


Step 4: Setting the TextChanged Action Event

The event that fires upon PostBack will be the CheckedChanged Action event for the CheckBoxes or the TextChanged for the TextBox:


Make sure to set each Server Control, except resultLabel, with an Action event named accordingly:

  1. quantityTextBox_TextChanged

  2. cupsRadio_CheckedChanged

  3. fromPintsRadio_CheckedChanged

  4. fromQuartsRadio_CheckedChanged

  5. fromGallonsRadio_CheckedChanged

Also, each RadioButton should be set to the same GroupName in the Properties Window:


Step 5: Prelude to Refactoring

Now, what you could do is write out each event/method with minor differences depending on the measurement it’s dealing with. This will create a very obvious pattern, which should be a tip that a helper method might be useful to avoid so much duplicate code:


Step 6: Understanding TryParse()

But before we refactor this, let’s briefly mention some unfamiliar code elements seen in each of these methods. Each method has some validation code to make sure acceptable inputs have been provided by the user. The first if() statement checks to see if quantityTextBox.Text is empty - after it’s been trimmed of whitespace - and exits the method if that is the case. The next if() statement simply checks to see if the value entered is non-numeric and also exits if that is the case.

There are extra elements in this line of code that you will become familiar with shortly. However, for the time being just know that the Double.TryParse() method returns true if it can successfully convert the input to a double, and it also returns the second argument – quantity – converted to a double via the out keyword. And finally, provided that the user-input values pass validation of the previous two if() statements, we perform the calculation and display it though the resultLabel. Now, to consolidate all of this duplicate code, let’s simply take the code common to each of these methods and put it all in its own custom helper method called calculateCups():


The code that’s different for each method is the part that performs particular calculations for each conversion. However, that can also be put into this helper method via a series of if() statements underneath the previous validation code:



Remember that with these if() statements that only perform one operation, there is no need to create a code block to hold the execution code. It would be perfectly fine to do so; but for readability's sake, it is left out in this example.

Now, you can erase all of the previous code in the methods/events, and instead just reference the helper method, by name, in each of those methods/events:


Whenever you reference a method by name followed by the invocation parentheses, it is said that you are calling the method. You are essentially “getting on the phone” and calling the method, asking it to then execute its code block each time you place a call to it.


When you run the application, it will work as it did before:


Step 7: Understanding a Method’s Invocation Parentheses

Be sure to include the invocation parentheses when calling a method that you want to execute, or else you will get an error:



Another common principle in coding is called the “DRY” principle. It stands for “don’t repeat yourself.” Repetition becomes a big problem in your code as the code-base grows larger and requires changes within it. You might imagine a scenario in which end-users are displeased upon you fixing a bug in one part of your application, while the bug persists in another part of your application where the repeated code (along with the repeated bug) may be missed.

Related Articles in this Tutorial:

Lesson 1 - Series Introduction

Lesson 2 - Installing Visual Studio 2015

Lesson 3 - Building Your First Web App

Lesson 4 - Understanding What You Just Did

Lesson 5 - Working with Projects in Visual Studio

Lesson 6 - Simple Web Page Formatting in Visual Studio

Challenge 1

Solution 1

Lesson 7 - Variables and Data Types

Lesson 8 - Data Type Conversion

Lesson 9 - Arithmetic Operators

Lesson 10 - C# Syntax Basics

Challenge 2 - ChallengeSimpleCalculator

Solution - ChallengeSimpleCalculator

Lesson 11 - Conditional If Statements

Lesson 12 - The Conditional Ternary Operator

Challenge 3 - ChallengeConditionalRadioButton

Solution - Challenge Conditional RadioButton

Lesson 13 - Comparison and Logical Operators

Lesson 13 Challenge - First Papa Bob's Website

Solution - Challenge First Papa Bob's Website

Lesson 14 - Working with Dates and Times

Lesson 15 - Working With Spans of Time

Lesson 16 - Working with the Calendar Server Control

Challenge 4 - Challenge Days Between Dates

Solution - Challenge Days Between Dates

Lesson 17 - Page_Load and Page.IsPostBack

Lesson 18 - Setting a Break Point and Debugging

Lesson 19 - Formatting Strings

Challenge 5 - Challenge Epic Spies Assignment

Solution - Challenge Epic Spies Assignment

Lesson 20 - Maintaining State with ViewState

Lesson 21 - Storing Values in Arrays

Lesson 22 - Understanding Multidimensional Arrays

Lesson 23 - Changing the Length of an Array

Challenge 6 - Challenge Epic Spies Asset Tracker

Solution - Challenge Epic Spies Asset Tracker

Lesson 24 - Understanding Variable Scope

Lesson 25 - Code Blocks and Nested If Statements

Lesson 26 - Looping with the For Iteration Statement

Challenge 7 - Challenge For Xmen Battle Count

Solution - Challenge For Xmen Battle Count

Lesson 27 - Looping with the while() & do...while() Iteration Statements

Lesson 28 - Creating and Calling Simple Helper Methods

Lesson 29 - Creating Methods with Input Parameters

Lesson 30 - Returning Values from Methods

Lesson 31 - Creating Overloaded Methods

Lesson 32 - Creating Optional Parameters

Lesson 33 - Creating Names Parameters

Lesson 34 - Creating Methods with Output Parameters

Challenge 8 - Challenge Postal Calculator Helper Methods

Solution - Challenge Postal Calculator Helper Methods

Mega Challenge Casino

Solution - Mega Challenge Casino

Lesson 35 - Manipulating Strings

Challenge 9 - Phun With Strings

Solution - Challenge Phun With Strings

Lesson 36 - Introduction to Classes and Objects

Challenge - Hero Monster Classes Part 1

Solution - Hero Monster Classes Part 1

Challenge - Hero Monster Classes Part 2

Solution - Challenge Hero Monster Classes Part 2

Lesson 37 - Creating Class Files Creating Cohesive Classes and Code Navigation

Lesson 38 - Understanding Object References and Object Lifetime

Lesson 39 - Understanding the .NET Framework and Compilation

Lesson 40 - Namespaces and Using Directives

Lesson 41 - Creating Class Libraries and Adding References to Assemblies

Lesson 42 - Accessibility Modifiers, Fields and Properties

Lesson 43 - Creating Constructor Methods

Lesson 44 - Naming Conventions for Identifiers

Lesson 45 - Static vs Instance Members

Challenge 10 - Challenge Simple Darts

Solution - Challenge Simple Darts

Lesson 46 - Working with the List Collection

Lesson 47 - Object Initializers

Lesson 48 - Collection Initializers

Lesson 49 - Working with the Dictionary Collection

Lesson 50 - Looping with the foreach Iteration Statement

Lesson 51 - Implicitly-Typed Variables with the var Keyword

Challenge 11 - Challenge Student Courses

Solution - Challenge Student Courses

Mega Challenge War

Solution - Mega Challenge War

Lesson 52 - Creating GUIDs

Lesson 53 - Working with Enumerations

Lesson 54 - Understanding the switch() Statement

Lesson 55 - First Pass at the Separation of Concerns Principle

Lesson 56 - Understanding Exception Handling

Lesson 57 - Understanding Global Exception Handling

Lesson 58 - Understanding Custom Exceptions

Lesson 59 - Creating a Database in Visual Studio

Lesson 60 - Creating an Entity Data Model

Lesson 61 - Displaying the DbSet Result in an ASP.NET GridView

Lesson 62 - Implementing a Button Command in a GridView

Lesson 63 - Using a Tools-Centric Approach to Building a Database Application

Lesson 64 - Using a Maintenance-Driven Approach to Building a Database Application

Lesson 65 - Creating a New Instance of an Entity and Persisting it to the Database

Lesson 66 - Package Management with NuGet

Lesson 67 - NuGet No-Commit Workflow

Lesson 68 - Introduction the Twitter Bootstrap CSS Framework

Lesson 69 - Mapping Enum Types to Entity Properties in the Framework Designer

Lesson 70 - Deploying the App to Microsoft Azure Web Services Web Apps

Papa Bob's Mega Challenge

Papa Bob's Mega Solution Part 1 - Setting up the Solution

Papa Bob's Mega Solution Part 2 - Adding an Order to the Database

Papa Bob's Mega Solution Part 3 - Passing an Order from the Presentation Layer

Papa Bob's Mega Solution Part 4 - Creating the Order Form

Papa Bob's Mega Solution Part 5 - Adding Enums

Papa Bob's Mega Solution Part 6 - Creating an Order with Validation

Papa Bob's Mega Solution Part 7 - Calculating the Order Price

Papa Bob's Mega Solution Part 8 - Displaying the Price to the User

Papa Bob's Mega Solution Part 9 - Creating the Order Management Page


Please login or register to add a comment