{"id":16691,"date":"2010-10-27T00:01:00","date_gmt":"2010-10-27T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2010\/10\/27\/use-net-framework-classes-to-work-with-strings-in-windows-powershell\/"},"modified":"2010-10-27T00:01:00","modified_gmt":"2010-10-27T00:01:00","slug":"use-net-framework-classes-to-work-with-strings-in-windows-powershell","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/use-net-framework-classes-to-work-with-strings-in-windows-powershell\/","title":{"rendered":"Use .NET Framework Classes to Work with Strings in Windows PowerShell"},"content":{"rendered":"

 <\/p>\n

Summary:<\/b> Learn how to use .NET Framework classes to work with strings in Windows PowerShell in this Scripting Guys how-to post.<\/p>\n

 <\/p>\n

\"Hey,Hey, Scripting Guy! I have been writing VBScript code for years. One thing I really liked about VBScript was the large number of functions that manipulated strings. I know Microsoft seems to love XML, but there is a lot of overhead associated with XML, and very often, I need to parse and manipulate strings. When I look at the Windows PowerShell cmdlets, I do not see very many cmdlets that would allow me to manipulate text. <\/p>\n

— BW<\/p>\n

 <\/p>\n

\"Hey,Hello BW, Microsoft Scripting Guy Ed Wilson here. When I was a student at the university, I majored in music for a while. One of my favorite classes was a music theory class that focused on string instruments. It was a string theory class. Today, I will examine string theory as it applies to Windows PowerShell. In continuing my discussion of the .NET Framework as it applies to Windows PowerShell, I will examine the System.String<\/b> .NET Framework class. <\/p>\n

Strings are letters, words, and numbers that function like letters and words. The GetType<\/b> method can be used to determine what kind of object one is working with. This is shown here.<\/p>\n

PS C:\\> (“this is a string”).GetType()<\/p>\n

IsPublic IsSerial Name                                     BaseType
——– ——– —-                                     ——–
True     True     String                                   System.Object<\/p>\n

PS C:\\><\/span><\/p>\n

As seen above, “this is a string” is an instance of a string object. The .NET Framework class string, is located in the System<\/b> .NET Framework namespace. Therefore, I will frequently refer it to it as the System.String<\/b> class because it helps me remember where in the labyrinthine .NET Framework hierarchy the String<\/b> class resides. Knowing where the class resides is useful when I have to look up information on MSDN, but to create some classes I have to specify both the namespace and the class name. <\/p>\n

If the string “this is a string” is an instance of the System.String<\/b> class, what does that really mean? It means that the class contains methods and properties. The methods do things and are like verbs, whereas the properties describe things and are like adjectives. To find the members (methods and properties) of the System.String<\/b> class, I can use the Get-Member<\/b> Windows PowerShell cmdlet. To do this, I first open Windows PowerShell by clicking Start<\/b> \\ Programs<\/b> \\ Accessories<\/b> \\ Windows PowerShell<\/b> \\ Windows PowerShell<\/b>. If you are tired of meandering through five levels of nested menus to start Windows PowerShell, you may want to create a desktop shortcut to Windows PowerShell. The Scripting Wife<\/a> talks about this technique. The technique of piping a string to the Get-Member<\/b> cmdlet is illustrated here. The PS C:\\><\/span> is not part of the command, but is the Windows PowerShell prompt. <\/p>\n

PS C:\\> “this is a string” | Get-Member<\/span><\/p>\n

After the command is typed, and the enter key pressed to submit the command to Windows PowerShell for interpretation, the output seen in the following figure appears. <\/p>\n

<\/p>\n

 <\/p>\n

There are many ways to call a method on an instance of a class such as the System.String<\/b> class seen here. In every example, a dotted notation is used immediately after the class instance that is followed by the method name. Several different ways of calling the toupper method are illustrated here. <\/p>\n

PS C:\\> (“this is A string”).toupper()
THIS IS A STRING
PS C:\\> “this is A string”.toupper()
THIS IS A STRING
PS C:\\> $a = “this is A string”
PS C:\\> $a.ToUpper()
THIS IS A STRING
PS C:\\> $b = New-Object system.string(“this is A string”)
PS C:\\> $b.ToUpper()
THIS IS A STRING
PS C:\\> [string]”this is A string”.toupper()
THIS IS A STRING
PS C:\\> ([string]”this is A string”).toupper()
THIS IS A STRING
PS C:\\> [string](“this is A string”).toupper()
THIS IS A STRING
PS C:\\><\/span><\/p>\n

The tolower<\/b> method works exactly like the toupper<\/b> method. Whereas the toupper<\/b> method will take a string and convert all the letters in the string to uppercase (hence the name toupper<\/b>) the tolower<\/b> method performs the opposite action. It converts a string to all lowercase characters. In the following example a mixed case string is converted to all uppercase letters and stored in the $a<\/i> variable. The contents of the $a<\/i> variable are then displayed on the Windows PowerShell console line. The tolower<\/b> method is then called to convert the uppercase letters stored in the $a<\/em> variable to lowercase. The output of the tolower<\/b> method call is not stored (that is the results are not stored in a variable, they are only displayed on the Windows PowerShell console line). The commands and their associated output are shown here.  <\/p>\n

PS C:\\> $a = [string](“this is A string”).toupper()<\/span><\/p>\n

PS C:\\> $a<\/span><\/p>\n

THIS IS A STRING<\/span><\/p>\n

PS C:\\> $a.ToLower()<\/span><\/p>\n

this is a string<\/span><\/p>\n

PS C:\\><\/span><\/p>\n

The toupper<\/b> or the tolower<\/b> methods are useful for evaluating user input. In the example that follows, the Read-Host<\/b> Windows PowerShell cmdlet asks for input from the user. If the user types yes<\/i>, the code continues. Refer to this code for the details. <\/p>\n

PS C:\\> $rtn = Read-Host “Do you wish to continue? yes \/ no”<\/span><\/p>\n

Do you wish to continue? yes \/ no: yes<\/span><\/p>\n

PS C:\\> if($rtn.ToUpper() -eq “YES”) {“continue”} ELSE { “don’t continue” }<\/span><\/p>\n

continue<\/span><\/p>\n

If the user can be counted upon to type exactly what the prompt expects, then everything will work perfectly. However, this is an unlikely expectation. In the example that follows, the same prompt is displayed by using the Read-Host<\/b> cmdlet. Instead of typing yes<\/i> the user types Yes, I would like to continue<\/i> and the $rtn.ToUpper<\/b> code fails. The contains<\/b> method returns a Boolean value if a match in a string is detected. Unfortunately, it is case-sensitive, and because the user typed Yes<\/i> instead of yes,<\/i> the contains<\/b> method fails also. What is needed is the ability to combine the tolower<\/b> method and the contains<\/b> method. The last line of the following code achieves that. <\/p>\n

PS C:\\> $rtn = Read-Host “Do you wish to continue? yes \/ no”<\/span><\/p>\n

Do you wish to continue? yes \/ no: Yes  I would like to continue.<\/span><\/p>\n

PS C:\\> if($rtn.ToUpper() -eq “yes”) { “continue” } ELSE { “don’t continue” }<\/span><\/p>\n

don’t continue<\/span><\/p>\n

PS C:\\> if($rtn.contains(“yes”)) { “continue” } ELSE { “don’t continue” }<\/span><\/p>\n

don’t continue<\/span><\/p>\n

PS C:\\> if($rtn.tolower().contains(“yes”)) { “continue” } ELSE { “don’t continue” }<\/span><\/p>\n

continue<\/span><\/p>\n

PS C:\\><\/span><\/p>\n

A common problem arising from working with strings is additional spaces. This can cause problems with reporting if the information writes to a database because it can cause equivalent records to report as separate entries. Additional spaces can also cause matches to fail. Luckily, several methods from the System.String<\/b> .NET Framework class resolve the problem of additional spaces. The methods are TrimStart<\/b>, TrimEnd<\/b>, and Trim<\/b>. I will examine using the TrimStart<\/b> method first. In the example that follows, a string that contains both leading and trailing spaces is assigned to the $a<\/i> variable. The TrimStart<\/b> method is used to remove leading spaces and the result is stored in the $b<\/i> variable. To show where spaces remain, the Replace<\/b> method replaces spaces with a period. This shows in the following output. <\/p>\n

PS C:\\> $a = ” this is a string  “<\/span><\/p>\n

PS C:\\> $b = $a.TrimStart()<\/span><\/p>\n

PS C:\\> $b.Replace(” “,”.”)<\/span><\/p>\n

this.is.a.string..<\/span><\/p>\n

PS C:\\><\/span><\/p>\n

The TrimEnd<\/b> method works just as the TrimStart<\/b> method does, except that it removes spaces from the end of a string. The string with spaces is assigned to the $a<\/i> variable. The TrimEnd<\/b> method removes spaces from the end of the string and assigns the result to the $b<\/i> variable. Finally, the Replace<\/b> method replaces spaces with periods  so that the spaces are more clearly visualized. The output that follows shows this procedure. <\/p>\n

PS C:\\> $a = ” this is a string  “<\/span><\/p>\n

PS C:\\> $b = $a.TrimEnd()<\/span><\/p>\n

PS C:\\> $b.Replace(” “,”.”)<\/span><\/p>\n

.this.is.a.string<\/span><\/p>\n

PS C:\\><\/span><\/p>\n

The last trim method I want to discuss is the one that I use most frequently. It is the Trim<\/b> method. What I like about the Trim<\/b> method is that it removes leading spaces in addition to trailing spaces. To achieve the same effect, if one did not know about the Trim<\/b> method, would involve calling both the TrimStart<\/b> and the TrimEnd<\/b> methods as shown here. <\/p>\n

PS C:\\> $a = ” this is a string  “<\/span><\/p>\n

PS C:\\> $b = $a.TrimEnd().TrimStart()<\/span><\/p>\n

PS C:\\> $b.Replace(” “,”.”)<\/span><\/p>\n

this.is.a.string<\/span><\/p>\n

PS C:\\><\/span><\/p>\n

In fact, the Trim<\/b> method does the same. It removes leading spaces just as the TrimStart<\/b> method does, and it removes trailing spaces as the TrimEnd<\/b> method does. The following code shows this concept. <\/p>\n

PS C:\\> $a = ” this is a string  “<\/span><\/p>\n

PS C:\\> $b = $a.Trim()<\/span><\/p>\n

PS C:\\> $b.Replace(” “,”.”)<\/span><\/p>\n

this.is.a.string<\/span><\/p>\n

PS C:\\><\/span><\/p>\n

BW, that is all there is to using .NET Framework classes to work with strings. My review of the .NET Framework for Windows PowerShell week will continue tomorrow when I will talk about more how to work with the .NET Framework classes. <\/p>\n

I invite you to follow me on Twitter<\/a> or Facebook<\/a>. If you have any questions, send email to me at scripter@microsoft.com<\/a> or post them on the Official Scripting Guys Forum<\/a>. See you tomorrow. Until then, peace.<\/p>\n

 <\/p>\n

Ed Wilson, Microsoft Scripting Guy<\/b><\/p>\n","protected":false},"excerpt":{"rendered":"

  Summary: Learn how to use .NET Framework classes to work with strings in Windows PowerShell in this Scripting Guys how-to post.   Hey, Scripting Guy! I have been writing VBScript code for years. One thing I really liked about VBScript was the large number of functions that manipulated strings. I know Microsoft seems to […]<\/p>\n","protected":false},"author":595,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[51,3,4,21,45],"class_list":["post-16691","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-getting-started","tag-scripting-guy","tag-scripting-techniques","tag-string-manipulation","tag-windows-powershell"],"acf":[],"blog_post_summary":"

  Summary: Learn how to use .NET Framework classes to work with strings in Windows PowerShell in this Scripting Guys how-to post.   Hey, Scripting Guy! I have been writing VBScript code for years. One thing I really liked about VBScript was the large number of functions that manipulated strings. I know Microsoft seems to […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/16691","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/595"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=16691"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/16691\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=16691"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=16691"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=16691"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}