I used a very similar method when writing my instant messenger client/server. There is some overhead but when weighed out against it’s simplcity its very minimal. If you would like you can download the entire sample project or view the code through this website.

Download Sample Project – View Code

//Code

Imports System.Runtime.CompilerServices
Imports System.Text
Imports System.Data

''' <summary>
''' EXTENDS DATASETS AND DATATABLES TO GIVE THEM THE ABILITY TO EXPORT TO CSV FORMATTED FILES
''' </summary>
Module DataExtensions

    ''' <summary>
    ''' EXPORTS A DATATABLE INTO A CSV FORMATTED FILE
    ''' </summary>
    ''' <param name="tmpTable">INPUT DATATABLE TO CONVERT TO CSV</param>
    ''' <param name="showNull">DISPLAY NULL IN EVENT OF NULL OR BLANK LINE</param>
    ''' <returns>RETURNS A CSV FORMATTED STRING WHICH CAN BE WRITTEN TO A FILE</returns>
    <Extension()> _
    Public Function ToCSV(ByVal tmpTable As DataTable, ByVal showNull As Boolean) As String
        Dim tmpResult As New StringBuilder()

        'INSERT THE COLUMN HEADERS INTO THE RETURN
        For Each tmpCcol As DataColumn In tmpTable.Columns
            tmpResult.Append(String.Format("""{0}"",", tmpCcol.ColumnName))
        Next
        tmpResult.AppendLine()

        'INSERT EACH ROWS LINE INTO THE RETURN
        For Each tmpRow As DataRow In tmpTable.Rows
            Dim tmpLine As New StringBuilder()
            For Each tmpCcol As DataColumn In tmpTable.Columns
                If (Not IsDBNull(tmpRow(tmpCcol.ColumnName))) Then
                    tmpLine.Append(String.Format("""{0}"",", tmpRow(tmpCcol.ColumnName)))
                Else
                    'IF THE USER WANTS TO SEE NULL THEN DISPLAY IT, OTHERWISE JUST A BLANK SPOT
                    If showNull Then
                        tmpLine.Append("""NULL"",")
                    Else
                        tmpLine.Append(",")
                    End If
                End If
            Next

            'APPEND THE ROW TO THE OVERALL RESULT TABLE
            tmpResult.AppendLine(tmpLine.ToString().Substring(0, tmpLine.Length - 1))
        Next

        'RETURN THE TABLE STRING
        Return tmpResult.ToString()
    End Function

    ''' <summary>
    ''' EXPORTS A DATASET INTO AN ARRAY OF CSV FORMATTED FILES
    ''' </summary>
    ''' <param name="tmpData">INPUT DATASET TO BE CONVERTED INTO CSV FILES</param>
    ''' <param name="showNull">DISPLAY NULL IN EVENT OF NULL OR BLANK LINE</param>
    ''' <returns>RETURNS A CSV FORMATTED STRING ARRAY WHICH CAN BE WRITTEN TO A SERIES OF FILES</returns>
    <Extension()> _
    Public Function ToCSV(ByVal tmpData As DataSet, ByVal showNull As Boolean) As String()
        Dim result(tmpData.Tables.Count - 1) As String

        For I As Integer = 0 To tmpData.Tables.Count - 1
            'STORE THE RETURN OF EACH TABLE INTO THE ARRAY
            result(I) = tmpData.Tables(I).ToCSV(showNull)
        Next

        'RETURN THE FULL RESULT
        Return result
    End Function

End Module

//Code

/// <summary>
/// RETURNS AN XML NODE WHICH CONTAINS ALL THE PROPERTIES FOR A LIST OF BASIC TYPES
/// </summary>
/// <typeparam name="t">PARAMETER TYPE WITHIN THE LIST</typeparam>
/// <param name="obj">INCOMING LIST TO ITERATE THROUGH</param>
/// <param name="ElementName">ROOT ELEMENT NAME TO CREATE</param>
/// <returns>AN XML NODE WHICH CONTAINS ALL THE PROPERTIES FOR A LIST OF BASIC TYPES</returns>
public static XElement CreateXMLNode<t>(this IEnumerable<t> obj, string ElementName)
{
    //NODE WHICH WILL BE RETURNED TO THE CALLING FUNCTION
    XElement tmpReturn = new XElement(ElementName);

    //LOOP THROUGH ALL THE INTERNAL OBJECTS TO ADD NODES TO THE ROOT
    foreach (object tmpObj in obj)
    {
        //TEMP NODE REPRESENTING THE PROPERTY ELEMENT
        XElement tmpNode = new XElement(tmpObj.GetType().Name.ToString());

        //LOOP THROUGH ALL THE FIELDS WHICH ARE PUBLIC
        foreach (FieldInfo tmpField in tmpObj.GetType().GetFields())
        {
            XElement tmpElement = new XElement(tmpField.Name);

            //IF THE FIELD IS PUBLIC THEN ADD THE FIELD TO THE NODE
            if (tmpField.IsPublic)
            {
                tmpElement.Value = tmpField.GetValue(tmpObj).ToString();
                tmpNode.Add(tmpElement);
            }
        }

        //LOOP THROUGH ALL THE PROPERTIES WHICH ARE PUBLIC
        foreach (PropertyInfo tmpProp in tmpObj.GetType().GetProperties())
        {
            XElement tmpElement = new XElement(tmpProp.Name);

            //ADD THE ELEMENT TO THE NODE
            tmpElement.Value = tmpProp.GetValue(tmpObj, null).ToString();
            tmpNode.Add(tmpElement);
        }

        //RETURN THE ROOT NODE TO THE CALLING FUNCTION
        tmpReturn.Add(tmpNode);
    }

    return tmpReturn;
}

//Usage

class Program
{
    static void Main(string[] args)
    {
        //CREATE A LIST OF CLASSES
        List<MyClass> tmpList1 = new List<MyClass>();
        tmpList1.Add(new MyClass() { EmployeeName = "Emp 1", Address = "Add 1", Salary = 100000 });
        tmpList1.Add(new MyClass() { EmployeeName = "Emp 2", Address = "Add 2", Salary = 50000 });
        tmpList1.Add(new MyClass() { EmployeeName = "Emp 3", Address = "Add 3", Salary = 65000 });
        tmpList1.Add(new MyClass() { EmployeeName = "Emp 4", Address = "Add 4", Salary = 80000 });

        //CREATE A LIST OF STRUCTS
        List<MyStruct> tmpList2 = new List<MyStruct>();
        tmpList2.Add(new MyStruct() { EmployeeName = "Emp 1", Address = "Add 1", Salary = 100000 });
        tmpList2.Add(new MyStruct() { EmployeeName = "Emp 2", Address = "Add 2", Salary = 50000 });
        tmpList2.Add(new MyStruct() { EmployeeName = "Emp 3", Address = "Add 3", Salary = 65000 });
        tmpList2.Add(new MyStruct() { EmployeeName = "Emp 4", Address = "Add 4", Salary = 80000 });

        //CREATE XML NODE CONTAINING THE LIST OF OBJECTS CREATED ABOVE
        XElement root1 = tmpList1.CreateXMLNode("MyList_Of_Classes");
        XElement root2 = tmpList2.CreateXMLNode("MyList_Of_Structs");
    }
}

//BASIC CLASS CONTAINING PUBLIC PROPERTIES
class MyClass
{
    public string EmployeeName { get; set; }
    public string Address { get; set; }
    public double Salary { get; set; }
}

//BASIC STRUCTURE CONTAINING PUBLIC FIELDS
struct MyStruct
{
    public string EmployeeName;
    public string Address;
    public double Salary;
}

//Output

<MyList_Of_Classes>
  <MyClass>
    <EmployeeName>Emp 1</EmployeeName>
    <Address>Add 1</Address>
    <Salary>100000</Salary>
  </MyClass>
  <MyClass>
    <EmployeeName>Emp 2</EmployeeName>
    <Address>Add 2</Address>
    <Salary>50000</Salary>
  </MyClass>
  <MyClass>
    <EmployeeName>Emp 3</EmployeeName>
    <Address>Add 3</Address>
    <Salary>65000</Salary>
  </MyClass>
  <MyClass>
    <EmployeeName>Emp 4</EmployeeName>
    <Address>Add 4</Address>
    <Salary>80000</Salary>
  </MyClass>
</MyList_Of_Classes>

<MyList_Of_Structs>
  <MyStruct>
    <EmployeeName>Emp 1</EmployeeName>
    <Address>Add 1</Address>
    <Salary>100000</Salary>
  </MyStruct>
  <MyStruct>
    <EmployeeName>Emp 2</EmployeeName>
    <Address>Add 2</Address>
    <Salary>50000</Salary>
  </MyStruct>
  <MyStruct>
    <EmployeeName>Emp 3</EmployeeName>
    <Address>Add 3</Address>
    <Salary>65000</Salary>
  </MyStruct>
  <MyStruct>
    <EmployeeName>Emp 4</EmployeeName>
    <Address>Add 4</Address>
    <Salary>80000</Salary>
  </MyStruct>
</MyList_Of_Structs>

//Code

        /// <summary>
        /// TRUNCATES A STRING PREFERRING WHOLE WORD OVER NON WHOLE WORD
        /// </summary>
        /// <param name="s">INCOMING STRING TO TRUNCATE</param>
        /// <param name="len">LENGTH IN WHICH TO TRUNCATE TO</param>
        /// <param name="postTruncate">ANYTHING TO ADD TO A TRUNCATED STRING SUCH AS ...</param>
        /// <returns>TRUNCATED STRING WITH POST TRUNCATE ADDED TO IT</returns>
        public static string Truncate(this string s, int len, string postTruncate)
        {
            //IF THE STRING IS SMALLER THEN THE LENGTH JUST RETURN THE STRING
            if (s == null || s.Length < len)
                return s;
            else
            {
                //INCASE NULL HAS BEEN PASSED IN CHANGE IT TO EMPTY STRING SO IT HAS A COUNT
                if (postTruncate == null)
                    postTruncate = string.Empty;

                //RETURN THE TRUNCATED STRING BACK TO CALLING FUNCTION
                string tmpReturn = string.Concat(Regex.Match(String.Concat(s, " "), string.Format("^(?<tmpMatch>.{{0,{0}}})\\s", len)).Groups["tmpMatch"].Value, postTruncate);

                //IF THE WHOLE WORD TRUNCATE WORKED THEN USE IT OTHERWISE USE NON WHOLE WORD TRUNCATE
                if (tmpReturn != postTruncate)
                    return tmpReturn;
                else
                    return string.Concat(Regex.Match(String.Concat(s, " "), string.Format("^(?<tmpMatch>.{{0,{0}}})", len)).Groups["tmpMatch"].Value, postTruncate);
            }
        }

//Usage

    class Program
    {
        static void Main(string[] args)
        {
            //OUTPUT WILL BE "Hello, World..."
            Console.WriteLine("Hello, World this is some long text to truncate".Truncate(15, "..."));
            Console.ReadLine();
        }
    }

//Code

        /// <summary>
        /// MAIN TO HUMAN READABLE FUNCTION TO CONVERT DOUBLES INTO XB, XKB, XMB, XGB
        /// </summary>
        /// <param name="x">INCOMING NUMBER TO MAKE READABLE</param>
        /// <returns>HUMAN READABLE SIZE FORMAT SUCH AS 1MB</returns>
        public static string ToHumanReadable(this double x)
        {
            //CONSTANTS FOR SIZING
            double KB = 1024;
            double MB = 1024 * KB;
            double GB = 1024 * MB;

            if (x < KB)
                return string.Format("{0}B", x);
            else if (x < MB)
            {
                return string.Format("{0:0.##}KB", x / KB);
            }
            else if (x < GB)
            {
                return string.Format("{0:0.##}MB", x / MB);
            }
            else if (x >= GB)
            {
                return string.Format("{0:0.##}GB", x / GB);
            }
            else
            {
                //HACK: GET RID OF COMPILER ERROR BECAUSE IT BELEIVES NOT ALL PATHS RETURN A VALUE
                return null;
            }
        }

        /// <summary>
        /// EXTENSION FOR LONG TO MAKE HUMAN READABLE
        /// </summary>
        /// <param name="x">INCOMING NUMBER TO MAKE READABLE</param>
        /// <returns>HUMAN READABLE SIZE FORMAT SUCH AS 1MB</returns>
        public static string ToHumanReadable(this long x)
        {
            return ToHumanReadable((double)x);
        }

        /// <summary>
        /// EXTENSION FOR INT TO MAKE HUMAN READABLE
        /// </summary>
        /// <param name="x">INCOMING NUMBER TO MAKE READABLE</param>
        /// <returns>HUMAN READABLE SIZE FORMAT SUCH AS 1MB</returns>
        public static string ToHumanReadable(this int x)
        {
            return ToHumanReadable((double)x);
        }

        /// <summary>
        /// EXTENSION FOR SINGLE TO MAKE HUMAN READABLE
        /// </summary>
        /// <param name="x">INCOMING NUMBER TO MAKE READABLE</param>
        /// <returns>HUMAN READABLE SIZE FORMAT SUCH AS 1MB</returns>
        public static string ToHumanReadable(this Single x)
        {
            return ToHumanReadable((double)x);
        }

//Code

        /// <summary>
        /// ENCRYPTS A STRING USING AES ENCRYPTION AND A PASSWORD
        /// </summary>
        /// <param name="s">INCOMING STRING TO ENCRYPT</param>
        /// <param name="password">PASSWORD TO USE FOR ENCRYPTION</param>
        /// <returns>BASE64 ENCODED ENCRYPTED STRING</returns>
        public static string EncryptString(this string s, string password)
        {
            //CREATE AN AES CRYPTOGRAPHY CLASS
            using (Aes tmpAes = AesCryptoServiceProvider.Create())
            {
                //CREATE A PASSWORD DERIVED BYTES CLASS TO CONVERT A SIMPLE PASSWORD INTO SOMETHING MORE COMPLEX
                PasswordDeriveBytes tmpPasswordBytes = new PasswordDeriveBytes(password.ToByteArray(), password.Reverse().ToByteArray());

                //CREATE A ICRYPTO TRANSFORM PROVIDER USING 256 BITS FOR THE KEY WHICH IS DERIVED FROM THE PASSWORD PASSED IN
                using (ICryptoTransform tmpCrypto = tmpAes.CreateEncryptor(tmpPasswordBytes.GetBytes(256 / 8), tmpPasswordBytes.GetBytes(16)))
                {
                    //CREATE A TEMPORARY MEMORY STREAM TO HOLD THE DATA WHICH IS BEING ENCRYPTED
                    using (MemoryStream tmpMemoryStream = new MemoryStream())
                    {
                        //CREATE THE CRYPTO STREAM WHICH WILL WRITE TO THE UNDERLYING MEMORY STREAM
                        using (CryptoStream tmpStream = new CryptoStream(tmpMemoryStream, tmpCrypto, CryptoStreamMode.Write))
                        {
                            tmpStream.Write(s.ToByteArray(), 0, s.Length);
                            tmpStream.Flush();
                        }

                        //CONVERT THE DATA TO A BASE64 STRING SO WE HAVE ALL VALID CHARACTERS IN THE STRING
                        return Convert.ToBase64String(tmpMemoryStream.ToArray());
                    }
                }
            }
        }

        /// <summary>
        /// DECRYPTS A BASE64 ENCODED STRING USING AES AND PASSWORD
        /// </summary>
        /// <param name="s">INCOMING BASE64 ENCODED STRING TO DECRYPT</param>
        /// <param name="password">PASSWORD USED DURING THE ENCRYPTION PROCESS TO REVERSE THE SEQUENCE</param>
        /// <returns>ORIGINAL STRING PRIOR TO ENCRYPTION</returns>
        public static string DecryptString(this string s, string password)
        {
            //CREATE AN AES CRYPTOGRAPHY CLASS
            using (Aes tmpAes = AesCryptoServiceProvider.Create())
            {
                //CREATE A PASSWORD DERIVED BYTES CLASS TO CONVERT A SIMPLE PASSWORD INTO SOMETHING MORE COMPLEX
                PasswordDeriveBytes tmpPasswordBytes = new PasswordDeriveBytes(password.ToByteArray(), password.Reverse().ToByteArray());

                //CREATE A ICRYPTO TRANSFORM PROVIDER USING 256 BITS FOR THE KEY WHICH IS DERIVED FROM THE PASSWORD PASSED IN
                using (ICryptoTransform tmpCrypto = tmpAes.CreateDecryptor(tmpPasswordBytes.GetBytes(256 / 8), tmpPasswordBytes.GetBytes(16)))
                {
                    //CREATE A MEMORY STREAM FROM THE BASE64 STRING WHICH IS BEING PASSED IN
                    using (MemoryStream tmpMemoryStream = new MemoryStream(Convert.FromBase64String(s)))
                    {
                        //CREATE A NEW STREAM WHICH WILL DECRYPT THE DATA AS WE READ IT
                        using (CryptoStream tmpStream = new CryptoStream(tmpMemoryStream, tmpCrypto, CryptoStreamMode.Read))
                        {
                            int readCount;
                            byte[] tmpBuffer = new byte[1024];
                            StringBuilder tmpReturn = new StringBuilder();

                            //CATCH THE ERROR INCASE THE PASSWORD IS INVALID
                            try
                            {
                                //AS LONG AS THEIR IS DATA ON THE STREAM KEEP READING
                                while ((readCount = tmpStream.Read(tmpBuffer, 0, tmpBuffer.Length)) != 0)
                                {
                                    tmpReturn.Append(tmpBuffer.Take(readCount).ToArray().ConvertToString());
                                }

                                //RETURN THE DECRYPTED STRING VALUE
                                return tmpReturn.ToString();
                            }
                            catch (CryptographicException ex)
                            {
                                return "";
                            }
                        }
                    }
                }
            }
        }

        #region "Supporting Extensions"
        /// <summary>
        /// CONVERT AN ARRAY OF BYTES INTO THE UTF8 STRING
        /// </summary>
        /// <param name="b">ARRAY OF BYTES COMING IN</param>
        /// <returns>STRING REPRESENTATION OF THE BYTES PASSED IN</returns>
        public static string ConvertToString(this byte[] b)
        {
            return System.Text.ASCIIEncoding.UTF8.GetString(b);
        }

        /// <summary>
        /// REVERSES A STRING
        /// </summary>
        /// <param name="s">INCOMING STRING TO REVERSE</param>
        /// <returns>REVERSED STRING</returns>
        public static string Reverse(this string s)
        {
            StringBuilder tmpReturn = new StringBuilder();

            //LOOP THROUGH EACH CHARACTER FROM BACK TO FRONT AND INSERT IT INTO THE BUILDER
            for (int i = s.Length - 1; i >= 0; i--)
                tmpReturn.Append(s[i]);

            //RETURN THE REVERSED STRING TO THE CALLING FUNCTION
            return tmpReturn.ToString();
        }

        /// <summary>
        /// CONVERTS A STRING INTO UTF8 ENCODED BYTE ARRAY
        /// </summary>
        /// <param name="s">INCOMING STRING TO CONVERT</param>
        /// <returns>BYTE ARRAY OF THE INCOMING STRING</returns>
        public static byte[] ToByteArray(this string s)
        {
            //CONVERT THE STRING TO A BYTE ARRAY
            return System.Text.ASCIIEncoding.UTF8.GetBytes(s);
        }
        #endregion

//Usage

    class Program
    {
        static void Main(string[] args)
        {
            string tmpEnc = "Hello, World!".EncryptString("password");
            string tmpDec = tmpEnc.DecryptString("password");

            Console.WriteLine("{0}\n{1}", tmpEnc, tmpDec);
            Console.ReadLine();
        }
    }

//Code

        /// <summary>
        /// CREATE A FIXED LENGTH STRING FOR INSERTING INTO FIXED LENGTH FILES OR GRIDS
        /// </summary>
        /// <param name="s">STRING TO BE PADDED</param>
        /// <param name="length">LENGTH OF FINAL STRING</param>
        /// <returns>FIXED LENGTH STRING OF X LENGTH</returns>
        public static string FixedLengthString(this string s, int length)
        {
            //IF THE STRING IS ALREADY LONG ENOUGH THEN JUST RETURN S
            //ELSE ADD SPACES TO THE END TO MAKE THE STRING X LENGTH
            if (s.Length >= length)
                return s;
            else
                return string.Concat(s, new string(' ', length - s.Length));
        }