StringBuilder F# snippets (dotnet#8866)

Author: albert-du

snippets/fsharp/System.Text/StringBuilder/.ctor/constructors.fs

@@ -0,0 +1,102 @@
+// This sample demonstrates how to use each member of the StringBuilder class.
+//<Snippet2>
+open System.Text
+
+let constructorWithNothing () =
+    // Initialize a new StringBuilder object.
+    //<Snippet1>
+    let stringBuilder = StringBuilder()
+    //</Snippet1>
+    ()
+
+let constructorWithCapacity () =
+    // Initialize a new StringBuilder object with the specified capacity.
+    //<Snippet3>
+    let capacity = 255
+    let stringBuilder = StringBuilder capacity
+    //</Snippet3>
+    ()
+
+let constructorWithString () =
+    // Initialize a new StringBuilder object with the specified string.
+    //<Snippet4>
+    let initialString = "Initial string."
+    let stringBuilder = StringBuilder initialString
+    //</Snippet4>
+    ()
+
+let constructorWithCapacityAndMax () =
+    // Initialize a new StringBuilder object with the specified capacity
+    // and maximum capacity.
+    //<Snippet5>
+    let capacity = 255
+    let maxCapacity = 1024
+    let stringBuilder = StringBuilder(capacity, maxCapacity)
+    //</Snippet5>
+    ()
+
+let constructorWithSubstring () =
+    // Initialize a new StringBuilder object with the specified substring.
+    //<Snippet6>
+    let initialString = "Initial string for stringbuilder."
+    let startIndex = 0
+    let substringLength = 14
+    let capacity = 255
+
+    let stringBuilder =
+        StringBuilder(initialString, startIndex, substringLength, capacity)
+    //</Snippet6>
+    ()
+
+let constructorWithStringAndMax () =
+    // Initialize a new StringBuilder object with the specified string
+    // and maximum capacity.
+    //<Snippet7>
+    let initialString = "Initial string. "
+    let capacity = 255
+    let stringBuilder = StringBuilder(initialString, capacity)
+    //</Snippet7>
+
+    // Ensure that appending the specified string will not exceed the
+    // maximum capacity of the object.
+    //<Snippet8>
+    let phraseToAdd = "Sentence to be appended."
+
+    if (stringBuilder.Length + phraseToAdd.Length) <= stringBuilder.MaxCapacity then
+        stringBuilder.Append phraseToAdd |> ignore
+    //</Snippet8>
+
+    // Retrieve the string value of the StringBuilder object.
+    //<Snippet9>
+    let builderResults = stringBuilder.ToString()
+    // let builderResults = string stringBuilder
+    //</Snippet9>
+
+    // Retrieve the last 10 characters of the StringBuilder object.
+    //<Snippet10>
+    let sentenceLength = 10
+    let startPosition = stringBuilder.Length - sentenceLength
+    let endPhrase = stringBuilder.ToString(startPosition, sentenceLength)
+    //</Snippet10>
+
+    // Retrieve the last character of the StringBuilder object.
+    //<Snippet11>
+    let lastCharacterPosition = stringBuilder.Length - 1
+    let lastCharacter = stringBuilder[lastCharacterPosition]
+    //</Snippet11>
+    ()
+
+constructorWithNothing ()
+constructorWithCapacity ()
+constructorWithString ()
+constructorWithCapacityAndMax ()
+constructorWithSubstring ()
+constructorWithStringAndMax ()
+
+printfn "This sample completed successfully press Enter to exit."
+stdin.ReadLine() |> ignore
+
+// This sample produces the following output:
+//
+// This sample completed successfully press Enter to exit.
+//</Snippet2>

snippets/fsharp/System.Text/StringBuilder/.ctor/fs.fsproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net7.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="constructors.fs" />
+  </ItemGroup>
+</Project>

snippets/fsharp/System.Text/StringBuilder/Append/append2.fs

@@ -0,0 +1,123 @@
+module append2
+
+open System
+open System.Text
+
+let appendBool () =
+    // <Snippet2>
+    let flag = false
+    let sb = StringBuilder()
+    sb.Append("The value of the flag is ").Append(flag).Append "." |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //       The value of the flag is False.
+    // </Snippet2>
+
+let appendByte () =
+    // <Snippet3>
+    let bytes = [| 16uy; 132uy; 27uy; 253uy |]
+    let sb = StringBuilder()
+
+    for value in bytes do
+        sb.Append(value).Append " " |> ignore
+
+    printfn $"The byte array: {sb}"
+    // The example displays the following output:
+    //         The byte array: 16 132 27 253
+    // </Snippet3>
+
+let appendChar () =
+    // <Snippet4>
+    let str = "Characters in a string."
+    let sb = StringBuilder()
+
+    for ch in str do
+        sb.Append(" '").Append(ch).Append "' " |> ignore
+
+    printfn "Characters in the string:"
+    printfn $"  {sb}"
+    // The example displays the following output:
+    //    Characters in the string:
+    //       'C'  'h'  'a'  'r'  'a'  'c'  't'  'e'  'r'  's'  ' '  'i'  'n'  ' '  'a'  ' '  's'  't' 'r'  'i'  'n'  'g'  '.'
+    // </Snippet4>
+
+let appendMultipleChars () =
+    // <Snippet5>
+    let value = 1346.19m
+    let sb = StringBuilder()
+    sb.Append('*', 5).AppendFormat("{0:C2}", value).Append('*', 5) |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //       *****$1,346.19*****
+    // </Snippet5>
+
+let appendCharArray () =
+    // <Snippet6>
+    let chars = [| 'a'; 'e'; 'i'; 'o'; 'u' |]
+    let sb = StringBuilder()
+    sb.Append("The characters in the array: ").Append chars |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //      The characters in the array: aeiou
+    // </Snippet6>
+
+let appendPartialCharArray () =
+    // <Snippet7>
+    let chars = [| 'a'; 'b'; 'c'; 'd'; 'e' |]
+    let sb = StringBuilder()
+    let startPosition = Array.IndexOf(chars, 'a')
+    let endPosition = Array.IndexOf(chars, 'c')
+
+    if startPosition >= 0 && endPosition >= 0 then
+        sb
+            .Append("The array from positions ")
+            .Append(startPosition)
+            .Append(" to ")
+            .Append(endPosition)
+            .Append(" contains ")
+            .Append(chars, startPosition, endPosition + 1)
+            .Append "."
+        |> ignore
+
+        printfn $"{sb}"
+    // The example displays the following output:
+    //       The array from positions 0 to 2 contains abc.
+    // </Snippet7>
+
+let appendDecimal () =
+    // <Snippet8>
+    let value = 1346.19m
+    let sb = StringBuilder()
+    sb.Append('*', 5).Append(value).Append('*', 5) |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //       *****1346.19*****
+    // </Snippet8>
+
+let appendDouble () =
+    // <Snippet9>
+    let value = 1034769.47
+    let sb = StringBuilder()
+    sb.Append('*', 5).Append(value).Append('*', 5) |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //       *****1034769.47*****
+    // </Snippet9>
+
+
+appendBool ()
+printfn "-----"
+appendByte ()
+printfn "-----"
+appendChar ()
+printfn "-----"
+appendMultipleChars ()
+printfn "-----"
+appendCharArray ()
+printfn "-----"
+appendPartialCharArray ()
+printfn "-----"
+appendDecimal ()
+printfn "-----"
+appendDouble ()
+printfn "-----"

snippets/fsharp/System.Text/StringBuilder/Append/append3.fs

@@ -0,0 +1,120 @@
+module append3
+
+open System
+open System.Text
+
+let appendInt16 () =
+    // <Snippet10>
+    let sb = StringBuilder "The range of a 16-bit integer: "
+    sb.Append(Int16.MinValue).Append(" to ").Append Int16.MaxValue |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //       The range of a 16-bit integer: -32768 to 32767
+    // </Snippet10>
+
+let appendInt32 () =
+    // <Snippet11>
+    let sb = StringBuilder "The range of a 32-bit integer: "
+    sb.Append(Int32.MinValue).Append(" to ").Append Int32.MaxValue |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //       The range of a 32-bit integer: -2147483648 to 2147483647
+    // </Snippet11>
+
+let appendInt64 () =
+    // <Snippet12>
+    let sb = StringBuilder "The range of a 64-bit integer: "
+    sb.Append(Int64.MinValue).Append(" to ").Append Int64.MaxValue |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //       The range of a 64-bit integer:  -9223372036854775808 to 9223372036854775807
+    // </Snippet12>
+
+let appendSByte () =
+    // <Snippet13>
+    let sb = StringBuilder "The range of an 8-bit signed integer: "
+    sb.Append(SByte.MinValue).Append(" to ").Append SByte.MaxValue |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //       The range of an 8-bit unsigned integer: -128 to 127
+    // </Snippet13>
+
+let appendSingle () =
+    // <Snippet14>
+    let value = 1034769.47f
+    let sb = StringBuilder()
+    sb.Append('*', 5).Append(value).Append('*', 5) |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //       *****1034769.47*****
+    // </Snippet14>
+
+let appendUInt16 () =
+    // <Snippet15>
+    let sb = StringBuilder "The range of a 16-bit unsigned integer: "
+    sb.Append(UInt16.MinValue).Append(" to ").Append UInt16.MaxValue |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //       The range of a 16-bit unsigned integer: 0 to 65535
+    // </Snippet15>
+
+let appendUInt32 () =
+    // <Snippet16>
+    let sb = StringBuilder "The range of a 32-bit unsigned integer: "
+    sb.Append(UInt32.MinValue).Append(" to ").Append UInt32.MaxValue |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //       The range of a 32-bit unsigned integer: 0 to 4294967295
+    // </Snippet16>
+
+let appendUInt64 () =
+    // <Snippet17>
+    let sb = StringBuilder "The range of a 64-bit unsigned integer: "
+    sb.Append(UInt64.MinValue).Append(" to ").Append UInt64.MaxValue |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //       The range of a 64-bit unsigned integer: 0 to 18446744073709551615
+    // </Snippet17>
+
+let appendString () =
+    // <Snippet19>
+    let str = "First;George Washington;1789;1797"
+    let mutable index = 0
+    let sb = StringBuilder()
+    let length = str.IndexOf(';', index)
+
+    sb.Append(str, index, length).Append " President of the United States: "
+    |> ignore
+
+    index <- index + length + 1
+    let length = str.IndexOf(';', index) - index
+    sb.Append(str, index, length).Append ", from " |> ignore
+    index <- index + length + 1
+    let length = str.IndexOf(';', index) - index
+    sb.Append(str, index, length).Append " to " |> ignore
+    index <- index + length + 1
+    sb.Append(str, index, str.Length - index) |> ignore
+    printfn $"{sb}"
+    // The example displays the following output:
+    //    First President of the United States: George Washington, from 1789 to 1797
+    // </Snippet19>
+
+
+appendInt16 ()
+printfn "---"
+appendInt32 ()
+printfn "---"
+appendInt64 ()
+printfn "---"
+appendSByte ()
+printfn "---"
+appendSingle ()
+printfn "---"
+appendUInt16 ()
+printfn "---"
+appendUInt32 ()
+printfn "---"
+appendUInt64 ()
+printfn "---"
+appendString ()
+printfn "---"

snippets/fsharp/System.Text/StringBuilder/Append/append4.fs

@@ -0,0 +1,16 @@
+module append4
+// <Snippet18>
+open System.Text
+
+type Dog(name: string, breed: string) =
+    member _.Name = name
+    member _.Breed = breed
+    override _.ToString() = name
+
+let dog1 = Dog("Yiska", "Alaskan Malamute")
+let sb = StringBuilder()
+sb.Append(dog1).Append(", Breed: ").Append dog1.Breed |> printfn "%O"
+
+// The example displays the following output:
+//        Yiska, Breed: Alaskan Malamute
+// </Snippet18>

snippets/fsharp/System.Text/StringBuilder/Append/fs.fsproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net7.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="append2.fs" />
+    <Compile Include="append3.fs" />
+    <Compile Include="append4.fs" />
+  </ItemGroup>
+</Project>