In our Exploring the .NET Framework series, we’ve covered some terminology, creating instances of objects and calling methods.  In today’s installment, we are going to look at using static members – methods and properties.  Static methods are methods that a class (or type) make available without needing to create an instance of the class.  Similarly, static properties are properties that you can access without needing an instance of the class.

Many classes provide static members supply functionality where it doesn’t make sense to need an object. 

The System.Math class contains a couple of static properties, PI and E. 

PS C:\scripts\PowerShell> [math]::E
2.71828182845905
PS C:\scripts\PowerShell> [math]::PI
3.14159265358979

Constant values are not the only type of property that you’ll find.  The System.AppDomain class has a static property, CurrentDomain, which is an AppDomain instance referring to the current application domain.

PS C:\scripts\PowerShell> [AppDomain]::CurrentDomain.gettype()

IsPublic  IsSerial Name         BaseType
——–    ——–    —-            ——–
True     False    AppDomain System.MarshalByRefObject

System.Math also contains a number of static methods that provide a great deal of basic mathematical function.

PS C:\scripts\PowerShell>[Math] | get-member –static –membertype method | select name

Name
—-
Abs
Acos
Asin
Atan
Atan2
BigMul
Ceiling
Cos
Cosh
DivRem
Equals
Exp
Floor
IEEERemainder
Log
Log10
Max
Min
Pow
ReferenceEquals
Round
Sign
Sin
Sinh
Sqrt
Tan
Tanh
Truncate

I wrote a little helper function to get the static method definitions (Get-StaticMethodDefinition), which you can grab from PoshCode.org.

(V2 CTP3 – We can use the trick of using the method name without parenthesis following to get additional information on each of the methods that we are interested in.)

One type of static method that I would like to highlight is the factory method.  A factory method is a common way of controlling object creation.  At its most basic level, a factory pattern is a method that creates objects of a specified type. 

An example of this is the System.Net.WebRequest’s Create method.

PS C:\scripts\PowerShell> $web = [net.webrequest]::create(‘http://www.google.com‘)
PS C:\scripts\PowerShell> $web.gettype()

IsPublic IsSerial Name                                     BaseType
——– ——– —-                                     ——–
True     True     HttpWebRequest                           System.Net.WebReq…

The factory method Create used the argument (‘http://www.google.com’) to determine the type of WebRequest object to create.  In this case, it created an HttpWebRequest object, which is a more specialized version of the WebRequest for HTTP requests. 

Let’s see how it would respond if we passed the Create method a URI with FTP.

PS C:\scripts\PowerShell> $web = [net.webrequest]::create(‘ftp://ftp.google.com’)
PS C:\scripts\PowerShell> $web.gettype()

IsPublic IsSerial Name                                     BaseType
——– ——– —-                                     ——–
True     False    FtpWebRequest                            System.Net.WebReq…

As we can see, the WebRequest class created an FtpWebRequest object.

Factory methods provide developers a way to more flexibly support different operations by allowing the static method to determine which object to return.

UPDATE:  Joel “Jaykul” Bennet added a V2 advanced function to convert static methods to functions to PoShCode.org  and pointed out Oisin Grehan’s blog post about creating functions from static methods (V1 compatible).

I’ve been really happy to receive some of the feedback (positive and constructive criticism) on this series.  There is a lot of the .NET Framework to cover, and I’m open to suggestions as to what you would like to know.  Please post a comment on the blog or email me at Steve at UsePowerShell.Com.

Continuing from where I left off last week, we were created an instance of the System.Net.NetworkInformation.Ping class and looked at the different ways (overloads) that we can call the Send method.  Now that we’ve seen how we can create Ping objects, let’s take advantage of options for creating some custom ping packets and examine the return object.

PS C:\> $encoder = new-object System.Text.ASCIIEncoding

PS C:\> $bytes = $encoder.Getbytes(‘Hello From Steve’)

PS C:\> $response = $ping.Send(‘google.com’, 100, $bytes)

Let’s take a look at the response we get back.

PS C:\> $response | Get-Member

   TypeName: System.Net.NetworkInformation.PingReply

Name                  MemberType     Definition
—-                       ———-     ———-
Equals                  Method         System.Boolean Equals(Object obj)
GetHashCode        Method         System.Int32 GetHashCode()
GetType               Method         System.Type GetType()
get_Address          Method         System.Net.IPAddress get_Address()
get_Buffer            Method         System.Byte[] get_Buffer()
get_Options          Method         System.Net.NetworkInformation.PingOptions…
get_RoundtripTime Method         System.Int64 get_RoundtripTime()
get_Status            Method         System.Net.NetworkInformation.IPStatus ge…
ToString               Method         System.String ToString()
Address                Property       System.Net.IPAddress Address {get;}
Buffer                  Property       System.Byte[] Buffer {get;}
Options                Property       System.Net.NetworkInformation.PingOptions…
RoundtripTime       Property       System.Int64 RoundtripTime {get;}
Status                  Property       System.Net.NetworkInformation.IPStatus St…
BufferSize             ScriptProperty System.Object BufferSize {get=$this.Buffe…
OptionsString        ScriptProperty System.Object OptionsString {get=’TTL={0}…

Get-Member shows us that this is a PingReply object in the System.Net.NetworkInformation namespace.

Looking at the PingReply object that was returned, we have several methods that look strangely similar to the properties, but with a “get_” prefixed to it.  When you see a method that matches a Property, but has “get_” or “set_”, that is a method exposed by the .NET Framework that provides the functionality for the properties.  When you access the Buffer property, you are actually calling the get_Buffer method.  Properties are, for the most part, easier to work with and you can effectively ignore those methods.  Properties also contain a clue in their description, if you look at the end of the Buffer property’s description, you see “{get;}” which indicates that there is a way to retrieve that property.  Properties can also show “{set;}” which indicates that you can update that property.

In PowerShell V2 CTP3 those “getters” and “setters” (as those methods are commonly called) are hidden by default.  If you are running CTP3 and want to see the “getters” and “setters”, you can call Get-Member with the Force parameter.

PS C:\> $response | Get-Member –Force

Back to the properties of our return object.  The properties names are pretty self-explanatory, but to confirm we got back the “special” packet we crafted, let’s take a look at the Buffer property and convert that back to text.

PS C:\> $encoder.GetString($response.buffer)
Hello From Steve

Now for the meat of the response, the RoundtripTime and Status.  I commonly use the Roundtrip time to watch for latency on my network, and since it is exposed so nicely, it is easy to log.

PS C:\> $response.RoundtripTime
74

And of course, we are interested in the Status.

PS C:\> $response.Status
Success

Now, we can see from the Get-Member return above, that Status is not just a string that says, “Success”, it is a IPStatus enumeration (more on enumerations coming up, but long story short, there are a number of predefined values that an IPStatus object can hold)(also found in the System.Net.NetworkInformation namespace). 

I’m normally checking the IPStatus for a Success value like

PS C:\> $success = [System.Net.NetworkInformation.IPStatus]::Success

PS C:\> $response.status -eq $success
True

I could compare the string results, but then I’m stepping back to parsing text results.  By using the IPStatus enumeration values, I can get be reasonably sure that my value are correct and I don’t have any text matching issues.

In the next post in this series, we’ll take a look at a special type of method, the constructor.