public class WatermarkedTextBox
{
  public static readonly DependencyProperty WatermarkProperty = DependencyProperty.RegisterAttached("Watermark", typeof(string), typeof(WatermarkedTextBox));
 
  public static void SetWatermark(TextBox element, string watermark) {
    element.SetValue(WatermarkProperty, watermark);
  }
 
  public static string GetWatermark(UIElement element) {
    return element.GetValue(WatermarkProperty) as string;
  }
}

<Style TargetType="{x:Type TextBoxBase}" x:Key="{x:Type TextBox}">
  <Setter Property="Template">
    <Setter.Value>
      <ControlTemplate TargetType="{x:Type TextBoxBase}">
        <Grid>
          <ScrollViewer Margin="0" x:Name="PART_ContentHost" Background="Transparent"/>
          <TextBlock x:Name="watermark" Opacity="0.3"
             Text="{Binding (l49ui:WatermarkedTextBox.Watermark),RelativeSource={RelativeSource TemplatedParent}}"
             TextWrapping="Wrap"
             Visibility="Collapsed" />
        </Grid>
        <ControlTemplate.Triggers>
          <MultiTrigger>
            <MultiTrigger.Conditions>
              <Condition Property="IsFocused" Value="False" />
              <Condition Property="TextBox.Text" Value="" />
            </MultiTrigger.Conditions>
            <Setter Property="Visibility" TargetName="watermark" Value="Visible" />
          </MultiTrigger>
        </ControlTemplate.Triggers>
      </ControlTemplate>
    </Setter.Value>
  </Setter>
</Style>

StringBuilder buffer = new StringBuilder();
bool first = true;
foreach(KeyValuePair<string, string> parameter in parameters) {
    if(first) {
        first = false;
    } else {
        buffer.Append('&');
    }
    if(encodeParams) {
        buffer.AppendFormat("{0}={1}", System.Uri.EscapeDataString(parameter.Key), Uri.EscapeDataString(parameter.Value));
    } else {
        buffer.AppendFormat("{0}={1}", parameter.Key, parameter.Value);
    }
}
string queryString = buffer.ToString();

string queryString = parameters.Aggregate("", (allParameters, param) => allParameters + encodeParams ? 
                string.Format("{0}={1}", Uri.EscapeDataString(param.Key), Uri.EscapeDataString(param.Value)) :
                string.Format("{0}={1}", param.Key, param.Value));

namespace Lime49.WPF {
    /// <summary>
    /// Tray minimization utility, based on Delay's code - http://blogs.msdn.com/delay/.
    /// </summary>
    public static class TrayMinimizer {
        /// <summary>
        /// Enables "minimize to tray" behavior for the specified Window.
        /// </summary>
        /// <param name="window">Window to enable the behavior for.</param>
        public static void EnableMinimizeToTray(Window window) {
            if(MinimizeInstances.ContainsKey(window)) {
                Console.WriteLine(string.Format("Minimization already enabled for '{0}'", window.Title));
            } else {
                var instance = new MinimizeToTrayInstance(window);
                instance.Enable();
                MinimizeInstances.Add(window, instance);
            }
        }

 
        /// <summary>
        /// Disables "minimize to tray" behavior for the specified Window.
        /// </summary>
        /// <param name="window">Window to enable the behavior for.</param>
        public static void DisableMinimizeToTray(Window window) {
            if(!MinimizeInstances.ContainsKey(window)) {
                Console.WriteLine(string.Format("Minimization not enabled for '{0}'", window.Title));
            } else {
                var instance = MinimizeInstances[window];
                instance.Disable();
                MinimizeInstances.Remove(window);
            }
        }
 
        private static Dictionary<Window, MinimizeToTrayInstance> _minimizeInstances;
        /// <summary>
        /// Gets or sets the windows for which tray minimization is currently enabled.
        /// </summary>
        /// <value>The windows for which tray minimization is currently enabled.</value>
        private static Dictionary<Window, MinimizeToTrayInstance> MinimizeInstances {
            get {
                if(_minimizeInstances == null) {
                    _minimizeInstances = new Dictionary<Window, MinimizeToTrayInstance>();
                }
                return _minimizeInstances;
            }
            set { _minimizeInstances = value; }
        }
 
        /// <summary>
        /// Allows minimization of a window to the tray.
        /// </summary>
        private class MinimizeToTrayInstance {
            private Window _window;
            private NotifyIcon _notifyIcon;
 
            /// <summary>
            /// Initializes a new instance of the MinimizeToTrayInstance class.
            /// </summary>
            /// <param name="window">Window instance to attach to.</param>
            public MinimizeToTrayInstance(Window window) {
                if(window == null)
                    throw new ArgumentException("window parameter is null.");
                _window = window;
            }
 
            /// <summary>
            /// Enables minimization for this Window.
            /// </summary>
            public void Enable() {
                _window.StateChanged += new EventHandler(HandleStateChanged);
            }
 
            /// <summary>
            /// Disables minimization for this Window.
            /// </summary>
            public void Disable() {
                _window.StateChanged -= new EventHandler(HandleStateChanged);
            }
 
            /// <summary>
            /// Handles the Window's StateChanged event.
            /// </summary>
            /// <param name="sender">The sender.</param>
            /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
            private void HandleStateChanged(object sender, EventArgs e) {
                if(_notifyIcon == null) {
                    _notifyIcon = new NotifyIcon();
                    _notifyIcon.Icon = Icon.ExtractAssociatedIcon(Assembly.GetEntryAssembly().Location);
                    _notifyIcon.MouseClick += new System.Windows.Forms.MouseEventHandler(HandleNotifyIconOrBalloonClicked);
                    _notifyIcon.BalloonTipClicked += new EventHandler(HandleNotifyIconOrBalloonClicked);
                }
                _notifyIcon.Text = _window.Title;
 
                // Show/hide Window and NotifyIcon
                var minimized = (_window.WindowState == WindowState.Minimized);
                _window.ShowInTaskbar = !minimized;
                _notifyIcon.Visible = minimized;
                if(minimized && !Settings.Default.MinimizeBalloonShown) {
                    // If this is the first time minimizing to the tray, show the user what happened
                    _notifyIcon.ShowBalloonTip(1000, _window.Title, "I'm still running!", ToolTipIcon.None);
                    Settings.Default.MinimizeBalloonShown = true;
                    Settings.Default.Save();
                }
            }
 
            /// <summary>
            /// Restores a window when the notify icon or its balloon are clicked.
            /// </summary>
            /// <param name="sender">The sender.</param>
            /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
            private void HandleNotifyIconOrBalloonClicked(object sender, EventArgs e) {
                _window.WindowState = WindowState.Normal;
            }
        }
        #endregion
    }
}

<Style TargetType="{x:Type TextBoxBase}" x:Key="{x:Type TextBox}">
  <Setter Property="Margin" Value="2" />
  <Setter Property="SnapsToDevicePixels" Value="True"/>
  <Setter Property="OverridesDefaultStyle" Value="false"/>
  <Setter Property="KeyboardNavigation.TabNavigation" Value="None"/>
  <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
  <Setter Property="MinWidth" Value="80"/>
  <Setter Property="MinHeight" Value="20"/>
  <Setter Property="AllowDrop" Value="true"/>
  <Setter Property="Background" Value="{StaticResource WindowBackgroundBrush}" />
  <Setter Property="BorderBrush" Value="{StaticResource SolidBorderBrush}" />
  <Setter Property="Template">
...

    <Setter.Value>
      <ControlTemplate TargetType="{x:Type TextBoxBase}">
        <Border Name="Border" CornerRadius="1" Padding="2"
                Background="{TemplateBinding Background}" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="1">
          <Border Name="ErrorContainer">
              <ScrollViewer Margin="0" x:Name="PART_ContentHost" Background="Transparent"/>
          </Border>
        </Border>
        <ControlTemplate.Triggers>
          <Trigger Property="IsEnabled" Value="False">
            <Setter TargetName="Border" Property="Background" Value="{StaticResource DisabledBackgroundBrush}"/>
            <Setter Property="Foreground" Value="{StaticResource DisabledForegroundBrush}"/>
          </Trigger>
          <Trigger Property="Validation.HasError" Value="true">
              <Setter TargetName="PART_ContentHost" Property="ToolTip" Value="{Binding RelativeSource={RelativeSource Self},Path=(Validation.Errors)[0].ErrorContent}" />
              <Setter TargetName="ErrorContainer" Property="Padding" Value="0,0,18,0" />
              <Setter TargetName="ErrorContainer" Property="Background">
                  <Setter.Value>
                      <ImageBrush ImageSource="pack://application:,,,/Resources/images/error_16.png" Stretch="None" AlignmentX="Right" AlignmentY="Center" />
                  </Setter.Value>
              </Setter>
          </Trigger>
        </ControlTemplate.Triggers>
      </ControlTemplate>
    </Setter.Value>
  </Setter>
</Style>

 tabControl.SelectedItem = someTab;
 someTextBox.Focus();
 FocusManager.SetFocusedElement(this, someTextBox);
 // both only work unless the tab which contains them is visible.

tabControl.SelectedItem = someTab;
if(!someTextBox.IsVisible) {
    DependencyPropertyChangedEventHandler deferredFocus = null;
    deferredFocus = delegate {
        someTextBox.Focus();
        someTextBox.IsVisibleChanged -= deferredFocus;
    };
    someTextBox.IsVisibleChanged += deferredFocus;
} else {
    someTextBox.Focus();
}

<Window ...
	Topmost="{Binding ElementName=itmTopMost,Path=IsChecked}"
...
	<MenuItem Header="_Always on Top" x:Name="itmTopMost" IsCheckable="True" />

/// <summary>
/// Removes an item from the cache using a Predictate to match the key.
/// </summary>
/// <param name="keyCriteria">The Predictate to use for each key to determine whether the entry should be removed.</param>
/// <summary>
/// Removes an item from the cache using a Predictate to match the key.
/// </summary>
/// <param name="keyCriteria">The Predictate to use for each key to determine whether the entry should be removed.</param>
public static void RemoveFromCache(Predicate<string> keyCriteria) {
	IDictionaryEnumerator enuma = HttpContext.Current.Cache.GetEnumerator();
	while(enuma.MoveNext()) {
		if(keyCriteria(enuma.Key.ToString())) {
			HttpContext.Current.Cache.Remove(enuma.Key.ToString());
		}
	}
}

	Order theOrder = GetOrder(orderId);
	litName.Text = theOrder.Name;
	litID.Text = theOrder.ID;
	litCustomer.Text = theOrder.BillingCustomer.Name;
	...

<asp:ObjectDataSource ID="dsOrderDetails" runat="server" TypeName="DatabaseHelper" SelectMethod="GetOrder">
	<SelectParameters>
		<asp:Parameter Name="orderId" Type="Int32" DefaultValue="-1" />
	</SelectParameters>
</asp:ObjectDataSource>
<asp:Repeater ID="rptOrder" runat="server" DataSourceID="dsOrderDetails">
	<ItemTemplate>
		<strong>Order ID: </strong><asp:Literal ID="lblOrderID" runat="server" Text='<%# Eval("ID") %>' />
		<strong>Checkout Complete: </strong><asp:Literal ID="lblPaid" runat="server" Text='<%# Convert.ToBoolean(Eval("Paid") ?? "false") ? "Yes" : "No" %>' />
		<strong>Customer Name: </strong><asp:Literal ID="lblCustomerName" runat="server" Text='<%# Eval("BillingCustomer.Name") %>' />
                            </div>
		...
		<asp:GridView ID="grdItems" runat="server" DataSource='<%# Eval("Items") %>'...

public class Order
{
    public int ID { get; set; }
    public bool Paid { get; set; }
    public Customer BillingCustomer { get; set; }
    public List<OrderItem> Items { get; set; }
	...

...
cmd.CommandText = "SELECT Filename, Description FROM tblGallery WHERE Visible = '1'";
StringBuilder jqueryBuffer = new StringBuilder("$().ready(function() {\n"); 
jqueryBuffer.Append("var galleryImages = [\n");
List<string> galleryPics = new List<string>();
SqlDataReader reader = cmd.ExecuteReader();
JavaScriptSerializer js = new JavaScriptSerializer();
while(reader.Read()) {
    galleryPics.Add(js.Serialize(new { 
        filename = Server.HtmlDecode(reader[0].ToString()), 
        alt = Server.HtmlDecode(reader[1].ToString()) 
    }));
}
reader.Close();
jqueryBuffer.Append(Utils.Implode(galleryPics, ",\n", false)).Append("];\n cycleGalleryPics(galleryImages);\n");
ScriptManager.RegisterStartupScript(this, typeof(Page), "jqueryListeners", jqueryBuffer.ToString(), true);
...

$().ready(function() {
  var galleryImages = [
  {"filename":"1","alt":"Picture 1"},
  {"filename":"2","alt":"Caption 2"},
  {"filename":"3","alt":"Something 3"},
  {"filename":"4","alt":"etc"},
  {"filename":"5","alt":""},
  {"filename":"6","alt":""}];
  cycleGalleryPics(galleryImages);
});

function cycleGalleryPics(galleryImages) {
    var galleryDiv = $('#Gallery');
    galleryDiv.html('');
    var path = "";
    if (typeof (imagePath) == 'undefined') {
        path = 'UserImages/Gallery/';
    } else {
        path = imagePath + '/Gallery/';
    }
    jQuery.each(galleryImages, function() {
        $('<img/>').attr({
            width: 368, height: 370,
            alt: unescape(this.alt),
            src: path + unescape(this.filename) + '.jpg'
        }).appendTo('#Gallery');
    });
    galleryDiv.cycle({ fx: 'fade', timeout: 3000, random: 1, fit: 1, containerResize: 0 });
}