More Examples

As you can imagine extension methods could be misused to cause a lot of confusion. 0:00 Notice how they appear to be part of the original class, but in fact they aren't. 0:05 When writing extension methods, I stick to a set of guidelines. 0:11 We'll go through these at the end of the workshop. 0:15 A good guideline is to only create extension methods that you could 0:17 realistically see as being part of the original class that you're extending. 0:21 A great example of an extension method is the IsEven method called on an integer. 0:25 So let's create a new class. 0:31 We'll call it, IntExtensions. 0:34 Again, we'll make it a public static class. 0:43 And in here, we'll have a public static method that returns a bool. 0:49 And it's called IsEven. 0:56 It's an extension method, so I've to say this and 0:59 the type that it's going to extend is integer. 1:03 I'll just call the parameter, value, here. 1:07 So in our method, we wanna check to see if this value is an even value. 1:12 So we'll return. 1:18 To see if the value is even, we can just divide the value by 2 and 1:20 to see if there's any remainder. 1:24 There's actually a special operator for that in C#, it's called modulus. 1:27 So we can return the value %2. 1:33 And if that is equal to zero then we know that value is even. 1:38 Otherwise it's false. 1:44 Another way to do this is to use a bitwise operator. 1:47 What we can do is we can take the integer value and 1:50 bitwise & it with the value 1, 1:53 because all odd integers have their lowest bit as 1. 1:58 Now don't worry if you're not familiar with bitwise operations. 2:04 This is just a very fast way to determine if the last bit of a integer is 1. 2:08 So now we can call the IsEven method on any integer 2:15 just like it was part of the original class. 2:20 In order to call it though, we need to make sure that we're 2:22 using the Treehouse.Common namespace where we want to use it. 2:25 So up here, we need to add, using Treehouse.Common. 2:29 Now down here, we can say 5.IsEven() and this should return false. 2:37 Now it's conceivable that the Treehouse.common namespace 2:45 has a lot of other classes in it. 2:49 We can reduce the scope even more by using a static using directive. 2:51 So we can actually say using static Treehouse.Common.IntExtensions. 2:56 This works with any static class. 3:04 And this makes it even more obvious that 3:07 we want to use the extension methods in this IntExtensions class. 3:10 Now, instead of using the entire Treehouse.Common namespace and 3:15 pulling in all of the other classes that might be in that namespace, 3:19 we're just pulling in the IntExtensions class. 3:23 And thereby, only pulling in this IsEven extension method. 3:26 Remember that just because there's an extension method that extends a type, 3:30 doesn't mean that it can be used from anywhere the type is used. 3:35 Extension methods are scoped to the namespace that they're declared in. 3:38 And we can further reduce that scope with the using static directive just like this. 3:42 It's a good practice to declare extension methods in a limited namespace. 3:48 For example, 3:53 we could have put the IntExtension class in the system namespace. 3:54 But then this extension method would be available everywhere. 3:58 And it wouldn't be very obvious that this method isn't part of the original 4:02 integer type. 4:05 There are a number of classes and 4:07 interfaces that I find myself writing extension methods for a lot. 4:08 One of those is the string class. 4:13 Let's take a look at the documentation for the string class. 4:15 Here's the documentation for the string class. 4:20 If we find the methods that start with split. 4:22 Here we see the all of the methods that start with split take a character array. 4:26 Now this first one, 4:32 actually takes a character array that's actually a params argument. 4:34 And a params argument allows us to pass in zero, one or 4:38 as many characters as we want and what it does is it just 4:43 combines all those into a single argument of type character array. 4:47 But the thing is, with params arguments, 4:52 is they have to be the last argument in the method. 4:54 So, like this one right here, takes a character array and the second 4:59 argument is the count which is the maximum number of substrings it should return. 5:05 So the first argument here, actually, it's just this regular old character array. 5:11 It's not a params, 5:17 which means we have to instantiate a character array and pass that in. 5:18 So this makes it kind of cumbersome when calling split, 5:24 if we only wanna pass in a single character as the separator. 5:29 We don't wanna have to create a character array every time we call the split method. 5:33 So we can leave this pain a little bit by creating an extension method 5:38 that does this for us. 5:42 So let's go back to our code here and I'll create a new file. 5:44 And it's a string extension, so 5:57 we'll put it in the StringExtensions class. 6:00 So it'll have to be a public static class. 6:08 And we'll make a public static method that returns a string array and 6:15 we'll call it split to match the other ones and it will extend a string. 6:20 So, we'll say this string. 6:26 And here we have to decide what we want to name the this parameter. 6:33 Now there's some debate about what you should name this. 6:36 Personally, I like to call it this. 6:40 But the problem is, is this is a keyword which, 6:43 we can't put it here because it's a keyword in C#. 6:47 It causes the C# compiler to kind of go into a fit. 6:50 So, [LAUGH] well, it just causes a compiler error. 6:56 So what we can do if we want to use a C# keyword as a variable 7:00 is we just prefix it with the @ symbol and this makes a lot of sense because 7:05 this parameter is actually called this parameter. 7:10 [LAUGH] So calling it @this makes a lot of sense. 7:14 Some people don't like that convention and 7:18 it's fine if you don't wanna do it this way. 7:20 Other people like to call the this parameter target or 7:22 source or value or extended or 7:26 something that just makes sense for the method that you code in, at that time. 7:30 I like to call it @this because I don't have to think about what to name the this 7:34 parameter every time I write an extension method. 7:38 It also makes argument null exceptions really obvious and 7:41 I'll show you what I mean in just a little bit. 7:45 Let's continue to write this method. 7:48 So we have to say which character we want to separate the string on, so 7:51 pass in the separator. 7:56 And we also wanna say the maximum number of times we want the string to split, 8:00 so we'll say int count. 8:04 The thing with extension methods is that 8:06 they can actually be called on an object whose value is null. 8:09 Now, if we were to call an instance method. 8:14 A method that's inside of a regular class on null, 8:17 we'd get a NullReferenceException thrown. 8:21 But because split is actually just a regular static method inside of a static 8:24 class and the object that is being called on is just another argument or 8:31 parameter being passed into the method, that means this can actually be null. 8:37 So we have to check for that, and throw an exception if that's the case. 8:42 Just to demonstrate that these extension methods are just really static 8:47 methods inside of a static class, we can go back to the program class and 8:52 change where we're calling random item, 8:57 to actually be look like a normal static method. 9:00 So we can say IListExtensions.RandomItem() and 9:05 we can pass in our list here. 9:11 So now this looks a lot more like the utility function that we had before. 9:15 So back in our split method, we need to check for null. 9:24 So I'll say, if(@this == null), 9:28 Now I've said normally, if a method is called on an object whose value is null 9:35 then we'll get a NullReferenceException. 9:39 But sometimes people actually call extension methods 9:43 like a regular static method. 9:46 So instead of throwing a NullReferenceException which really 9:48 wouldn't make sense if you're calling it as a utility method or as a static method. 9:52 What we'll throw is a ArgumentNullException. 9:56 So I'll say, throw new ArgumentNullException. 10:00 And here, we pass in the name of the argument that is null, 10:06 so in this case it's @this. 10:11 There we go. 10:15 Now there's a cool trick in C#. 10:16 There's an operator called nameof that we can use. 10:18 That can make it so that instead of passing in a string here, 10:24 we can actually just pass in the variable itself and nameof will return 10:29 the actual name, the string, that is the name of the variable. 10:34 This is handy because we may wanna refactor in the future and 10:39 change the name of the variable here. 10:43 And as part of that refactoring, the compiler will catch 10:46 that we've changed the variable and will tell us we also need to change it here. 10:50 Strings can actually be quite dangerous when we're using them to refer to code. 10:54 So it's always best to always just stick in the code. 10:59 Now down here, we can finish implementing our method. 11:03 So, we want to return. 11:05 And we'll just call the regular split method from the string class. 11:08 So we'll say @this.Split(). 11:12 Now, this is how we would normally call this method. 11:16 We would create a new array. 11:20 And in the array, we would specify the separator that we want to split on. 11:25 And then pass in count. 11:35 So there you go. 11:37 So now when we're using this method, instead of calling string.Split, 11:38 creating a new array with the separator we wanna split on, 11:44 we can just call this method like so. 11:48 We'll just say "mySTring".Split('S', 11:51 3) like that. 11:59 Pretty nifty. 12:02 So I mentioned before that calling this parameter @this can 12:09 actually help a little bit when we have argument null exceptions. 12:13 So let's go to program and let's cause one of these exceptions. 12:19 So let's create a string. 12:27 And we'll just call it myString, and set it equal to null. 12:29 And we'll call myString.Split. 12:37 And notice now that there are a lot of different split methods in this 12:45 string class. 12:49 We can go down here, these ones are all part of the regular class. 12:50 And we'll just pass in you can split on a comma, three times. 12:58 And it's not seeing our new extension method because we don't have 13:04 the namespace up here. 13:09 So let's bring this back to using static Treehouse.Common. 13:10 There we go. 13:21 So let's run this and let's see what kind of exception we get. 13:22 All right, so because we're in the debugger, 13:26 it breaks right here where the ArgumentNullException is being thrown. 13:28 And here we see ArgumentNullException was unhandled and 13:33 we go down here, we can click on this view detail. 13:37 And here we see value cannot be null parameter name is this. 13:40 Now my logic for calling the parameter this is because if 13:46 an ArgumentNullException is thrown and the parameter name is this, then I know right 13:51 away that the method that threw this exception is a extension method. 13:55 So that gives me a lot better idea of where to look. 14:01