//Code To Generate A License Key

/// <summary>
/// GENERATE A UNIQUE KEY THAT CAN BE REVERESED TO VALIDATE WITHOUT INTERNET CONNECTION
/// </summary>
/// <param name="AppID">APPLIATION GUID THE KEY SHOULD BE GERNEATED FOR</param>
/// <returns>STRING VALUE REPRESENTING A VALID KEY</returns>
static string GenerateKey(string AppID)
{
    int curSegment = 1;
    string newLicense = "";
    string License = new string(Guid.NewGuid().ToString().Replace("-", "").ToUpper().ToCharArray().Take(12).ToArray());

    //GENERATE 4 BYTE SEGMENTS WHICH ARE [HASH,HASH][KEY,KEY]
    //VALUES ARE TAKEN FROM THE HASH AT A MATHIMATICALLY COMPUTED LOCATION [(FIRST CHAR ASCII VALUE + SEGMENT) % 32] TO MAKE IT DEPENDENT ON SEGMENT LOCATION AND VALUE
    //THIS SHOULD MAKE IT HARDER TO "GUESS" A KEY OR BRUTE FORCE ONE OUT OF THE SYSTEM
    foreach (Match tmpMatch in Regex.Matches(License, "[a-zA-Z0-9]{2}"))
        newLicense += (newLicense != "" ? "-" : "") + BitConverter.ToString(SHA256.Create().ComputeHash(System.Text.ASCIIEncoding.ASCII.GetBytes(tmpMatch.Value + AppID)).Skip((tmpMatch.Value.ToCharArray()[0] + curSegment++) % 32).Take(1).ToArray()).Replace("-", "") + tmpMatch.Value;

    //RETURN THE NEW LICENSE VALUE TO THE CALLING FUNCTION
    return newLicense;
}

//Code To Validate A License Key

/// <summary>
/// VALIDATES A KEY THAT HAS BEEN GENERATED FOR THE GIVEN APPLICATION ID
/// </summary>
/// <param name="AppID">APPLICATION THE KEY SHOULD BE VALIDATED AGAINST</param>
/// <param name="Key">UNIQUE KEY TO COMPARE AGAINST</param>
/// <returns>TRUE OR FALSE REPRESENTING THE VALIDATION OF THE GIVEN KEY AND APPLICATION ID</returns>
public static bool ValidateKey(string Key)
{
    try
    {
        int curSegment = 1;
        string[] segments = Key.ToUpper().Split(new char[] { '-' });
        string AppID = ((GuidAttribute)Assembly.GetCallingAssembly().GetCustomAttributes(typeof(GuidAttribute), false)[0]).Value;

        foreach (string segment in segments)
        {
            //SPLIT THE SEGMENT INTO HASH VALUE AND KEY VALUE
            string hashedValue = segment.Substring(0, 2);
            string keyValue = segment.Substring(2, 2);

            //COMPUTE THE HASH USING THE REVERSE ALGORITHM FROM CREATING A HASH
            string hash = BitConverter.ToString(SHA256.Create().ComputeHash(System.Text.ASCIIEncoding.ASCII.GetBytes(keyValue + AppID)).Skip((keyValue.ToCharArray()[0] + curSegment++) % 32).Take(1).ToArray());

            //IF THE HASH DOES NOT MATCH WHAT IS BELIEVED SHOULD BE A MATCH THEN DROP OUT BECAUSE THE KEY IS INVALID
            if (hash != hashedValue)
                return false;
        }

        //IF WE MADE IT THIS FAR THEN THE KEY IS VALID
        return true;
    }
    catch
    {
        //IF THERE WAS AN ERROR WHILE ATTEMPTING TO VALIDATE THEN THE KEY MUST BE INVALID
        return false;
    }
}

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

More

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