Preview
Video Player
00:00
00:00
Introduction
13:05In this video we'll compare and contrast subclassing, helper methods, utility methods, and extension methods.
Welcome to this workshop
about C# extension methods.
0:04
I'm Jeremy.
0:08
Have you ever been coding along and
0:10
thought, I wish this class I'm using
had methods for doing X, Y, or Z?
0:11
For example, just the other day, I wanted
to randomly pick an item from a list.
0:15
But neither the Random class nor the List
class have methods for doing this.
0:21
Both the list and the Random class
are provided by the .NET Framework.
0:25
So I can't just go and open up their
code files and add a method to them.
0:29
Fortunately, .NET has provided
a way to add methods to any class,
0:34
even if we don't have
access to the source code.
0:38
This is the purpose of
C# extension methods.
0:41
Let's take a look at the code that I wrote
to randomly pick an item from a list.
0:44
Here we have a list of the synonyms for
best, and
0:48
down here I print out,
my dog Jojo is the synonym for best dog.
0:52
To get the synonym for
0:58
best, I call this GetRandomItem method and
pass it that list.
0:59
I wrote this GetRandomItem method
to get a random item from the list.
1:03
Here it takes the list and
I construct a random object and
1:08
I call next on that random object,
and what this does is it just gets
1:13
a random index from the list and
then returns the item at that index.
1:17
Now on the surface,
this looks pretty good, but
1:22
there are a few things we
could do to improve it.
1:25
For one this GetRandomItem
method isn't very reusable.
1:27
It's stuck in the program class.
1:31
It's likely that there are other
places in the code where we
1:33
might want to get a random
item from a list.
1:36
Methods like this are often
called helper methods because
1:39
they're used to help
the class do something minor.
1:42
They aren't considered a core
part of the class, and
1:45
helper methods like these can
quickly clutter up a class.
1:48
So it's better if we could move this
method outside of this class so
1:51
that it could be reused by other code.
1:55
Also, it would be more
readable if we could just
1:57
say, SynonymsForBest.RandomItem,
2:00
like this.
2:09
But the List class doesn't have
a method named RandomItem.
2:11
This is what C# extension
methods can be used for.
2:16
We can add methods so that they appear as
if they're part of the original class.
2:19
Not every language has extension methods,
though, and
2:24
developers have been coding for
a long time without them.
2:27
So, let's take a look at how
we would solve this problem
2:30
without using an extension method first.
2:33
One way we could do this is to extend
the list class directly using inheritance.
2:35
So, let's create a class library.
2:41
Just right click on the solution,
go to Add > New Project,
2:45
select Class Library, and here I'll create
2:51
a new class library
called Treehouse.Common.
2:56
I often create a class library to contain
some of the common code that I want to
3:01
share between different programs.
3:06
That's where we want
to put our List class.
3:09
Let's delete this file and
3:11
then add a new class for our list.
3:17
I'm just gonna to call it List, but
I'll put it in a different namespace so
3:25
that it doesn't conflict with
the System.Collections.Generic.List.
3:30
So I'll say,
Treehouse.Collections.Generic.
3:35
The List will need to be public so
3:44
that it can be accessed from
outside of the class library.
3:47
And it will be a subclass of
the System.Collections.Generic.List.
3:52
We need to specify what type of
item we want our list to contain.
4:04
So add a type parameter here.
4:10
Now if we were doing this properly,
we would create constructors for
4:13
each of the constructors in the base
System.Collections.Generic.List class.
4:17
Let's skip that for right now.
4:22
Right now,
let's copy this GetRandomItem method from
4:24
the program class over here and
move it over here to the List class.
4:29
Let's make it public.
4:39
And it's no longer static.
4:42
We'll just call it RandomItem.
4:46
And instead of returning a string,
4:48
we'll have it return the type of
the item that's contained in the list.
4:49
We don't need to pass it the list and
4:54
we'll get the item from the list itself,
4:58
just say this, and
just change this to Count.
5:04
So now we have an instance method
on our new List class that will
5:09
return a random item from the list.
5:14
Something else we could do here so that
we're not creating a new random object
5:17
every time the random method is called,
or the random item method is called,
5:21
is we can move this
outside of this method and
5:26
make it a static field, so
just say private static.
5:30
Random equals new random, type random.
5:38
There we go.
5:48
Now if we go back over
to the program class,
5:51
we still don't have the random
item method on our list.
5:54
That's because we're still using
the System.Collections.Generics
5:57
version of the list.
6:01
We need to change it to use our new List.
6:03
So we'll just change this
namespace up here from
6:06
System.Collections.Generic to
Treehouse.Collections.Generic.
6:10
Looks like I probably misspelled.
6:20
I see what the problem is.
6:23
We need to add a reference to
our new class library here.
6:24
So say Add Reference >
Projects > Treehouse.Common.
6:28
There we go, that should fix it.
6:35
So now we're using our new type of list,
6:41
which is just a subclass of
the list provided by .NET.
6:44
However, in order to use this new method,
6:48
the list had to be of type
Treehouse.Collections.Generic.List,
6:51
instead of .NET's
implementation of the list.
6:56
We're no longer using the List class from
.NET, but had we gotten this list of
6:59
synonyms from some other source or
library of code that didn't know about
7:03
our new fangled list type,
it probably wouldn't be the right type.
7:08
Most likely,
it would be the List that comes with .NET.
7:13
Sometimes it makes sense to
make a subclass of List and
7:16
create our own list that has
a bunch more features in it.
7:21
But adding one method
isn't enough justification
7:24
to warrant creating
a whole new type of List.
7:28
Instead of creating a new type of List,
7:31
we could just create what many
refer to as a utility method.
7:34
To do that,
let's change our List class over here.
7:38
Let's actually change it
to be called ListUtils.
7:42
This is a common way of naming
classes that contain utility methods.
7:48
We'll also make it a static class.
7:53
Let's change our RandomItem method so
8:04
that it takes a Type parameter, and
we'll also make it static as well.
8:07
In order for
8:15
it to get an item from the list,
it needs to take the list as a parameter.
8:16
So we'll say List<T>,
8:20
and we just call it list.
8:24
So this is starting to look like
the method that we originally had
8:29
in the program class.
8:33
We also need to add
the System.Collections.Generic
8:40
namespace up here.
8:47
Now over in Program.cs,
8:51
we'll need to change this back to
8:55
System.Collections.Generic as well.
9:00
But now we don't have a List class
that contains a RandomItem method.
9:08
So instead,
9:12
what we have to do is call the RandomItem
method that's in our ListUtils class.
9:13
So it'll be ListUtils.RandomItem, and
9:19
we'll pass in the synonymsForBest list.
9:23
We still need to have
a using statement for
9:34
our Treehouse.Collections namespace.
9:39
There we go.
9:47
While we're at it, let's go ahead in
change the name of this file to be
9:48
ListDetails as well,
to match the class name.
9:53
So now we have our reusable
RandomItem method.
10:01
But it isn't quite as readable or
useful as the RandomItem
10:05
method that we had when we could just
call it right on the List class.
10:10
We can get some of this
readability back and
10:14
ease-of-use by using
a C# extension method.
10:16
What we want is to be able
to call the RandomItem
10:19
method right on the list, like this.
10:27
To do that, let's take another
look at our ListUtils class.
10:33
To turn our RandomItem method
into an extension method,
10:37
all we have to do is add
the keyword this here.
10:42
Now our red squiggly
lines have gone away and
10:48
we can call the RandomItem
method directly on a list.
10:51
So adding the List keyword here
right before the type parameter
10:55
made this static method
into an extension method.
10:59
What the List parameter
does is it tells C# that
11:03
this method can be called
on any object of type List.
11:07
In order for
this to be an extension method,
11:15
it must be a public static method
inside of a public static class.
11:17
So this works just like a utility method,
only we don't have to say
11:23
ListUtils.RandomItem and
then pass in the list.
11:28
Instead, we can just call RandomItem
right on an object of List.
11:32
In fact,
we can even make it better than that.
11:37
We can change the type that the extension
method can be called on to an interface.
11:40
So now, the RandomItem method
11:47
can be called on any object that
implements the IList interface.
11:49
That's pretty cool.
11:54
To make it clear that this class
contains extension methods,
11:56
let's rename the name of the class.
12:00
Let's name this IListExtensions.
12:03
We'll also rename the file.
12:10
Let's go back to Program.cs.
12:20
Notice what happens when I comment
out this using statement for
12:25
Treehouse.Collections.Generic.
12:30
We lose the ability to call the RandomItem
extension method on synonymsForBest.
12:33
This is how we provide scope for
extension methods.
12:39
By saying that we're using the
Treehouse.Collections.Generic namespace,
12:43
we're also saying that we
want to have access to
12:47
any extension methods that
are declared inside that namespace.
12:50
So extension methods are pretty nifty and
12:54
they help to keep our code clean,
dry, and readable.
12:57
Let's take a look at a few more
features of extension methods
13:00
by writing a few more.
13:04