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

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