As you can imagine extension methods could be misused to cause a lot of confusion.

Notice how they appear to be part of the original class, but in fact they aren't.

When writing extension methods, I stick to a set of guidelines.

We'll go through these at the end of the workshop.

A good guideline is to only create extension methods that you could

realistically see as being part of the original class that you're extending.

A great example of an extension method is the IsEven method called on an integer.

So let's create a new class.

We'll call it, IntExtensions.

Again, we'll make it a public static class.

And in here, we'll have a public static method that returns a bool.

And it's called IsEven.

It's an extension method, so I've to say this and

the type that it's going to extend is integer.

I'll just call the parameter, value, here.

So in our method, we wanna check to see if this value is an even value.

So we'll return.

To see if the value is even, we can just divide the value by 2 and

to see if there's any remainder.

There's actually a special operator for that in C#, it's called modulus.

So we can return the value %2.

And if that is equal to zero then we know that value is even.

Otherwise it's false.

Another way to do this is to use a bitwise operator.

What we can do is we can take the integer value and

bitwise & it with the value 1,

because all odd integers have their lowest bit as 1.

Now don't worry if you're not familiar with bitwise operations.

This is just a very fast way to determine if the last bit of a integer is 1.

So now we can call the IsEven method on any integer

just like it was part of the original class.

In order to call it though, we need to make sure that we're

using the Treehouse.Common namespace where we want to use it.

So up here, we need to add, using Treehouse.Common.

Now down here, we can say 5.IsEven() and this should return false.

Now it's conceivable that the Treehouse.common namespace

has a lot of other classes in it.

We can reduce the scope even more by using a static using directive.

So we can actually say using static Treehouse.Common.IntExtensions.

This works with any static class.

And this makes it even more obvious that

we want to use the extension methods in this IntExtensions class.

Now, instead of using the entire Treehouse.Common namespace and

pulling in all of the other classes that might be in that namespace,

we're just pulling in the IntExtensions class.

And thereby, only pulling in this IsEven extension method.

Remember that just because there's an extension method that extends a type,

doesn't mean that it can be used from anywhere the type is used.

Extension methods are scoped to the namespace that they're declared in.

And we can further reduce that scope with the using static directive just like this.

It's a good practice to declare extension methods in a limited namespace.

For example,

we could have put the IntExtension class in the system namespace.

But then this extension method would be available everywhere.

And it wouldn't be very obvious that this method isn't part of the original

integer type.

There are a number of classes and

interfaces that I find myself writing extension methods for a lot.

One of those is the string class.

Let's take a look at the documentation for the string class.

Here's the documentation for the string class.

If we find the methods that start with split.

Here we see the all of the methods that start with split take a character array.

Now this first one,

actually takes a character array that's actually a params argument.

And a params argument allows us to pass in zero, one or

as many characters as we want and what it does is it just

combines all those into a single argument of type character array.

But the thing is, with params arguments,

is they have to be the last argument in the method.

So, like this one right here, takes a character array and the second

argument is the count which is the maximum number of substrings it should return.

So the first argument here, actually, it's just this regular old character array.

It's not a params,

which means we have to instantiate a character array and pass that in.

So this makes it kind of cumbersome when calling split,

if we only wanna pass in a single character as the separator.

We don't wanna have to create a character array every time we call the split method.

So we can leave this pain a little bit by creating an extension method

that does this for us.

So let's go back to our code here and I'll create a new file.

And it's a string extension, so

we'll put it in the StringExtensions class.

So it'll have to be a public static class.

And we'll make a public static method that returns a string array and

we'll call it split to match the other ones and it will extend a string.

So, we'll say this string.

And here we have to decide what we want to name the this parameter.

Now there's some debate about what you should name this.

Personally, I like to call it this.

But the problem is, is this is a keyword which,

we can't put it here because it's a keyword in C#.

It causes the C# compiler to kind of go into a fit.

So, [LAUGH] well, it just causes a compiler error.

So what we can do if we want to use a C# keyword as a variable

is we just prefix it with the @ symbol and this makes a lot of sense because

this parameter is actually called this parameter.

[LAUGH] So calling it @this makes a lot of sense.

Some people don't like that convention and

it's fine if you don't wanna do it this way.

Other people like to call the this parameter target or

source or value or extended or

something that just makes sense for the method that you code in, at that time.

I like to call it @this because I don't have to think about what to name the this

parameter every time I write an extension method.

It also makes argument null exceptions really obvious and

I'll show you what I mean in just a little bit.

Let's continue to write this method.

So we have to say which character we want to separate the string on, so

pass in the separator.

And we also wanna say the maximum number of times we want the string to split,

so we'll say int count.

The thing with extension methods is that

they can actually be called on an object whose value is null.

Now, if we were to call an instance method.

A method that's inside of a regular class on null,

we'd get a NullReferenceException thrown.

But because split is actually just a regular static method inside of a static

class and the object that is being called on is just another argument or

parameter being passed into the method, that means this can actually be null.

So we have to check for that, and throw an exception if that's the case.

Just to demonstrate that these extension methods are just really static

methods inside of a static class, we can go back to the program class and

change where we're calling random item,

to actually be look like a normal static method.

So we can say IListExtensions.RandomItem() and

we can pass in our list here.

So now this looks a lot more like the utility function that we had before.

So back in our split method, we need to check for null.

So I'll say, if(@this == null),

Now I've said normally, if a method is called on an object whose value is null

then we'll get a NullReferenceException.

But sometimes people actually call extension methods

like a regular static method.

So instead of throwing a NullReferenceException which really

wouldn't make sense if you're calling it as a utility method or as a static method.

What we'll throw is a ArgumentNullException.

So I'll say, throw new ArgumentNullException.

And here, we pass in the name of the argument that is null,

so in this case it's @this.

There we go.

Now there's a cool trick in C#.

There's an operator called nameof that we can use.

That can make it so that instead of passing in a string here,

we can actually just pass in the variable itself and nameof will return

the actual name, the string, that is the name of the variable.

This is handy because we may wanna refactor in the future and

change the name of the variable here.

And as part of that refactoring, the compiler will catch

that we've changed the variable and will tell us we also need to change it here.

Strings can actually be quite dangerous when we're using them to refer to code.

So it's always best to always just stick in the code.

Now down here, we can finish implementing our method.

So, we want to return.

And we'll just call the regular split method from the string class.

So we'll say @this.Split().

Now, this is how we would normally call this method.

We would create a new array.

And in the array, we would specify the separator that we want to split on.

And then pass in count.

So there you go.

So now when we're using this method, instead of calling string.Split,

creating a new array with the separator we wanna split on,

we can just call this method like so.

We'll just say "mySTring".Split('S',

3) like that.

Pretty nifty.

So I mentioned before that calling this parameter @this can

actually help a little bit when we have argument null exceptions.

So let's go to program and let's cause one of these exceptions.

So let's create a string.

And we'll just call it myString, and set it equal to null.

And we'll call myString.Split.

And notice now that there are a lot of different split methods in this

string class.

We can go down here, these ones are all part of the regular class.

And we'll just pass in you can split on a comma, three times.

And it's not seeing our new extension method because we don't have

the namespace up here.

So let's bring this back to using static Treehouse.Common.

There we go.

So let's run this and let's see what kind of exception we get.

All right, so because we're in the debugger,

it breaks right here where the ArgumentNullException is being thrown.

And here we see ArgumentNullException was unhandled and

we go down here, we can click on this view detail.

And here we see value cannot be null parameter name is this.

Now my logic for calling the parameter this is because if

an ArgumentNullException is thrown and the parameter name is this, then I know right

away that the method that threw this exception is a extension method.

So that gives me a lot better idea of where to look.