//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

            //CREATE AN FTP REQUEST WITH THE DOMAIN AND CREDENTIALS
            System.Net.FtpWebRequest tmpReq = (System.Net.FtpWebRequest)System.Net.FtpWebRequest.Create("ftp://domain.com/file.txt");
            tmpReq.Credentials = new System.Net.NetworkCredential("userName", "Password");

            //GET THE FTP RESPONSE
            using (System.Net.WebResponse tmpRes = tmpReq.GetResponse())
            {
                //GET THE STREAM TO READ THE RESPONSE FROM
                using (System.IO.Stream tmpStream = tmpRes.GetResponseStream())
                {
                    //CREATE A TXT READER (COULD BE BINARY OR ANY OTHER TYPE YOU NEED)
                    using (System.IO.TextReader tmpReader = new System.IO.StreamReader(tmpStream))
                    {
                        //STORE THE FILE CONTENTS INTO A STRING
                        string fileContents = tmpReader.ReadToEnd();

                        //DO SOMETHING WITH SAID FILE CONTENTS
                    }
                }
            }

Ini File

[Section 1]
Test = 1
Test2 = 1

[Section 2]
blah = foo
foo = blah

[Section 3]
var = more settings
test = this will handle = signs as part of the value also

Sample Code

            IniFileReaderLib.IniFile tmpIni = new IniFileReaderLib.IniFile("Settings.ini");
            Console.WriteLine(tmpIni.Section["Section 1"]["test"]);

Code

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

namespace IniFileReaderLib
{
    /// <summary>
    /// PROVIDES ROUTINES FOR READING AND PROCESSING A .INI FILE
    /// </summary>
    public class IniFile
    {
        /// <summary>
        /// HOLDS ALL THE VARIABLES LISTED IN THE INI FILE BASED ON obj["Section"]["Setting"]
        /// </summary>
        public Dictionary<string, Dictionary<string, string>> Section { get; set; }

        /// <summary>
        /// DID THE FILE CONTAIN ERRORS WHEN ATTEMPTING TO LOAD
        /// </summary>
        public bool HasErrors { get; set; }

        /// <summary>
        /// WHAT WERE THE ERRORS CONTAINED IN THE FILE
        /// </summary>
        public List<string> Errors { get; set; }

        /// <summary>
        /// FILENAME OF THE INI FILE WE ARE PROCESSING
        /// </summary>
        public string FileName { get; set; }

        /// <summary>
        /// CLASS INITIALIZER
        /// </summary>
        /// <param name="FileName">FILENAME TO PROCESS</param>
        public IniFile(string FileName)
        {
            //STORE THE NAME OF THE FILE WE ARE TO PROCESS
            this.FileName = FileName;

            //PROCESS THE FILE
            ReloadFile();
        }

        /// <summary>
        /// RELOAD THE INI FILE INCASE IT HAS CHANGED SINCE THIS CLASS WAS CREATED
        /// </summary>
        /// <param name="FileName">FILENAME OF THE INIFILE TO PROCESS</param>
        public void ReloadFile()
        {
            //CLEAR OUT ALL THE VALUES BY RELEASING THE OBJECT
            Section = new Dictionary<string, Dictionary<string, string>>(StringComparer.CurrentCultureIgnoreCase);
            Errors = new List<string>();

            //CREATE A TEXT READER TO READ THE INI FILE
            using (TextReader tmpReader = (TextReader)File.OpenText(FileName))
            {
                string tmpLine = null;
                string curSection = null;

                //LOOP THROUGH THE ENTIRE FILE ADDING VARIABLES TO THE SECTION
                while ((tmpLine = tmpReader.ReadLine()) != null)
                {
                    //IF THE LINE IS A SECTION THEN ADD IT TO THE SECTIONS AND START ADDING VARIABLES TO THE SECTION
                    if (Regex.Match(tmpLine, @"[[].*[]]").Success)
                    {
                        //PARSE THE SECTION OUT OF THE STRING AND APPEND IT TO THE LIST OF SECTIONS
                        curSection = Regex.Match(tmpLine, @"[[](?<Section>.*)[]]").Groups["Section"].Value;
                        Section[curSection] = new Dictionary<string, string>(StringComparer.CurrentCultureIgnoreCase);
                    }
                    else
                    {
                        try
                        {
                            //IF THERE IS DATA ON THE LINE THEN TRY TO PROCESS IT
                            if (!string.IsNullOrEmpty(tmpLine) && tmpLine.Contains("="))
                            {
                                //SPLIT THE STRING UP SO WE CAN GET THE VAR TO THE LEFT OF THE = SIGN
                                string[] curPair = tmpLine.Split('=');

                                //ADD THE ITEM TO THE COLLECTION AND MAKE SURE TO PIECE ANYTHING BACK TOGETHER ON THE RIGHT OF THE FIRST = SIGN
                                Section[curSection].Add(curPair[0].Trim(), string.Join("=", curPair.Skip(1).ToArray()).Trim());
                            }
                        }
                        catch(Exception e)
                        {
                            //TRACK THAT AN ERROR WAS THROWN
                            HasErrors = true;

                            //ADD THE MESSAGE TO THE ERROR LIST
                            Errors.Add(e.Message);
                        }
                    }
                }
            }
        }
    }
}

You could also simply download the plugin I wrote for this as well. Although I have submitted it to WordPress.org they have not posted it yet so here is a link in the mean time. Please note the plugin is a little more customizable then the code below.

-Auto Keywords and Description Generator-

//Code

<?php
$keywords = "";
$description = "";

if(is_home() || is_front_page())
{
	//LOAD KEYWORDS FROM USER SPECIFIED STRING
	$keywords = "Insert your homepage keywords here";

	//LOAD DESCRIPTION FROM BLOGINFO
	$description = bloginfo('description');
}
elseif(is_single())
{
	//LOAD POST TITLE AS DESCRIPTION
	$description = $post->post_title;

	//BUILD LIST OF KEYWORDS FROM TAGS
	$tags = wp_get_post_tags($post->ID);
	foreach($tags as $tag)
		$keywords = $keywords . $tag->name . ", ";
}
elseif(is_category())
{
	//LOAD CATEGORY DESCRIPTION
	$keywords = single_cat_title('', false);
	$description = category_description();
}
?>
<meta name="keywords" content="<?php echo $keywords ?>" />
<meta name="description" content="<?php echo $description ?>" />

//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();
        }
    }

//Function

        /// <summary>
        /// FUNCTION FOR TESTING PASSWORD COMPLEXITY
        /// </summary>
        /// <param name="s">INCOMING PASSWORD TO TEST</param>
        /// <param name="minLength">MIN LENGTH OF PASSWORD</param>
        /// <param name="maxLength">MAX LENGTH OF PASSWORD</param>
        /// <param name="rule">COMPARISON FLAGS CAN BE ANY COMBINATION OF THE FOLLOWING - UPPER, LOWER, NUMERIC, SPECIAL</param>
        /// <returns>TRUE OR FALSE IF THE PASSWORD PASSES OR NOT</returns>
        static bool ValidatePasswordComplexity(string s, int minLength, int maxLength, PasswordRules rule)
        {
            //CONSTANTS FOR COMPARISON GROUPS
            const string UPPER = "(?=.*[A-Z])";
            const string LOWER = "(?=.*[a-z])";
            const string NUMERIC = "(?=.*[0-9])";
            const string SPECIAL = "(?=.*[!@#$%^&*()<>])";

            //CREATE A NEW VAR TO HOLD THE COMPARE STRING WHILE ITS ASSEMBLED
            StringBuilder tmpCompare = new StringBuilder("^");

            //CHECK IF UPPER IS A REQUIREMENT
            if ((rule & PasswordRules.Upper) == PasswordRules.Upper)
                tmpCompare.Append(UPPER);

            //CHECK IF LOWER IS A REQUIREMENT
            if ((rule & PasswordRules.Lower) == PasswordRules.Lower)
                tmpCompare.Append(LOWER);

            //CHECK IF NUMERIC IS A REQUIREMENT
            if ((rule & PasswordRules.Numeric) == PasswordRules.Numeric)
                tmpCompare.Append(NUMERIC);

            //CHECK IF SPECIAL IS A REQUIREMENT
            if ((rule & PasswordRules.Special) == PasswordRules.Special)
                tmpCompare.Append(SPECIAL);

            //APPEND THE LENGTH REQUIREMENTS
            tmpCompare.Append(string.Format(".{{{0},{1}}}", minLength, maxLength));

            //RETURN THE RESULT OF THE COMPARISON
            return Regex.Match(s, tmpCompare.ToString()).Success;
        }

        /// <summary>
        /// ERNUMERATIONS FOR PASSWORD COMPLEXITY TESTING
        /// </summary>
        [Flags]
        public enum PasswordRules
        {
            Upper = 1,
            Lower = 2,
            Numeric = 4,
            Special = 8,
        }

//Usage

        /// <summary>
        /// MAIN APPLICATION ENTRY POINT
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            //SOMETHING TO COMPARE
            string pwd = "Password1";

            //TWO DIFFERENT SAMPLES TO SHOW THE PASSWORD MEETS THE REQUIREMENTS IF YOU ARE NOT LOOKING FOR A SPECIAL CHARACTER
            //BUT FAILS ONCE THE SPECIAL REQUIREMENT IS ADDED TO THE PARAMETER
            Console.WriteLine("{0}: {1}", pwd, ValidatePasswordComplexity(pwd, 6, 15, PasswordRules.Upper | PasswordRules.Lower | PasswordRules.Numeric));
            Console.WriteLine("{0}: {1}", pwd, ValidatePasswordComplexity(pwd, 6, 15, PasswordRules.Upper | PasswordRules.Lower | PasswordRules.Numeric | PasswordRules.Special));

            //WAIT FOR USER INPUT
            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);
        }

//Application

using System;
using System.IO;
using System.IO.Pipes;

class Program
{
    /// <summary>
    /// MAIN APPLICATION THREAD
    /// </summary>
    /// <param name="args">NOTHING IS ACCEPTED HERE</param>
    static void Main(string[] args)
    {
        //HOLDS THE SECLECTION A USER MAKES AS TO WHAT THEY WANT TO RUN
        string tmpSelection = string.Empty;

        //ASK THE USER WHAT THEY WANT TO DO
        Console.Write("Please Enter A Selection 1(Server) or 2(Client): ");
        tmpSelection = Console.ReadLine();

        //CLEAR THE SCREEN AND BEGIN RUNNING THE USERS SELECTION
        Console.Clear();
        if (tmpSelection == "1")
        {
            //START A PIPE SERVER
            pipeServer();
        }
        else if (tmpSelection == "2")
        {
            //START A PIPE CLIENT
            pipeClient();
        }
        else
        {
            //LET THE USER KNOW THEY HAVE MADE AN INVALID SELECTION
            Console.WriteLine("Invalid selection made.  This app will now close.");
            Console.ReadLine();
        }
    }

    /// <summary>
    /// RUNS A PIPE CLIENT FOR SENDING MESSAGES
    /// </summary>
    private static void pipeClient()
    {
        //LET THE USER KNOW WHAT IS GOING ON
        Console.WriteLine("Starting Client!");

        //LOOP FOREVER FOR TESTING PURPOSES
        while (true)
        {
            //CREATE A CONNECTION TO A NAMED PIPE ON THE LOCAL MACHINE NAMED testPipe
            using (NamedPipeClientStream tmpPipe = new NamedPipeClientStream(".", "testPipe", PipeDirection.Out))
            {
                string tmpSendMessage;

                //GET SOME TEXT TO SEND THROUGH THE PIPE
                Console.Write("Enter Some Text To Send: ");
                tmpSendMessage = Console.ReadLine();

                //SEND THE MESSAGE THROUGH THE PIPE
                tmpPipe.Connect();
                using (TextWriter tmpWriter = new StreamWriter(tmpPipe))
                {
                    tmpWriter.WriteLine(tmpSendMessage);
                }
            }
        }
    }

    /// <summary>
    /// RUNS A PIPE SERVER FOR ACCEPTING MESSAGES
    /// </summary>
    private static void pipeServer()
    {
        //LET THE USER KNOW WHAT IS GOING ON
        Console.WriteLine("Starting Server!");

        //LOOP FOREVER FOR TESTING PURPOSES
        while (true)
        {
            //CREATE A NAMED PIPE ON THE LOCAL MACHINE NAMED testPipe
            using (NamedPipeServerStream tmpPipe = new NamedPipeServerStream("testPipe", PipeDirection.In))
            {
                //READ THE DATA ON THE PIPE
                tmpPipe.WaitForConnection();
                using (TextReader tmpReader = new StreamReader(tmpPipe))
                {
                    Console.WriteLine(tmpReader.ReadLine());
                }
            }
        }
    }
}

//Class

    public static class AssemblyBuilder
    {
        /// <summary>
        /// COMPILE CODE INTO A MEMORY DLL
        /// </summary>
        /// <param name="Code">PLAIN TEXT OF THE CODE TO BE EXECUTED</param>
        /// <returns>MEMORY DLL OF COMPILED CODE</returns>
        static Assembly BuildAssembly(string Code)
        {
            CSharpCodeProvider tmpProvider = new CSharpCodeProvider();
            CompilerParameters tmpParams = new CompilerParameters() { GenerateExecutable = false, GenerateInMemory = true };

            //ADD ANY ADDITIONAL REFERENCES YOU MAY NEED HERE
            tmpParams.ReferencedAssemblies.Add("System.dll");
            tmpParams.ReferencedAssemblies.Add("System.Windows.Forms.dll");

            //ATTEMPT TO COMPILE THE CODE INTO A MEMORY DLL
            CompilerResults tmpResults = tmpProvider.CompileAssemblyFromSource(tmpParams, Code);

            //IF IT WORKED THEN RETURN THE COMPILED ASSEMBLY ELSE RETURN NOTHING
            if (!tmpResults.Errors.HasErrors)
                return tmpResults.CompiledAssembly;
            else
                return null;
        }

        /// <summary>
        /// COMPILE AND EXECUTE PLAIN TEXT AS THOUGH IT WERE A LOADED LIBRARY
        /// </summary>
        /// <param name="code">CODE TO COMPILE</param>
        /// <param name="namespacename">NAMESPACE INSIDE THE CODE FROM WHICH TO EXECUTE</param>
        /// <param name="classname">CLASS NAME INSIDE THE NAMESPACE FROM WHICH TO EXECUTE</param>
        /// <param name="functionname">FUNCTION TO EXECUTE INSIDE OF THE CLASS</param>
        /// <param name="isstatic">IS THE METHOD A STATIC METHOD OR AN INSTANCED METHOD</param>
        /// <param name="args">ARRAY OF ARGUMENTS TO BE PASSED INTO THE FUNCTION WE ARE CALLING</param>
        /// <returns>RETURNS ANY VALUE RETURNED BY THE FUNCTION THAT WAS CALLED</returns>
        public static object ExecuteCode(string code, string namespacename, string classname, string functionname, bool isstatic, params object[] args)
        {
            Type tmpType = null;
            object tmpInstance = null;
            Assembly tmpAsm = BuildAssembly(code);

            //CHECK TO VERIFY THE BUILDASSEMBLY WORKED
            if (tmpAsm != null)
            {
                //IF THIS IS A STATIC METHOD WE CAN CALL IT DIRECTLY OTHERWISE WE NEED TO CREATE AN INSTANCE OF THE LIBRARY FIRST
                if (isstatic)
                {
                    tmpType = tmpAsm.GetType(namespacename + "." + classname);
                }
                else
                {
                    tmpInstance = tmpAsm.CreateInstance(namespacename + "." + classname);
                    tmpType = tmpInstance.GetType();
                }

                //FIND THE METHOD WE WISH TO EXECUTE
                MethodInfo method = tmpType.GetMethod(functionname);

                //RETURN WHATEVER VALUE COMES BACK FROM THE FUNCTION CALL
                return method.Invoke(tmpInstance, args);
            }
            else
            {
                return null;
            }
        }
    }

//Usage

            string plainTextCode = "using System.Windows.Forms;namespace Test{public class Test	{public void Main(){MessageBox.Show(\"Testing!\", \"Test Title\");	}}}";
            AssemblyBuilder.ExecuteCode(plainTextCode, "Test", "Test", "Main", false, new object[]{});