The ReverseString method shown in the following example demonstrates the use of the StringBuilder class to reverse a string. If you did not use the StringBuilder class to perform this operation, it would be significantly more expensive in terms of resource utilization, especially as the input string is made longer. The method creates a StringBuilder object of the correct capacity to ensure that no buffer reallocation is required during the reversal operation.

using System;
using System.Text;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_01
    {
        public static string ReverseString(string str)
        {
            // Make sure we have a reversible string.
            if (str == null || str.Length <= 1)
            {
                return str;
            }

            // Create a StringBuilder object with the required capacity.
            StringBuilder revStr = new StringBuilder(str.Length);

            // Loop backward through the source string one character at a time and
            // append each character to StringBuilder.
            for (int count = str.Length - 1; count > −1; count--)
            {
                revStr.Append(str[count]);
            }

            // Return the reversed string.
            return revStr.ToString();
        }

        public static void Main()
        {
            Console.WriteLine(ReverseString("Madam Im Adam"));

            Console.WriteLine(ReverseString(
              "The quick brown fox jumped over the lazy dog."));

// Wait to continue.
            Console.WriteLine("
Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example demonstrates the use of some encoding classes:

using System;
using System.IO;
using System.Text;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_02
    {
        public static void Main()
        {
            // Create a file to hold the output.
            using (StreamWriter output = new StreamWriter("output.txt"))
            {
                // Create and write a string containing the symbol for pi.
                string srcString = "Area = u03A0r^2";
                output.WriteLine("Source Text : " + srcString);

                // Write the UTF-16 encoded bytes of the source string.
                byte[] utf16String = Encoding.Unicode.GetBytes(srcString);
                output.WriteLine("UTF-16 Bytes: {0}",
                    BitConverter.ToString(utf16String));

// Convert the UTF-16 encoded source string to UTF-8 and ASCII.
                byte[] utf8String = Encoding.UTF8.GetBytes(srcString);
                byte[] asciiString = Encoding.ASCII.GetBytes(srcString);

                // Write the UTF-8 and ASCII encoded byte arrays.
                output.WriteLine("UTF-8  Bytes: {0}",
                    BitConverter.ToString(utf8String));
                output.WriteLine("ASCII  Bytes: {0}",
                    BitConverter.ToString(asciiString));

                // Convert UTF-8 and ASCII encoded bytes back to UTF-16 encoded
                // string and write.
                output.WriteLine("UTF-8  Text : {0}",
                    Encoding.UTF8.GetString(utf8String));
                output.WriteLine("ASCII  Text : {0}",
                    Encoding.ASCII.GetString(asciiString));
            }

            // Wait to continue.
            Console.WriteLine("
Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

Running the code will generate a file named output.txt. If you open this file in a text editor that supports Unicode, you will see the following content:

Source Text : Area = πr^2

UTF-16 Bytes: 41-00-72-00-65-00-61-00-20-00-3D-00-20-00-A0-03-72-00-5E-00-32-00

UTF-8  Bytes: 41-72-65-61-20-3D-20-CE-A0-72-5E-32

ASCII  Bytes: 41-72-65-61-20-3D-20-3F-72-5E-32

UTF-8  Text : Area = πr^2

ASCII  Text : Area = ?r^2

Notice that using UTF-16 encoding, each character occupies 2 bytes, but because most of the characters are standard characters, the high-order byte is 0. (The use of little-endian byte ordering means that the low-order byte appears first.) This means that most of the characters are encoded using the same numeric values across all three encoding schemes. However, the numeric value for the symbol pi (emphasized in bold in the preceding output) is different in each of the encodings. The value of pi requires more than 1 byte to represent. UTF-8 encoding uses 2 bytes, but ASCII has no direct equivalent and so replaces pi with the code 3F. As you can see in the ASCII text version of the string, 3F is the symbol for an English question mark (?).

The following example demonstrates the use of BitConverter to convert a bool type and an int type to and from a byte array. The second argument to each of the ToBoolean and ToInt32 methods is a zero-based offset into the byte array where the BitConverter should start taking the bytes to create the data value. The code also shows how to convert a decimal type to a byte array using a MemoryStream object and a BinaryWriter object, as well as how to convert a byte array to a decimal type using a BinaryReader object to read from the MemoryStream object.

using System;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_03
    {
        // Create a byte array from a decimal.
        public static byte[] DecimalToByteArray (decimal src)
        {
            // Create a MemoryStream as a buffer to hold the binary data.
            using (MemoryStream stream = new MemoryStream())
            {
                // Create a BinaryWriter to write binary data to the stream.
                using (BinaryWriter writer = new BinaryWriter(stream))
                {
                    // Write the decimal to the BinaryWriter/MemoryStream.
                    writer.Write(src);

                    // Return the byte representation of the decimal.
                    return stream.ToArray();
                }
            }
        }

        // Create a decimal from a byte array.
        public static decimal ByteArrayToDecimal (byte[] src)
        {
            // Create a MemoryStream containing the byte array.
            using (MemoryStream stream = new MemoryStream(src))
            {
                // Create a BinaryReader to read the decimal from the stream.
                using (BinaryReader reader = new BinaryReader(stream))
                {
                    // Read and return the decimal from the
                    // BinaryReader/MemoryStream.
                    return reader.ReadDecimal();
                }
            }
        }

        public static void Main()

{
            byte[] b = null;

            // Convert a bool to a byte array and display.
            b = BitConverter.GetBytes(true);
            Console.WriteLine(BitConverter.ToString(b));

            // Convert a byte array to a bool and display.
            Console.WriteLine(BitConverter.ToBoolean(b,0));

            // Convert an int to a byte array and display.
            b = BitConverter.GetBytes(3678);
            Console.WriteLine(BitConverter.ToString(b));

            // Convert a byte array to an int and display.
            Console.WriteLine(BitConverter.ToInt32(b,0));

            // Convert a decimal to a byte array and display.
            b = DecimalToByteArray(285998345545.563846696m);
            Console.WriteLine(BitConverter.ToString(b));

            // Convert a byte array to a decimal and display.
            Console.WriteLine(ByteArrayToDecimal(b));

            // Wait to continue.
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The example shown here demonstrates how to Base64 encode and decode a byte array, a Unicode string, an int type, and a decimal type using the Convert class. The DecimalToBase64 and Base64ToDecimal methods rely on the ByteArrayToDecimal and DecimalToByteArray methods listed in recipe 2-3.

using System;
using System.IO;
using System.Text;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_04
    {
        // Create a byte array from a decimal.
        public static byte[] DecimalToByteArray (decimal src)
        {
            // Create a MemoryStream as a buffer to hold the binary data.
            using (MemoryStream stream = new MemoryStream())
            {
                // Create a BinaryWriter to write binary data the stream.
                using (BinaryWriter writer = new BinaryWriter(stream))
                {
                    // Write the decimal to the BinaryWriter/MemoryStream.
                    writer.Write(src);

// Return the byte representation of the decimal.
                    return stream.ToArray();
                }
            }
        }

        // Create a decimal from a byte array.
        public static decimal ByteArrayToDecimal (byte[] src)
        {
            // Create a MemoryStream containing the byte array.
            using (MemoryStream stream = new MemoryStream(src))
            {
                // Create a BinaryReader to read the decimal from the stream.
                using (BinaryReader reader = new BinaryReader(stream))
                {
                    // Read and return the decimal from the
                    // BinaryReader/MemoryStream.
                    return reader.ReadDecimal();
                }
            }
        }

        // Base64 encode a Unicode string.
        public static string StringToBase64 (string src)
        {
            // Get a byte representation of the source string.
            byte[] b = Encoding.Unicode.GetBytes(src);

            // Return the Base64-encoded string.
            return Convert.ToBase64String(b);
        }

        // Decode a Base64-encoded Unicode string.
        public static string Base64ToString (string src)
        {
            // Decode the Base64-encoded string to a byte array.
            byte[] b = Convert.FromBase64String(src);

            // Return the decoded Unicode string.
            return Encoding.Unicode.GetString(b);
        }

        // Base64 encode a decimal.
        public static string DecimalToBase64 (decimal src)
        {
            // Get a byte representation of the decimal.
            byte[] b = DecimalToByteArray(src);

            // Return the Base64-encoded decimal.
            return Convert.ToBase64String(b);
        }

// Decode a Base64-encoded decimal.
        public static decimal Base64ToDecimal (string src)
        {
            // Decode the Base64-encoded decimal to a byte array.
            byte[] b = Convert.FromBase64String(src);

            // Return the decoded decimal.
            return ByteArrayToDecimal(b);
        }

        // Base64 encode an int.
        public static string IntToBase64 (int src)
        {
            // Get a byte representation of the int.
            byte[] b = BitConverter.GetBytes(src);

            // Return the Base64-encoded int.
            return Convert.ToBase64String(b);
        }

        // Decode a Base64-encoded int.
        public static int Base64ToInt (string src)
        {
            // Decode the Base64-encoded int to a byte array.
            byte[] b = Convert.FromBase64String(src);

            // Return the decoded int.
            return BitConverter.ToInt32(b,0);
        }

        public static void Main()
        {
            // Encode and decode a general byte array. Need to create a char[]
            // to hold the Base64-encoded data. The size of the char[] must
            // be at least 4/3 the size of the source byte[] and must be
            // divisible by 4.
            byte[] data = { 0x04, 0x43, 0x5F, 0xFF, 0x0, 0xF0, 0x2D, 0x62, 0x78,
                0x22, 0x15, 0x51, 0x5A, 0xD6, 0x0C, 0x59, 0x36, 0x63, 0xBD, 0xC2,
                0xD5, 0x0F, 0x8C, 0xF5, 0xCA, 0x0C};

char[] base64data =
                new char[(int)(Math.Ceiling((double)data.Length / 3) * 4)];

            Console.WriteLine("
Byte array encoding/decoding");
            Convert.ToBase64CharArray(data, 0, data.Length, base64data, 0);
            Console.WriteLine(new String(base64data));
            Console.WriteLine(BitConverter.ToString(
                Convert.FromBase64CharArray(base64data, 0, base64data.Length)));

             // Encode and decode a string.
            Console.WriteLine(StringToBase64
                ("Welcome to Visual C# Recipes from Apress"));
            Console.WriteLine(Base64ToString("VwBlAGwAYwBvAG0AZQAgAHQAbwA" +
                "gAFYAaQBzAHUAYQBsACAAQwAjACAAUgBlAGMAaQBwAGUAcwAgAGYAcgB" +
                "vAG0AIABBAHAAcgBlAHMAcwA="));

            // Encode and decode a decimal.
            Console.WriteLine(DecimalToBase64(285998345545.563846696m));
            Console.WriteLine(Base64ToDecimal("KDjBUP07BoEPAAAAAAAJAA=="));

            // Encode and decode an int.
            Console.WriteLine(IntToBase64(35789));
            Console.WriteLine(Base64ToInt("zYsAAA=="));

            // Wait to continue.
            Console.WriteLine("
Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The ValidateInput method shown in the following example tests any input string to see if it matches a specified regular expression.

using System;
using System.Text.RegularExpressions;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_05
    {

public static bool ValidateInput(string regex, string input)
        {
            // Create a new Regex based on the specified regular expression.
            Regex r = new Regex(regex);

            // Test if the specified input matches the regular expression.
            return r.IsMatch(input);
        }

        public static void Main(string[] args)
        {
            // Test the input from the command line. The first argument is the
            // regular expression, and the second is the input.
            Console.WriteLine("Regular Expression: {0}", args[0]);
            Console.WriteLine("Input: {0}", args[1]);
            Console.WriteLine("Valid = {0}", ValidateInput(args[0], args[1]));

            // Wait to continue.
            Console.WriteLine("
Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

To execute the example, run Recipe02-05.exe and pass the regular expression and data to test as command-line arguments. For example, to test for a correctly formed e-mail address, type the following:

Recipe02-05 ^[w-]+@([w-]+.)+[w-]+$ [email protected]

The result would be as follows:

Regular Expression: ^[w-]+@([w-]+.)+[w-]+$

Input: [email protected]

Valid = True

This line of code shows how to create a Regex object that is compiled to MSIL instead of the usual intermediate form:

Regex reg = new Regex(@"[w-]+@([w-]+.)+[w-]+", RegexOptions.Compiled);

The following example shows how to create an assembly named MyRegEx.dll, which contains two regular expressions named PinRegex and CreditCardRegex:

using System;
using System.Reflection;
using System.Text.RegularExpressions;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_06
    {

public static void Main()
        {
            // Create the array to hold the Regex info objects.
            RegexCompilationInfo[] regexInfo = new RegexCompilationInfo[2];

            // Create the RegexCompilationInfo for PinRegex.
            regexInfo[0] = new RegexCompilationInfo(@"^d{4}$",
                RegexOptions.Compiled, "PinRegex", "", true);

            // Create the RegexCompilationInfo for CreditCardRegex.
            regexInfo[1] = new RegexCompilationInfo(
                @"^d{4}-?d{4}-?d{4}-?d{4}$",
                RegexOptions.Compiled, "CreditCardRegex", "", true);

            // Create the AssemblyName to define the target assembly.
            AssemblyName assembly = new AssemblyName();
            assembly.Name = "MyRegEx";

            // Create the compiled regular expression
            Regex.CompileToAssembly(regexInfo, assembly);
        }
    }
}

The following example demonstrates the flexibility of the Parse method and the use of the ParseExact method. Refer to the documentation for the System.Globalization.DateTimeFormatInfo class in the .NET Framework SDK document for complete details on all available format specifiers.

using System;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_07
    {
        public static void Main(string[] args)
        {
            string ds1 = "Sep 2005";
            string ds2 = "Monday 5 September 2005 14:15:33";
            string ds3 = "5,9,5";
            string ds4 = "5/9/2005 14:15:33";
            string ds5 = "2:15 PM";

            // 1st September 2005 00:00:00
            DateTime dt1 = DateTime.Parse(ds1);

            // 5th September 2005 14:15:33
            DateTime dt2 = DateTime.Parse(ds2);

// 5th September 2005 00:00:00
            DateTime dt3 = DateTime.Parse(ds3);

            // 5th September 2005 14:15:33
            DateTime dt4 = DateTime.Parse(ds4);

            // Current Date 14:15:00
            DateTime dt5 = DateTime.Parse(ds5);

            // Display the converted DateTime objects.
            Console.WriteLine("String: {0} DateTime: {1}", ds1, dt1);
            Console.WriteLine("String: {0} DateTime: {1}", ds2, dt2);
            Console.WriteLine("String: {0} DateTime: {1}", ds3, dt3);
            Console.WriteLine("String: {0} DateTime: {1}", ds4, dt4);
            Console.WriteLine("String: {0} DateTime: {1}", ds5, dt5);

            // Parse only strings containing LongTimePattern.
            DateTime dt6 = DateTime.ParseExact("2:13:30 PM", "h:mm:ss tt", null);

            // Parse only strings containing RFC1123Pattern.
            DateTime dt7 = DateTime.ParseExact(
                "Mon, 05 Sep 2005 14:13:30 GMT", "ddd, dd MMM yyyy
 HH':'mm':'ss 'GMT'", null);

            // Parse only strings containing MonthDayPattern.
            DateTime dt8 = DateTime.ParseExact("September 05", "MMMM dd", null);

            // Display the converted DateTime objects.
            Console.WriteLine(dt6);
            Console.WriteLine(dt7);
            Console.WriteLine(dt8);

            // Wait to continue.
            Console.WriteLine("
Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example demonstrates the use of operators to manipulate the DateTime and TimeSpan structures:

using System;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_08
    {
        public static void Main()
        {
            // Create a TimeSpan representing 2.5 days.
            TimeSpan timespan1 = new TimeSpan(2, 12, 0, 0);

            // Create a TimeSpan representing 4.5 days.
            TimeSpan timespan2 = new TimeSpan(4, 12, 0, 0);

            // Create a TimeSpan representing 3.2 days.
            // using the static convenience method
            TimeSpan timespan3 = TimeSpan.FromDays(3.2);

            // Create a TimeSpan representing 1 week.
            TimeSpan oneWeek = timespan1 + timespan2;

// Create a DateTime with the current date and time.
            DateTime now = DateTime.Now;

            // Create a DateTime representing 1 week ago.
            DateTime past = now - oneWeek;

            // Create a DateTime representing 1 week in the future.
            DateTime future = now + oneWeek;

            // Display the DateTime instances.
            Console.WriteLine("Now   : {0}", now);
            Console.WriteLine("Past  : {0}", past);
            Console.WriteLine("Future: {0}", future);

            // Use the comparison operators.
            Console.WriteLine("Now is greater than past: {0}", now > past);
            Console.WriteLine("Now is equal to future: {0}", now == future);

            // Wait to continue.
            Console.WriteLine("
Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example demonstrates how to sort an array, a generic List, and an ArrayList:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_09
    {
        public static void Main()
        {
            // Create a new array and populate it.
            int[] array = { 4, 2, 9, 3 };

            // Created a new, sorted array
            array = Enumerable.OrderBy(array, e => e).ToArray<int>();

            // Display the contents of the sorted array.
            foreach (int i in array) {
                Console.WriteLine(i);
            }

            // Create a list and populate it.
            List<string> list = new List<string>();
            list.Add("Michael");
            list.Add("Kate");
            list.Add("Andrea");
            list.Add("Angus");

// Enumerate the sorted contents of the list.
            Console.WriteLine("
List sorted by content");
            foreach (string person in Enumerable.OrderBy(list, e => e))
            {
                Console.WriteLine(person);
            }

            // Sort and enumerate based on a property.
            Console.WriteLine("
List sorted by length property");
            foreach (string person in Enumerable.OrderBy(list, e => e.Length))
            {
                Console.WriteLine(person);
            }

            // Create a new ArrayList and populate it.
            ArrayList arraylist = new ArrayList(4);
            arraylist.Add("Michael");
            arraylist.Add("Kate");
            arraylist.Add("Andrea");
            arraylist.Add("Angus");

            // Sort the ArrayList.
            arraylist.Sort();

            // Display the contents of the sorted ArrayList.
            Console.WriteLine("
Arraylist sorted by content");
            foreach (string s in list) {
                Console.WriteLine(s);
            }

            // Wait to continue.
            Console.WriteLine("
Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

This example demonstrates how to copy the contents of an ArrayList structure to an array using the CopyTo method, and then shows how to use the ToArray method on the ArrayList object.

using System;
using System.Collections;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_10
    {
        public static void Main()
        {
            // Create a new ArrayList and populate it.
            ArrayList list = new ArrayList(5);
            list.Add("Brenda");
            list.Add("George");
            list.Add("Justin");
            list.Add("Shaun");
            list.Add("Meaghan");

            // Create a string array and use the ICollection.CopyTo method
            // to copy the contents of the ArrayList.
            string[] array1 = new string[list.Count];
            list.CopyTo(array1, 0);

// Use ArrayList.ToArray to create an object array from the
            // contents of the collection.
            object[] array2 = list.ToArray();

            // Use ArrayList.ToArray to create a strongly typed string
            // array from the contents of the collection.
            string[] array3 = (string[])list.ToArray(typeof(String));

            // Display the contents of the three arrays.
            Console.WriteLine("Array 1:");
            foreach (string s in array1)
            {
                Console.WriteLine("	{0}",s);
            }

            Console.WriteLine("Array 2:");
            foreach (string s in array2)
            {
                Console.WriteLine("	{0}", s);
            }

            Console.WriteLine("Array 3:");
            foreach (string s in array3)
            {
                Console.WriteLine("	{0}", s);
            }

            // Wait to continue.
            Console.WriteLine("
Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example demonstrates the use of generic collections to create a variety of collections specifically for the management of AssemblyName objects. Notice that you never need to cast to or from the Object type.

using System;
using System.Reflection;
using System.Collections.Generic;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_11
    {
        public static void Main(string[] args)
        {
            // Create an AssemblyName object for use during the example.
            AssemblyName assembly1 = new AssemblyName("com.microsoft.crypto, " +
                "Culture=en, PublicKeyToken=a5d015c7d5a0b012, Version=1.0.0.0");

            // Create and use a Dictionary of AssemblyName objects.
            Dictionary<string,AssemblyName> assemblyDictionary =
                new Dictionary<string,AssemblyName>();

            assemblyDictionary.Add("Crypto", assembly1);

            AssemblyName a1 = assemblyDictionary["Crypto"];

Console.WriteLine("Got AssemblyName from dictionary: {0}", a1);

            // Create and use a List of Assembly Name objects.
            List<AssemblyName> assemblyList = new List<AssemblyName>();

            assemblyList.Add(assembly1);

            AssemblyName a2 = assemblyList[0];

            Console.WriteLine("
Found AssemblyName in list: {0}", a1);

            // Create and use a Stack of Assembly Name objects.
            Stack<AssemblyName> assemblyStack = new Stack<AssemblyName>();

            assemblyStack.Push(assembly1);

            AssemblyName a3 = assemblyStack.Pop();

            Console.WriteLine("
Popped AssemblyName from stack: {0}", a1);

            // Wait to continue.
            Console.WriteLine("
Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example demonstrates a simplified bag implementation that returns those objects put into it at random. A bag is a data structure that can contain zero or more items, including duplicates of items, but does not guarantee any ordering of the items it contains.

using System;
using System.Collections.Generic;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    public class Bag<T>
    {
        // A List to hold the bags's contents. The list must be
        // of the same type as the bag.
        private List<T> items = new List<T>();

        // A method to add an item to the bag.
        public void Add(T item)
        {
            items.Add(item);
        }

        // A method to get a random item from the bag.
        public T Remove()
        {
            T item = default(T);

            if (items.Count != 0)
            {
                // Determine which item to remove from the bag.
                Random r = new Random();
                int num = r.Next(0, items.Count);

                // Remove the item.
                item = items[num];
                items.RemoveAt(num);
            }
            return item;
        }

        // A method to provide an enumerator from the underlying list
        public IEnumerator<T> GetEnumerator()
        {
            return items.GetEnumerator();
        }

        // A method to remove all items from the bag and return them
        // as an array
        public T[] RemoveAll()
        {
            T[] i = items.ToArray();
            items.Clear();
            return i;
        }
    }

public class Recipe02_12
    {
        public static void Main(string[] args)
        {
            // Create a new bag of strings.
            Bag<string> bag = new Bag<string>();

            // Add strings to the bag.
            bag.Add("Darryl");
            bag.Add("Bodders");
            bag.Add("Gary");
            bag.Add("Mike");
            bag.Add("Nigel");
            bag.Add("Ian");

            Console.WriteLine("Bag contents are:");
            foreach (string elem in bag)
            {
                Console.WriteLine("Element: {0}", elem);
            }

            // Take four strings from the bag and display.
            Console.WriteLine("
Removing individual elements");
            Console.WriteLine("Removing = {0}", bag.Remove());
            Console.WriteLine("Removing = {0}", bag.Remove());
            Console.WriteLine("Removing = {0}", bag.Remove());
            Console.WriteLine("Removing = {0}", bag.Remove());

            Console.WriteLine("
Bag contents are:");
            foreach (string elem in bag)
            {
                Console.WriteLine("Element: {0}", elem);
            }

            // Remove the remaining items from the bag.
            Console.WriteLine("
Removing all elements");
            string[] s = bag.RemoveAll();

            Console.WriteLine("
Bag contents are:");
            foreach (string elem in bag)
            {
                Console.WriteLine("Element: {0}", elem);
            }

            // Wait to continue.
            Console.WriteLine("
Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The example shown here demonstrates the use of both BinaryFormatter and SoapFormatter to serialize a System.Collections.ArrayList object containing a list of people to a file. The ArrayList object is then deserialized from the files and the contents displayed to the console.

using System;
using System.IO;
using System.Collections;
using System.Runtime.Serialization.Formatters.Soap;
using System.Runtime.Serialization.Formatters.Binary;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_13
    {
        // Serialize an ArrayList object to a binary file.
        private static void BinarySerialize(ArrayList list)
        {
            using (FileStream str = File.Create("people.bin"))
            {
                BinaryFormatter bf = new BinaryFormatter();
                bf.Serialize(str, list);
            }
        }

        // Deserialize an ArrayList object from a binary file.
        private static ArrayList BinaryDeserialize()
        {
            ArrayList people = null;

            using (FileStream str = File.OpenRead("people.bin"))
            {
                BinaryFormatter bf = new BinaryFormatter();
                people = (ArrayList)bf.Deserialize(str);
            }
            return people;
        }

        // Serialize an ArrayList object to a SOAP file.
        private static void SoapSerialize(ArrayList list)
        {
            using (FileStream str = File.Create("people.soap"))
            {
                SoapFormatter sf = new SoapFormatter();
                sf.Serialize(str, list);
            }
        }

        // Deserialize an ArrayList object from a SOAP file.
        private static ArrayList SoapDeserialize()
        {
            ArrayList people = null;

using (FileStream str = File.OpenRead("people.soap"))
            {
                SoapFormatter sf = new SoapFormatter();
                people = (ArrayList)sf.Deserialize(str);
            }
            return people;
        }

        public static void Main()
        {
            // Create and configure the ArrayList to serialize.
            ArrayList people = new ArrayList();
            people.Add("Graeme");
            people.Add("Lin");
            people.Add("Andy");

            // Serialize the list to a file in both binary and SOAP form.
            BinarySerialize(people);
            SoapSerialize(people);

            // Rebuild the lists of people from the binary and SOAP
            // serializations and display them to the console.
            ArrayList binaryPeople = BinaryDeserialize();
            ArrayList soapPeople = SoapDeserialize();

            Console.WriteLine("Binary people:");
            foreach (string s in binaryPeople)
            {
                Console.WriteLine("	" + s);
            }

            Console.WriteLine("
SOAP people:");
            foreach (string s in soapPeople)
            {
                Console.WriteLine("	" + s);
            }

            // Wait to continue.
            Console.WriteLine("
Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The SOAP file that the example produces is show following. The binary file is not human-readable.

<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-

ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-

ENV="http://schemas.xmlsoap.org/soap/envelope/"

xmlns:clr="http://schemas.microsoft.com/soap/encoding/clr/1.0" SOAP-

ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">

<SOAP-ENV:Body>

<a1:ArrayList id="ref-1" xmlns:a1="
http://schemas.microsoft.com/clr/ns/System.Collections">

<_items href="#ref-2"/>

<_size>3</_size>

<_version>3</_version>

</a1:ArrayList>

<SOAP-ENC:Array id="ref-2" SOAP-ENC:arrayType="xsd:anyType[4]">

<item id="ref-3" xsi:type="SOAP-ENC:string">Graeme</item>

<item id="ref-4" xsi:type="SOAP-ENC:string">Lin</item>

<item id="ref-5" xsi:type="SOAP-ENC:string">Andy</item>

</SOAP-ENC:Array>

</SOAP-ENV:Body>

</SOAP-ENV:Envelope>

The following example serializes a List of strings using a MemoryStream, prints out the resulting JSON, and then deserializes the List in order to print out the contents.

using System;
using System.Collections.Generic;
using System.Runtime.Serialization.Json;
using System.IO;
using System.Text;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_14
    {
        public static void Main()
        {

            // Create a list of strings.
            List<string> myList = new List<string>()
            {
                "apple", "orange", "banana", "cherry"
            };

            // Create memory stream - we will use this
            // to get the JSON serialization as a string.
            MemoryStream memoryStream = new MemoryStream();

            // Create the JSON serializer.
            DataContractJsonSerializer jsonSerializer
                = new DataContractJsonSerializer(myList.GetType());

            // Serialize the list.
            jsonSerializer.WriteObject(memoryStream, myList);

            // Get the JSON string from the memory stream.
            string jsonString = Encoding.Default.GetString(memoryStream.ToArray());

// Write the string to the console.
            Console.WriteLine(jsonString);

            // Create a new stream so we can read the JSON data.
            memoryStream = new MemoryStream(Encoding.Default.GetBytes(jsonString));

            // Deserialize the list.
            myList = jsonSerializer.ReadObject(memoryStream) as List<string>;

            // Enumerate the strings in the list.
            foreach (string strValue in myList)
            {
                Console.WriteLine(strValue);
            }

            // Wait to continue.
            Console.WriteLine("
Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example reads input from the console one character at a time using the ReadKey method. If the user presses F1, the program toggles in and out of "secret" mode, where input is masked by asterisks. When the user presses Esc, the console is cleared and the input the user has entered is displayed. If the user presses Alt+X or Alt+x, the example terminates.

using System;
using System.Collections.Generic;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_15
    {
        public static void Main()
        {
            // Local variable to hold the key entered by the user.
            ConsoleKeyInfo key;

            // Control whether character or asterisk is displayed.
            bool secret = false;

            // Character List for the user data entered.
            List<char> input = new List<char>();

string msg = "Enter characters and press Escape to see input." +
                "
Press F1 to enter/exit Secret mode and Alt-X to exit.";

            Console.WriteLine(msg);

            // Process input until the user enters "Alt+X" or "Alt+x".
            do
            {
                // Read a key from the console. Intercept the key so that it is not
                // displayed to the console. What is displayed is determined later
                // depending on whether the program is in secret mode.
                key = Console.ReadKey(true);

                // Switch secret mode on and off.
                if (key.Key == ConsoleKey.F1)
                {
                    if (secret)
                    {
                        // Switch secret mode off.
                        secret = false;
                    }
                    else
                    {
                        // Switch secret mode on.
                        secret = true;
                    }
                }

                // Handle Backspace.
                if (key.Key == ConsoleKey.Backspace)
                {
                    if (input.Count > 0)
                    {
                        // Backspace pressed, remove the last character.
                        input.RemoveAt(input.Count - 1);

                        Console.Write(key.KeyChar);
                        Console.Write(" ");
                        Console.Write(key.KeyChar);
                    }
                }
                // Handle Escape.
                else if (key.Key == ConsoleKey.Escape)
                {
                    Console.Clear();
                    Console.WriteLine("Input: {0}

",
                        new String(input.ToArray()));
                    Console.WriteLine(msg);
                    input.Clear();
                }
                // Handle character input.

else if (key.Key >= ConsoleKey.A && key.Key <= ConsoleKey.Z)
                {
                    input.Add(key.KeyChar);
                    if (secret)
                    {
                        Console.Write("*");
                    }
                    else
                    {
                        Console.Write(key.KeyChar);
                    }
                }
            } while (key.Key != ConsoleKey.X
                || key.Modifiers != ConsoleModifiers.Alt);

            // Wait to continue.
            Console.WriteLine("

Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example creates a BigInteger with a value that is twice the maximum value of Int64 and then adds another Int64.MaxValue.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Numerics;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe2_16
    {
        static void Main(string[] args)
        {
            // Create a new big integer.
            BigInteger myBigInt = BigInteger.Multiply(Int64.MaxValue, 2);
            // Add another value.
            myBigInt = BigInteger.Add(myBigInt, Int64.MaxValue);
            // Print out the value.
            Console.WriteLine("Big Integer Value: {0}", myBigInt);

            // Wait to continue.
            Console.WriteLine("

Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example defines a class Fruit, which has properties for the name and color of a type of fruit. A List is created and populated with fruits, which are then used as the basis of a LINQ query—the query is performed using keywords and then repeated using lambda expressions.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_17
    {
        static void Main(string[] args)
        {

// Create a list of fruit.
            List<Fruit> myList = new List<Fruit>() {
                new Fruit("apple", "green"),
                new Fruit("orange", "orange"),
                new Fruit("banana", "yellow"),
                new Fruit("mango", "yellow"),
                new Fruit("cherry", "red"),
                new Fruit("fig", "brown"),
                new Fruit("cranberry", "red"),
                new Fruit("pear", "green")
            };

            // Select the names of fruit that isn't red and whose name
            // does not start with the letter "c."
            IEnumerable<string> myResult = from e in myList where e.Color

!= "red" && e.Name[0] != 'c' orderby e.Name select e.Name;

            // Write out the results.
            foreach (string result in myResult)
            {
                Console.WriteLine("Result: {0}", result);
            }

            // Perform the same query using lambda expressions.
            myResult = myList.Where(e => e.Color != "red" && e.Name[0]

!= 'c').OrderBy(e => e.Name).Select(e => e.Name);

            // Write out the results.
            foreach (string result in myResult)
            {
                Console.WriteLine("Lambda Result: {0}", result);
            }

            // Wait to continue.
            Console.WriteLine("

Main method complete. Press Enter");
            Console.ReadLine();
        }
    }

    class Fruit
    {
        public Fruit(string nameVal, string colorVal)
        {
            Name = nameVal;
            Color = colorVal;
        }
        public string Name { get; set; }
        public string Color { get; set; }
    }
}

The following example removes duplicates from a List<Fruit> using a custom implementation of IEqualityComparer passed to the List.Distinct method and prints out the unique items:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Apress.VisualCSharpRecipes.Chapter02
{
    class Recipe02_18
    {
        static void Main(string[] args)
        {

            // Create a list of fruit, including duplicates.
            List<Fruit> myList = new List<Fruit>() {
                new Fruit("apple", "green"),
                new Fruit("apple", "red"),
                new Fruit("orange", "orange"),
                new Fruit("orange", "orange"),
                new Fruit("banana", "yellow"),
                new Fruit("mango", "yellow"),
                new Fruit("cherry", "red"),
                new Fruit("fig", "brown"),
                new Fruit("fig", "brown"),

new Fruit("fig", "brown"),
                new Fruit("cranberry", "red"),
                new Fruit("pear", "green")
            };

            // Use the Distinct method to remove duplicates
            // and print out the unique entries that remain.
            foreach (Fruit fruit in myList.Distinct(new FruitComparer()))
            {
                Console.WriteLine("Fruit: {0}:{1}", fruit.Name, fruit.Color);
            }

            // Wait to continue.
            Console.WriteLine("

Main method complete. Press Enter");
            Console.ReadLine();
        }
    }

    class FruitComparer : IEqualityComparer<Fruit>
    {
        public bool Equals(Fruit first, Fruit second)
        {
            return first.Name == second.Name && first.Color == second.Color;
        }

        public int GetHashCode(Fruit fruit)
        {
            return fruit.Name.GetHashCode() + fruit.Name.GetHashCode();
        }
    }

    class Fruit
    {
        public Fruit(string nameVal, string colorVal)
        {
            Name = nameVal;
            Color = colorVal;
        }
        public string Name { get; set; }
        public string Color { get; set; }
    }
}