Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.

Preview

Start a free Basic trial
to watch this video

Sign up for Treehouse

Defining methods

4:14 with Jay McGavren

You've learned how to call methods written by others. Now let's learn how to write your own!

Here I have another C# program. The first three lines of the Main method display a message that we're waiting, pause for 3 seconds, and print another message that we're done waiting. The next three lines count from 1 to 3.

These are two separate tasks in the same program, but it's hard to tell at a glance which lines belong to which task, or what task they're supposed to be doing.

using System;
using System.Threading;

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Waiting...");
        Thread.Sleep(3000);
        Console.WriteLine("Done");
        Console.WriteLine(1);
        Console.WriteLine(2);
        Console.WriteLine(3);
    }
}
  • static keyword means you can call the method all by itself; it doesn't belong to an object.
    • GetType() is an example of a method you can only call on an object.
    • Have to place a dot operator after an object, then call the method: 42.GetType();
    • On the other hand, Console.WriteLine() is an example of a static method; a method you can call all by itself:
    • WriteLine takes arguments in parentheses, but you don't have to refer to an object, add a dot operator, and then call the method.
  • void means no return value; we'll talk about return values shortly
static void Wait()
{
}

static void CountToThree()
{
}
  • Method body in curly braces: one or more lines of code that will be run when method is called
    • Lines of method body are usually indented to make it clear they're a part of the method, although this isn't required
static void Wait()
{
    Console.WriteLine("Waiting...");
    Thread.Sleep(3000);
    Console.WriteLine("Done");
}
  • Calling methods
    • Method name followed by parentheses
    • End statement with semicolon, as always
using System;
using System.Threading;

class Program
{

    static void Wait()
    {
        Console.WriteLine("Waiting...");
        Thread.Sleep(3000);
        Console.WriteLine("Done");
    }

    static void CountToThree()
    {
        Console.WriteLine(1);
        Console.WriteLine(2);
        Console.WriteLine(3);
    }

    static void Main(string[] args)
    {
        Wait();
        CountToThree();
    }

}

The rules regarding the names you can use with a C# method are similar to the rules for naming variables.

  • Unlike variables, though, the first letter of the name should be capitalized.
  • As with variables, you should use camel case if there are multiple words. So every word after the first should be capitalized as well.
  • And of course, you can't use C# keywords, and there should be no spaces in the method name.

OK:

  • Average
  • CalculateTax

Not OK:

  • average
  • Calculatetax
  • 0:00

    Here I have another C# program.

  • 0:02

    The first three lines of the main method display a message that we're waiting,

  • 0:06

    pause for three seconds, and print another message that we're done waiting.

  • 0:10

    The next three lines count from 1 to 3.

  • 0:13

    These are two separate tasks in the same program.

  • 0:16

    But it's hard to tell at a glance which lines belong to which task, or

  • 0:20

    what task they're supposed to be doing.

  • 0:22

    So let's define a couple new methods to hold some of this code.

  • 0:26

    I'll start by writing a method to hold the code that sleeps for three seconds.

  • 0:32

    The static keyword here at the start means you can call this method all by itself.

  • 0:36

    It doesn't belong to an object.

  • 0:40

    GetType is an example of a method you can only call on an object.

  • 0:43

    You have to place a dot operator after an object and then call the method.

  • 0:48

    So we take this 42 object and then call the GetType method on it.

  • 0:53

    On the other hand, Console.WriteLine is an example of a static method.

  • 0:58

    It is a method you can call all by itself.

  • 1:00

    WriteLine takes arguments in parentheses, but

  • 1:02

    you don't have to refer to an object, add a dot operator, and then call the method.

  • 1:08

    Up next is the void keyword.

  • 1:10

    Void means there is no return value.

  • 1:11

    We'll talk about return values shortly.

  • 1:14

    And then we write the name that we want for the method and a pair of parentheses.

  • 1:19

    The method body goes here between the curly braces.

  • 1:22

    It's one or more lines of code that will be run when the method is called.

  • 1:26

    For this method,

  • 1:27

    we're just going to cut the first three lines from the main function.

  • 1:31

    Here on my Mac system, I can hold the Cmd key and press X to cut.

  • 1:36

    On another system, you might press Ctrl+X.

  • 1:39

    Then I'll paste those three lines of code here in the wait method.

  • 1:44

    Now, if I were to save this, and run this as is,

  • 1:47

    our wait method code wouldn't be called at all.

  • 1:50

    So let me try and type in dotnet run here.

  • 1:53

    And you can see that only our lines that print 1, 2, and 3 are run.

  • 1:56

    For the code in wait to be run, we have to actually call it.

  • 2:00

    We do that by writing our method name, wait, followed by parentheses.

  • 2:05

    And of course, every statement has to end with a semicolon.

  • 2:08

    Let me try saving this, and we'll run it again.

  • 2:13

    And this time,

  • 2:14

    you can see that our wait code gets run before the code that prints 1, 2, 3.

  • 2:18

    So the main method gets run when the program starts, but

  • 2:21

    that's the only method that gets called automatically.

  • 2:24

    For any other method you want to run, you have to call it.

  • 2:29

    Now let me move those lines that print 1, 2, and 3 to a method of their own.

  • 2:33

    I'll start the definition with static void as before, and

  • 2:36

    I'll name the method CountToThree.

  • 2:38

    Notice that I type both my opening and my closing curly braces.

  • 2:41

    You don't have to do this, but it's a good habit to get into so

  • 2:44

    that you never forget your closing curly brace.

  • 2:47

    Just go back and fill in the method body later, when you're ready.

  • 2:52

    Now, let me go down to my main method.

  • 2:53

    And again, I'll cut the lines that print 1, 2, and 3.

  • 2:57

    And I'll move them to the CountToThree method body.

  • 3:00

    Let me save that.

  • 3:01

    And once again, if I go down here to dotnet run,

  • 3:08

    We'll see that this time only the wait method is called.

  • 3:13

    Again, we have to go into our main method and

  • 3:15

    make a call to the CountToThree method.

  • 3:20

    CountToThree.

  • 3:25

    And now, if I run this, it'll wait at the start and then it'll count to three again.

  • 3:33

    You can call methods from other methods.

  • 3:36

    So for example, up here in the wait method,

  • 3:38

    I could place a call to the CountToThree method.

  • 3:41

    Let me save that and try running it.

  • 3:47

    And you can see that it counts to 3 at the start of the wait method.

  • 3:52

    And then it counts to 3 again when there's a call to CountToThree in the main method.

  • 3:57

    But that's not what we want.

  • 3:58

    So I'm going to remove the extra call to CountToThree up in the wait method.

  • 4:02

    Let me save that.

  • 4:05

    And rerun one more time.

  • 4:10

    And now, it just waits and counts to 3 again.

You need to sign up for Treehouse in order to download course files.

Sign up