Looking at some code examples for HtmlHelpers, and I see declarations that look like:
public static string HelperName(this HtmlHelper htmlHelper, ...more regular params )
I can't remember seeing this type of construct any where else - can someone explain the purpose of the "this"? I thought that by declaring something public static meant that the class did not need to be instantiated - so what is "this" in this case?
A parameter is a named variable passed into a function. Parameter variables are used to import arguments into functions. Note the difference between parameters and arguments: Function parameters are the names listed in the function's definition.
The this keyword refers to the current instance of the class and is also used as a modifier of the first parameter of an extension method. This article discusses the use of this with class instances. For more information about its use in extension methods, see Extension Methods.
"Can I pass “this” as a parameter to another function in javascript" --- yes you can, it is an ordinary variable with a reference to current object.
For example, if one defines a function as def f(x): ... , then x is the parameter, and if it is called by a = ...; f(a) then a is the argument. A parameter is an (unbound) variable, while the argument can be a literal or variable or more complex expression involving literals and variables.
This is the syntax for declaring extension methods, a new feature of C# 3.0.
An extension method is part code, part compiler "magic", where the compiler with the help of intellisense in Visual Studio make it appear that your extension method is actually available as an instance method on the object in question.
Let me give an example.
There's no method on the String class that is named GobbleGobble, so let's create an extension method:
public static class StringExtensions { public static void GobbleGobble(this string s) { Console.Out.WriteLine("Gobble Gobble, " + s); } }
The class name is just my naming convention, it isn't necessary to name it like that, but it has to be static, as do the method.
After declaring the above method, you can, in Visual Studio, type this:
String s = "Turkey Baster!"; s.
after the dot, wait for intellisense, and notice there is a GobbleGobble method there, complete the code like this:
String s = "Turkey Baster!"; s.GobbleGobble();
Important: The class where the extension method is declared must be available to the compiler and the intellisense processor in order for intellisense to show the method. If you type in GobbleGobble manually, and use the Ctrl+. shortcut, it will not help you get the right using directives into the file.
Notice that the parameter to the method has disappeared. The compiler will silently move around the important bits, which are:
String s = "Turkey Baster!"; s.GobbleGobble(); ^ ^ | +-- the compiler will find this in the StringExtensions class | +-- will be used as the first parameter to the method
Thus, the above code will be transformed by the compiler to this:
String s = "Turkey Baster!"; StringExtensions.GobbleGobble(s);
So at call-time, there's nothing magical about it, it's just a call to a static method.
Note that if your extension method declares more than one parameter, only the first supports the this
modifier, and the rest has to be specified as part of the method call as normal:
public static void GobbleGobble(this string value, string extra) { | | ... | | } | | | | +--------------------------------------------+ | | | v | s.GobbleGobble("extra goes here"); | ^ | | | +-----------------------------------+
Extension methods was added in part due to Linq, where the Linq syntax of C# will look for appropriately named extension methods for the objects in play, which means you can "introduce" Linq-support into any type of class by just declaring the right extension methods. Of course, full Linq support is a lot of work, but it is possible.
Also, extension methods by themselves are really useful, so read up on it.
Here's a few links:
After extension methods, I've been using them like crazy.. here is a few I use constantly..
public static T ChangeType<T>(this object obj) { return (T)Convert.ChangeType(obj, typeof(T)); }
Works like this..
int i = "123".ChangeType<int>(); bool valid = "bool".ChangeType<bool>(); int id = dataSet.Tables[0].Rows[0]["Id"].ChangeType<int>();
Yeah, it shows up on every single object, can be annoying but since I use this for pretty much every data type, it helps to just attach it an object rather than duplicating it for every data type possible.
public static string ToXml(this object serializableObject) { var aMemStr = new MemoryStream(); try { var serializer = new XmlSerializer(serializableObject.GetType()); serializer.Serialize(new XmlTextWriter(aMemStr, null), serializableObject); return Encoding.UTF8.GetString(aMemStr.ToArray()); } finally { if (aMemStr != null) { aMemStr.Dispose(); } } } string xml = dataSet.ToXml(); public static T ToObject<T>(this string xmlString) { var aStream = new MemoryStream(Encoding.UTF8.GetBytes(xmlString)); try { return (T)new XmlSerializer(typeof(T)).Deserialize(aStream); } finally { if (aStream != null) { aStream.Dispose(); aStream = null; } } } DataSet dataSet = xml.ToObject<DataSet>();
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With