"The following module was built either with optimizations enabled or without debug information:

....

To debug this module, change its project build configuration to Debug mode. To suppress this message, disable the 'Warn if no user code on launch' debugger option."

Do this to get rid of the alert:
1. Right click the project giving the alert, choose “Properties”.
2. Choose “Build” and then “Advanced…”
3. Set Debug info to “full”.

Now the alert should be gone.

<httpModules>
  <add name="ScriptModule" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
</httpModules>

1. Start by finding the “plugins” folder which is located below the “fckeditor\editor” folder.
2. Create a new folder, name it “openurl”.
3. Add an icon within the “openurl” folder, name it “openurl.gif”.
4. Create a new file within the “openurl” folder, name it “fckplugin.js”, and add the following code:

// Our method which is called during initialization of the toolbar.
function OpenUrl()
{
}

// Disable button toggling.
OpenUrl.prototype.GetState = function()
{
	return FCK_TRISTATE_OFF;
}

// Our method which is called on button click.
OpenUrl.prototype.Execute = function()
{
	window.open('http://www.kindblad.com');
}

// Register the command.
FCKCommands.RegisterCommand('openurl', new OpenUrl());

// Add the button.
var item = new FCKToolbarButton('openurl', 'Open URL');
item.IconPath = FCKPlugins.Items['openurl'].Path + 'openurl.gif';
FCKToolbarItems.RegisterItem('openurl', item);

5. Now we need to define where we want our button to be shown in the toolbar. Open up “fckeditor\fckconfig.js” and look for:

FCKConfig.ToolbarSets["Default"] = [
	['Source'],
	['Cut','Copy','Paste','PasteText','PasteWord','-','SpellCheck'],
	...

Add ‘openurl’ anywhere in the toolbar definition, e.g.:

FCKConfig.ToolbarSets["Default"] = [
	['openurl,'Source'],
	['Cut','Copy','Paste','PasteText','PasteWord','-','SpellCheck'],
	...

6. And lastly, we need to tell FCKeditor to load our plugin, we do this by finding the following string in the “fckeditor/fckconfig.js”.

FCKConfig.PluginsPath = FCKConfig.BasePath + 'plugins/' ;

Add the following code below the line above:

FCKConfig.Plugins.Add('openurl');

That’s it.

FCKeditorAPI.GetInstance([instanceName]);

E.g.:

var editor = FCKeditorAPI.GetInstance('ctrArticle');

And this is how you get the editor instance when you are inside the editor instance:

var editor = FCK;

And lastly, this is how you get the name (DOM id) of the editor instance (get the instance using either of the methods above):

alert(editor.Name);

- Small download, fast install.
- Very fast startup.
- Compact and slick user interface which gives you more space.
- Any tab element can be detached into a separate window, and a separate window can be re-attached to the tab.
- “Porn mode” - A new window called “incognito” can be opened. This window won’t leave any traces in the browser- or search history, and cookies will be deleted when the window is closed.
- “Create application shortcut” - Create a shortcut to the current page on your start menu, quick lunch or desktop.
- Render sites really well.
- Built in task manager which shows how much CPU, memory and network each tab uses.
- One tab = one process. If one tab crashes it doesn’t effect all the tabs within the same window.
- Nifty DOM inspector which has most of the Firebug features.

Some screenshots:

public enum SortExpressions
{
	FirstNameAsc,
	FirstNameDesc,
	LastNameAsc,
	LastNameDesc
}

var value = "lastnameasc";
var sortExpression = (SortExpressions) Enum.Parse(typeof(SortExpressions), value, true);

Since this operation is often needed we should make a ConvertToEnum method so we can reuse it. But instead of returning it as the typical object type, we should rather use generics to return it as the actual type:

/// <summary>
/// Converts a string to the specificed enumeration.
/// </summary>
public T ConvertToEnum<T>(string value, T defaultEnum)
{
	value = value.Replace(" ", "").Trim();

	try
	{
		return (T) Enum.Parse(typeof(T), value, true);
	}
	catch
	{
		return defaultEnum;
	}
}

A try/catch is used instead of the method Enum.IsDefined as it’s case-sensitive.

And this is how you can use our new ConvertToEnum method:

var value = "lastnameasc";
var sortExpression = ConvertToEnum<SortExpressions>(value, SortExpressions.FirstNameAsc);

Here’s a stored procedure which does this:

CREATE PROCEDURE DeleteProducts
(
	@values varchar(8000)
)
AS
BEGIN
	SET NOCOUNT ON;

	declare @value int
	declare @pos1 int
	declare @pos2 int

	-- Append , at the end of string.
	if substring(@values, len(@values), 1) <> ','
	begin
		set @values = @values + ','
	end

	-- First position.
	set @pos1 = 1
	set @pos2 = charindex(',', @values, 1)

	while (@pos1 > 0 and @pos2 > 0)
	begin
		set @value = cast(substring(@values, @pos1, @pos2 - @pos1) as int)

		delete from Product
		where ProductId = @value;

		-- Next position.
		set @pos1 = charindex(',', @values, @pos1) + 1
		set @pos2 = charindex(',', @values, @pos1)
	end
END

And this is how you would execute it:

exec DeleteProducts '1,20,30,100,250,1000';

The IDataReader interface provides methods for getting field values for a given type:

string email = reader.GetString(0);

The problem with these methods are that they only accept the index-position and not the field name. Instead, I would prefer to write the code above like this:

string email = reader.GetString("Email");

In order to do this, we need to create a new static class, which defines some new extension methods:

using System;
using System.Data;

/// <summary>
/// Provides extension methods for the IDataReader interface.
/// </summary>
public static class IDataReaderExtension
{
	public static bool GetBoolean(this IDataReader reader, string name)
	{
		return (bool) reader[name];
	}
	public static Guid GetGuid(this IDataReader reader, string name)
	{
		return (Guid) reader[name];
	}
	public static int GetInt(this IDataReader reader, string name)
	{
		return (int) reader[name];
	}
	public static double GetDouble(this IDataReader reader, string name)
	{
		return (double) reader[name];
	}
	public static string GetString(this IDataReader reader, string name)
	{
		return (string) reader[name];
	}
	public static bool IsDBNull(this IDataReader reader, string name)
	{
		if (reader[name] == DBNull.Value)
			return true;

		return false;
	}
}

Since we didn’t put our static class within a namespace, then our extension methods will be available at once. However, if you want to use a namespace, then you need to import the namespace in every class where you want to use these extension methods.

Text reflection:
1. Start by adding some text to your Powerpoint slide.
2. Select the text you want to add reflection to.
3. Click on the tab Format.
4. Select Text Effects, then Reflection and choose the reflection variant you prefer.

Shape reflection:
Same as text reflection, but choose Shape Effects instead.

Picture reflection:
Same as text reflection, but choose Picture Effects instead.

public static class StringExtension
{
	/// <summary>
	/// Returns the first five characters of a string.
	/// </summary>
	public static String GetFirstFiveCharacters(this String myString)
	{
		return myString.Substring(0, 5);
	}
	/// <summary>
	/// Returns the last five characters of a string.
	/// </summary>
	public static String GetLastFiveCharacters(this String myString)
	{
		return myString.Substring(myString.Length - 5, 5);
	}
}

In the example above, we use a class with the name StringExtension. However, you can name this class whatever you like: StringExtension, StringMethods, StringHelper, Helper etc. The only important thing is that your methods follow the pattern for extension methods:

public static <type> MethodName(this <type> variableName)

Now, let’s produce some code using our extension methods:

String helloWorld = "Hello World";
String hello = helloWorld.GetFirstFiveCharacters(); // contains Hello
String world = helloWorld.GetLastFiveCharacters(); // contains World

Of course, extension methods are shown in the intellisense in Visual Studio.