• The ReplaceFirst method replaces the first occurrence of “needle” in a string and replaces it with “replacement”.
• The ReplaceAll function is similar: it steps through the string modifying it each time it finds “needle” and replaces it. To avoid a possible infinite loop it first checks whether “needle” is equivalent to “replacement”.

using System;
using System.Collections;

namespace StringItems
{
        static class StringExt
        {
                public static string ReplaceFirst(this string haystack, string needle, string replacement)
                {
                        int pos = haystack.IndexOf(needle);
                        if (pos < 0) return haystack;

                        return haystack.Substring(0,pos) + replacement + haystack.Substring(pos+needle.Length);
                }

                public static string ReplaceAll(this string haystack, string needle, string replacement)
                {
                        int pos;
                        // Avoid a possible infinite loop
                        if (needle == replacement) return haystack;
                        while((pos = haystack.IndexOf(needle))>0)
                                haystack = haystack.Substring(0,pos) + replacement + haystack.Substring(pos+needle.Length);
                        return haystack;
                }

        }
}

Both methods are implemented using a class extension. (for more on creating class extensions see also Finding all occurrences of a string within another string) After you include these methods into your project you can call them directly from any string instance:

string myString = “Hello World”;
string myModifiedString = myString.ReplaceFirst(“World”,”People”);
Console.WriteLine(“{0}”,myModifiedString); // Writes: “Hello People”

An example use of the ReplaceAll method:

string myString = “boo foo is not foo boo or foo boo foo”;
string myModifiedString = myString.ReplaceFirst(“boo”,”goo”);
Console.WriteLine(“{0}”,myModifiedString); // Writes: “goo foo is not foo goo or foo goo foo”;

Why not just use a regular expression?

If you are familiar with the RegEx class in C# you can easily write a regular expression to achieve the same string replacement result:

using System.Text.RegularExpressions;
Regex regex = new Regex(“boo”);
string result = regex.Replace(“boo foo is not foo boo or foo boo foo”, “goo”);

Regular expressions are flexible and if you do anything more complex than just a basic string replacement they are your only choice. But they come at a hefty performance price. To run a regular expression it needs to be compiled first and then executed. The .NET runtime caches the expression for performance but using a regular expression for string replacement is still much slower.

How much slower are regular expressions for string replacement?

In an earlier post I described the Stopwatch class in System.Diagnostics. It is ideal for a little benchmark testing — so lets compare my string replacement methods with the build-in regular expression library:

string haystack = "boo foo is not foo boo or foo boo foo";
string result;
Stopwatch sw = Stopwatch.StartNew();
for (int Lp = 0; Lp < 100000; Lp++)
result = regex.Replace($haystack, "goo");
sw.Stop();
Console.WriteLine("Time used (float): {0} ms",sw.Elapsed.TotalMilliseconds);

And the same for the string replacement functions:

string haystack = "boo foo is not foo boo or foo boo foo";
string result;
Stopwatch sw = Stopwatch.StartNew();
for(int Lp = 0; Lp < 100000; Lp++)
result = haystack.ReplaceAll("boo","goo");
sw.Stop();
Console.WriteLine("Time used (float): {0} ms",sw.Elapsed.TotalMilliseconds);

The regular expression code needed 1100ms , whereas the string replacement code needed just 27ms. So for this particular example, the string replacement was 40 times faster than a regular expression.

This is a post from Martijn's C# Coding Blog.

Because you might want to use this code throughout your project it is implemented as an Extension class. Simply put: the IndexOfAll method is attached to the String class. So if we want to call it we can just use .IndexOfAll(needle)

To be able to define an extension we need to create a static method and put it into a static class. The first parameter of the method identifies the class the method should associate with. In our case: string. We do this by defining it as “this string”.

using System;
using System.Collections;

namespace StringItems
{
    static class StringExt
    {
        public static IEnumerable IndexOfAll(this string haystack, string needle)
        {
            int pos,offset = 0;
            while ((pos = haystack.IndexOf(needle))>0)
            {
                haystack = haystack.Substring(pos+needle.Length);
                offset += pos;
                yield return offset;
            }
        }
    }

    class MainClass
    {
        public static void Main(string[] args)
        {
            string needle = "x";
            string haystack = "3 x 4 = 2 x 6 = 1 x 12";
            foreach(int Pos in haystack.IndexOfAll(needle))
                Console.WriteLine("Offset: {0}",Pos);
        }
    }
}

This is a post from Martijn's C# Coding Blog.

Cutting a string using a delimiter

string Msg = “1997,Ford,E350,Super luxurious truck”;

The String.Split function allows you to specify one or more separators. If we want to cut the above string at each comma we would do the following:

string Msg = "1997,Ford,E350,Super luxurious truck";
string[] Data = Msg.Split(new char[] {','});
int Cnt = 0;
foreach(string Field in Data)
Console.WriteLine("{0} = {1}",Cnt++,Field);

This outputs:

0 = 1997
1 = Ford
2 = E350
3 = Super luxurious truck

The split method takes an array of char[] as its parameter. It is possible to specify more than one separator. So if you would like to split a string on both comma’s and exclamation marks you could do the following:

string Msg = "The world is not enough ! I have one, two, no three! plans for conquering it";
string[] Data = Msg.Split(new char[] {',','!'});

If you specify nothing at all then String.Split() will break on a predefined set of separators. These include spaces (all Unicode defined spaces), line breaks, tabs etc.

If you don’t want the returned array to contain empty strings, you can specify StringSplitOptions.RemoveEmptyEntries

string Msg = "One,Two,,Four,,,Six,,Eight";
string[] Data = Msg.Split(new char[] {','},StringSplitOptions.RemoveEmptyEntries);

Putting things back together again using String.Join()

To quickly put things back together again we just String.Join(), its use is simple: You specify the character you would like to use to join, and pass an array of strings and the first element in the array to use. Lastly it is possible to limit the number of items Joined together.

String[] val = {“ape”,”monkey”,”lion”,”human”,”woman”};
Console.WriteLine(“{0}”, String.Join(“|”,val,0,4));

This results in:

ape|monkey|lion|human

Building a Comma Separated Values (CSV) reader / writer using String.Split and String.Join

Comma Seperated Values files are created by spreadsheets (such as Excel, OpenOffice Calc), databases (Microsoft Access). They are used to quickly transport data between different programs.   As we can now split input, and put it back together again I have created a very simple CSV reader and writer. It can read and write a CSV file and for good measure display to contents on the console.

Note that this reader is very simple, it does not deal with many potential data formatting issues that are perfectly legal for a CSV file. If you intend to import large data sets from databases you will want to create something stronger.

To play with this code the following data set provides a little bit of history on Japanese car manufacturers. It contains the name of the company, its founding year, current number of employees and founders name.

Data.CSV

Toyota,1937,316000,Kiichiro Toyoda
Mazda,1920,39364,Jujiro Matsuda
Honda,1948,167231,Soichiro Honda

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

namespace consoleoutput
{
	class MainClass
	{

		public static ArrayList ReadCSV(string FileName)
		{
			ArrayList DataRows = new ArrayList();

		    // Create a Streamreader and open the file
		    using (StreamReader sr = new StreamReader(FileName))
            {
                String line;
                // Read lines from the file until the end of
                // the file is reached.
                while ((line = sr.ReadLine()) != null)
                {
					// Skip over empty lines
					if (line.Length == 0) continue;

					// Split the line at the comma
					string[] DataColumn = line.Split(new char[] {','});

					// Add the row of data to the ArrayList
					DataRows.Add(DataColumn);
                }
            }

			return DataRows;
		}

		public static void WriteCSV(string FileName, ArrayList CSVData)
		{
		    // Create a StreamWriter and open the file
		    using (StreamWriter sw = new StreamWriter(FileName))
            {
				foreach(string[] CSVRow in CSVData)
				{
					string line = String.Join(",",CSVRow);
					sw.WriteLine(line);
				}
			}
		}

		public static void PrintCVS(ArrayList CSVData)
		{
			foreach(string[] CSVRow in CSVData)
			{
				string line = String.Join(",",CSVRow);
				Console.WriteLine(line);
			}
		}
		public static void Main(string[] args)
		{
			ArrayList myArrayList = ReadCSV("/home/martijn/cars.csv");
			PrintCVS(myArrayList);
			WriteCSV("/home/martijn/output.csv",myArrayList);
		}
	}
}

Image credit: Kacey

This is a post from Martijn's C# Coding Blog.

The complete source code is listed below, but lets have a little look at how it works first.

The problem

I want to take a string, and then encrypt it using a password. The result should be a Base64 encoded string that I can store somewhere relatively safe.

            // The message to encrypt.
            string Msg = "This world is round, not flat, don't believe them!";
            string Password = "secret";

            string EncryptedString = EncryptString(Msg, Password);
            string DecryptedString = DecryptString(EncryptedString, Password);

            Console.WriteLine("Message: {0}",Msg);
            Console.WriteLine("Password: {0}",Password);
            Console.WriteLine("Encrypted string: {0}",EncryptedString);
            Console.WriteLine("Decrypted string: {0}",DecryptedString);

In the EncryptString function we apply the TripleDES algorithm with a 128 bit key. But first we need to turn the above passphrase (‘secret’) into a 128 bit key. One useful coincidence is that the MD5 hash algorithm accepts a set of bytes of any length and turns them into a 128 bit hash. So by running the password through the MD5 hashing algorithm we create our key.

            // Step 1. We hash the passphrase using MD5
            // We use the MD5 hash generator as the result is a 128 bit byte array
            // which is a valid length for the TripleDES encoder we use below

            MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
            byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));

The TripleDES algorithm itself turns a byte array into an encrypted byte array. So we first need to convert our C# message string (which is Unicode encoded) into a byte array through the System.Text.UTF8Encoding encoder.

The key is used to initialize the TripleDES algorithm. In addition we need to specify that we will only encode something once (CipherMode.ECB) and because its unlikely that our source string fits into a single TripleDES block we need to specify how we want to pad any remaining bytes (PaddingMode.PKCS7).

            // Step 2. Create a new TripleDESCryptoServiceProvider object
            TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();

            // Step 3. Setup the encoder
            TDESAlgorithm.Key = TDESKey;
            TDESAlgorithm.Mode = CipherMode.ECB;
            TDESAlgorithm.Padding = PaddingMode.PKCS7;

The encrypted byte array is finally converted into a Base64 encoded string for easy storage. The DecryptString function is very similar to the encryption function, except that it turns the Base64 encoded encrypted message back into the original UTF8 string.

Drawbacks to the above method

To keep the code above straightforward we made use of the fact that an MD5 hash is exactly 128 bits in length. The C# TripleDES code accepts three possible key lengths: 64 bit, 128 bit and 192 bit. Only 192 bit keys are truly TripleDES, the 128 bit key length we obtain from the MD5 hash is only sufficient for Double DES. According to Wikipedia, that would make its real key strength only equivalent to 80 bits.

The Source code

using System;
using System.Text;
using System.Security.Cryptography;

namespace EncryptStringSample
{
    class MainClass
    {

        public static string EncryptString(string Message, string Passphrase)
        {
            byte[] Results;
            System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();

            // Step 1. We hash the passphrase using MD5
            // We use the MD5 hash generator as the result is a 128 bit byte array
            // which is a valid length for the TripleDES encoder we use below

            MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
            byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));

            // Step 2. Create a new TripleDESCryptoServiceProvider object
            TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();

            // Step 3. Setup the encoder
            TDESAlgorithm.Key = TDESKey;
            TDESAlgorithm.Mode = CipherMode.ECB;
            TDESAlgorithm.Padding = PaddingMode.PKCS7;

            // Step 4. Convert the input string to a byte[]
            byte[] DataToEncrypt = UTF8.GetBytes(Message);

            // Step 5. Attempt to encrypt the string
            try
            {
                ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
                Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length);
            }
            finally
            {
                // Clear the TripleDes and Hashprovider services of any sensitive information
                TDESAlgorithm.Clear();
                HashProvider.Clear();
            }

            // Step 6. Return the encrypted string as a base64 encoded string
            return Convert.ToBase64String(Results);
        }

        public static string DecryptString(string Message, string Passphrase)
        {
            byte[] Results;
            System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();

            // Step 1. We hash the passphrase using MD5
            // We use the MD5 hash generator as the result is a 128 bit byte array
            // which is a valid length for the TripleDES encoder we use below

            MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
            byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));

            // Step 2. Create a new TripleDESCryptoServiceProvider object
            TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();

            // Step 3. Setup the decoder
            TDESAlgorithm.Key = TDESKey;
            TDESAlgorithm.Mode = CipherMode.ECB;
            TDESAlgorithm.Padding = PaddingMode.PKCS7;

            // Step 4. Convert the input string to a byte[]
            byte[] DataToDecrypt = Convert.FromBase64String(Message);

            // Step 5. Attempt to decrypt the string
            try
            {
                ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor();
                Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
            }
            finally
            {
                // Clear the TripleDes and Hashprovider services of any sensitive information
                TDESAlgorithm.Clear();
                HashProvider.Clear();
            }

            // Step 6. Return the decrypted string in UTF8 format
            return UTF8.GetString( Results );
        }

        public static void Main(string[] args)
        {
            // The message to encrypt.
            string Msg = "This world is round, not flat, don't believe them!";
            string Password = "secret";

            string EncryptedString = EncryptString(Msg, Password);
            string DecryptedString = DecryptString(EncryptedString, Password);

            Console.WriteLine("Message: {0}",Msg);
            Console.WriteLine("Password: {0}",Password);
            Console.WriteLine("Encrypted string: {0}",EncryptedString);
            Console.WriteLine("Decrypted string: {0}",DecryptedString);
        }
    }
}

This is a post from Martijn's C# Coding Blog.