Encrypt and decrypt data

Here is what you looking for my friend.

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

/// <summary>
/// Encryptor class
/// </summary>
/// <remarks></remarks>
public sealed class Encryptor
{

    #region " Private Static Members "

    private static byte[] _savedKey = null;

    private static byte[] _savedIV = null;

    #endregion

    #region " Private Static Methods "

    /// <summary>
    /// Generate Secret Key and Initial Vector
    /// </summary>
    /// <remarks></remarks>
    private static void generateSecretKeyAndInitVector()
    {
        dynamic keyGen = new Rfc2898DeriveBytes("9be6ee5b-e76b-4d4d-86b9-20284fe6ba96", Encoding.ASCII.GetBytes("8726a597-eabe-4b0a-990f-29956dbb5e4a"));
        _savedKey = keyGen.GetBytes(32);
        _savedIV = keyGen.GetBytes(16);
    }

    #endregion

    #region " Public Static Methods "

    /// <summary>
    /// Encrypt PlainText value
    /// </summary>
    /// <param name="plainText">PlainText value</param>
    /// <returns>CipherText value</returns>
    /// <remarks></remarks>
    public static string Encrypt(string plainText)
    {
        // Encode data string to be stored in memory.
        byte[] plainTextAsBytes = Encoding.ASCII.GetBytes(plainText);
        byte[] cipherTextAsBytes = {
        };

        // Create MemoryStream to contain output.
        using (MemoryStream memStream = new MemoryStream(plainTextAsBytes.Length))
        {
            using (RijndaelManaged rijndael = new RijndaelManaged())
            {

                // Generate and save secret key and init vector.
                generateSecretKeyAndInitVector();

                if (_savedKey == null || _savedIV == null)
                {
                    throw new NullReferenceException("savedKey and savedIV must be non-null.");
                }

                // Create encryptor and stream objects.
                using (ICryptoTransform rdTransform = rijndael.CreateEncryptor((byte[])_savedKey.Clone(), (byte[])_savedIV.Clone()))
                {
                    using (CryptoStream cryptoStream = new CryptoStream(memStream, rdTransform, CryptoStreamMode.Write))
                    {
                        // Write encrypted data to the MemoryStream.
                        cryptoStream.Write(plainTextAsBytes, 0, plainTextAsBytes.Length);
                        cryptoStream.FlushFinalBlock();
                        cipherTextAsBytes = memStream.ToArray();
                    }
                }
            }
        }
        // Convert encrypted string.
        string cipherText = Convert.ToBase64String(cipherTextAsBytes);
        return cipherText;
    }

    /// <summary>
    /// Decrypt CipherText value
    /// </summary>
    /// <param name="cipherText">CipherText value</param>
    /// <returns>Planetext value</returns>
    /// <remarks></remarks>
    public static string Decrypt(string cipherText)
    {
        // Unconvert encrypted string.
        byte[] cipherTextAsBytes = Convert.FromBase64String(cipherText);
        byte[] planeTextAsBytes = new Byte[cipherTextAsBytes.Length];

        // Generate and save secret key and init vector.
        generateSecretKeyAndInitVector();

        using (RijndaelManaged rijndael = new RijndaelManaged())
        {
            using (MemoryStream memStream = new MemoryStream(cipherTextAsBytes))
            {
                if (_savedKey == null || _savedIV == null)
                {
                    throw new NullReferenceException("savedKey and savedIV must be non-null.");
                }

                // Create decryptor, and stream objects.
                using (ICryptoTransform rdTransform = rijndael.CreateDecryptor((byte[])_savedKey.Clone(), (byte[])_savedIV.Clone()))
                {
                    using (CryptoStream cryptoStream = new CryptoStream(memStream, rdTransform, CryptoStreamMode.Read))
                    {
                        // Read in decrypted string as a byte[].
                        cryptoStream.Read(planeTextAsBytes, 0, planeTextAsBytes.Length);
                    }
                }
            }
        }

        // Convert byte[] to string.
        string planeText = Encoding.ASCII.GetString(planeTextAsBytes);
        return planeText;
    }

    #endregion

}

Good luck.

MD5 is a one way hashing algorithm so it cannot be decrypted.

Who told you that you can "decrypt" the hash?! A hashing algorithm cannot be reversed, according to its purpose.

(Also, you should never use MD5 for any security purpose. This algorithm is considered broken. The algorithms of of SHA family is recommended instead. Both are supported by .NET.
See http://en.wikipedia.org/wiki/MD5[^], http://en.wikipedia.org/wiki/SHA2[^].)

This has nothing to do with encryption. Use, for example, RSA; it is perfectly supported by .NET.
See:
http://msdn.microsoft.com/en-us/library/system.security.cryptography.rsa.aspx[^],
http://en.wikipedia.org/wiki/Asymmetric_key_algorithm[^],
http://en.wikipedia.org/wiki/RSA[^].

[EDIT]

RSA is just one example you can use for both encryption and digital signatures. You need to look at System.Security.Cryptography and thoroughly understand the purpose of each tool. See:
http://msdn.microsoft.com/en-us/library/system.security.cryptography.aspx[^].

Start here:
http://msdn.microsoft.com/en-us/library/92f9ye3s.aspx[^].

—SA