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

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

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