x
1
2
NULL
4
5

SELECT x,
    CASE x
        WHEN NULL THEN ‘yes’
        ELSE ‘no’
    END AS result
FROM
    someTable

O resultado que se esperava era:

x 	result
1 	no
2 	no
NULL 	yes
4 	no
5 	no

Mas não é isso que se tem. O resultado é:

x 	result
1 	no
2 	no
NULL 	no
4 	no
5 	no

Curiosamente, se você executar:

SELECT x,
    CASE x
        WHEN 1 THEN ‘yes’
        ELSE ‘no’
    END AS result
FROM
    someTable

Você obtem:

x 	result
1 	yes
2 	no
NULL 	no
4 	no
5 	no

Enfim o SQL que você deve utilizar

SELECT x,
    CASE
        WHEN x IS NULL THEN ‘yes’
        ELSE ‘no’
    END AS result
FROM
    someTable

SELECT
CASE tppessoa
   WHEN 1 THEN (
      SELECT c.nome FROM cliente c WHERE c.cdcliente = p.cdcliente
   )
   WHEN 2 THEN (
      SELECT f.nome FROM fornecedor f
      WHERE f.cdfornecedor = p.cdfornecedor
   )
   WHEN 3 THEN (
      SELECT ps.nome FROM PrestadorDeServicos ps
      WHERE ps.cdPrestServico = p.cdPrestServico
   )
   ELSE 'Em Branco'
END
FROM Cadastro p

Primeiramente crie a classe GoogleAnalyticsE conforme exemplo abaixo:

public static class GoogleAnalyticsE {

internal static string AddItem;
internal static string AddTrans;
internal static string OrderID;
internal static string Total;
internal static string Tax;
internal static string Shipping;
internal static string City;
internal static string State;
internal static string Country;

}

No Local aonde você obtem os dados do usuário (e dados de valores do pedido) adicione:

// Dados Pedido
GoogleAnalyticsE.Total = _varValorTotal;
GoogleAnalyticsE.Shipping = _varValorDoFrete;
GoogleAnalyticsE.OrderID = _varCodigoPedido;
// Dados Usuário
GoogleAnalyticsE.City = _varCidade;
GoogleAnalyticsE.State = _varEstado;
GoogleAnalyticsE.Country = _varPais;

No Local aonde você lista o seu carrinho adicione:

GoogleAnalyticsE.AddItem = GoogleAnalyticsE.AddItem + " pageTracker._addItem('_ORDERID_','" + ProdutoId + "','" + NomeProduto + "','','" + ValorUnitario.ToString().Replace(",",".") + "','" + Quantidade + "');" + Environment.NewLine;

no Page_Load crie um Script da seguinte maneira:

ClientScript.RegisterStartupScript(GetType(), "StartAnalytics", @"
// Abra Aqui o Javascript script type='text/javascript'

$(document).ready(function () {
try {
var pageTracker = _gat._getTracker(trackerValue);
pageTracker._setDomainName('none');
pageTracker._setAllowLinker(true);
"
+ "pageTracker._addTrans('" + GoogleAnalyticsE.OrderID + "','NOME_DA_LOJA','" + GoogleAnalyticsE.Total.ToString().Replace(",", ".").Replace("R$ ","") + "','0.00','" + GoogleAnalyticsE.Shipping.ToString().Replace(",", ".") + "','" + GoogleAnalyticsE.City + "','" + GoogleAnalyticsE.State + "','" + GoogleAnalyticsE.Country + "');" + @"
"+ GoogleAnalyticsE.AddItem.ToString().Replace("_ORDERID_",GoogleAnalyticsE.OrderID) + @"
pageTracker._trackTrans();
} catch (err) {
alert(err);
}

});

//script - Feche aqui o JavaScript
");

Qualquer duvida.. mande msg..

// Abre o arquivo App.Config do executavel
System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
// Remove e em seguida Adiciona uma configuração .
config.AppSettings.Settings.Remove("LastDateFeesChecked");
config.AppSettings.Settings.Add("LastDateFeesChecked", DateTime.Now.ToShortDateString());
// Salva a nova configurações.
config.Save(ConfigurationSaveMode.Modified);
// Força o "reload" das novas configurações.
ConfigurationManager.RefreshSection("appSettings");

Obs: Lembre-se de adicionar a referencia (namespace) System.Configuration

function Left(str, n){
	if (n <= 0)
	    return "";
	else if (n > String(str).length)
	    return str;
	else
	    return String(str).substring(0,n);
}
function Right(str, n){
    if (n <= 0)
       return "";
    else if (n > String(str).length)
       return str;
    else {
       var iLen = String(str).length;
       return String(str).substring(iLen, iLen - n);
    }
}

function ExibirMensagem(Texto) {
alert(texto);
}

A Linguagem JavaScript permite escrever isso na forma de uma atribuição de variável, se você preferir:

var ExibirMensagem = function(Texto) {
alert(Texto);
}

Conforme você pode esperar, há uma diferença muito sutil entre os efeitos desses dois estilos:
Uma função declarada como a primeira sintaxe pode ser usada por qualquer código no arquivo, mesmo que apareça antes da declaração da função. Uma função declarada como a última sintaxe só pode ser usada pelo código executando após a instrução de atribuição que declara a função. (Lembre-se: Se seu código for bem organizado, essa diferença não importa)

Você pode reduzir essa sequência inteira usando a sintaxe de objeto literal, conforme abaixo:

var NomePrograma = {

variavelX: "Apenas uma variavel",
Mensagem: function(texto){
alert(text);
}

};

Em vez de criar primeiro um objeto vazio e depois preenchê-lo com propriedades e métodos, usando uma série de instruções de atribuição, a sintaxe de objeto literal permite criar o objeto e seu conteúdo com uma única instrução.

Na sintaxe de objeto literal, representamos um novo objeto com chaves; dentro dessas chaves, listamos as propriedades e os métodos do objeto, separados por vírgulas. Para cada propriedade e método, atribuímos um valor usando dois pontos, em vez do perador de atribuição.

A sintaxe de objeto literal pode ser difícil de ler quando você está usando a sintaxe de atribuição padrão há algum tempo, mas ela é ligeiramente mais sucinta.

function replaceAll(string, token, newtoken) {
	while (string.indexOf(token) != -1) {
 		string = string.replace(token, newtoken);
	}
	return string;
}

Veja um exemplo:

str = "Isso é um teste, mas pensando em um teste podemos sempre usar o replaceAll";
alert(replaceAll(str,"teste","grande teste")

Boa Sorte..

Definição da sintaxe das URLs
Em um mundo no qual URLs solicitado não necessariamente coincidem com os arquivos físicos no servidor web, o primeiro passo a tomar é de listagem que URLs sejam significativos para a aplicação. Para evitar ser específico demais, vamos supor que você suportar apenas algumas URLs fixas, cada mapeado para um componente manipulador de HTTP. O trecho de código a seguir mostra as mudanças necessárias a serem feitas ao padrão web.config

Sempre que o aplicativo recebe um pedido que corresponda ao URL especificado, ele irá passá-la para o manipulador especificado.

Definir o comportamento do manipulador HTTP

No ASP.NET, um manipulador de HTTP é um componente que implementa a interface IHttpHandler. A interface é simples e consiste de dois membros, como mostrado aqui:

public class MvcEmuleHandler : IHttpHandler
{
public void ProcessRequest(HttpContext context)
{
// Logic goes here
...
}
public Boolean IsReusable
{
get { return false; }
}
}

Na maioria das vezes, um manipulador de HTTP tem um comportamento codificado influenciado apenas por alguns dados de entrada passou a string de consulta. Nada nos impede, no entanto, de usar o manipulador como uma fábrica abstrata para adicionar mais um nível de indireção. O manipulador, de fato, pode utilizar as informações do pedido para determinar um componente externo para chamar de realmente servir o pedido. Desta forma, um manipulador HTTP pode servir uma variedade de pedidos e envio apenas a chamada entre alguns componentes mais especializados.

O manipulador HTTP pôde analisar o URL em tokens e usar essa informação para identificar a classe eo método para invocar. Aqui está um exemplo de como poderia funcionar:

public void ProcessRequest(HttpContext context)
{
// Parse out the URL and extract controller, action, and parameter
var segments = context.Request.Url.Segments;
var controller = segments[1].TrimEnd('/');
var action = segments[2].TrimEnd('/');
var param1 = segments[3].TrimEnd('/');
// Complete controller class name with suffix and (default) namespace
var fullName = String.Format("{0}.{1}Controller",
this.GetType().Namespace, controller);
var controllerType = Type.GetType(fullName, true, true);
// Get an instance of the controller
var instance = Activator.CreateInstance(controllerType);
// Invoke the action method on the controller instance
var methodInfo = controllerType.GetMethod(action,
BindingFlags.Instance |
BindingFlags.IgnoreCase |
BindingFlags.Public);
var result = String.Empty;
if (methodInfo.GetParameters().Length == 0)
{
result = methodInfo.Invoke(instance, null) as String;
}
else
{
result = methodInfo.Invoke(instance, new Object[] { param1 }) as String;
}
// Write out results
context.Response.Write(result);
}

O código anterior só assume o primeiro token na URL após o nome do servidor contém as principais informações para identificar o componente especializado que irá servir o pedido. O segundo símbolo refere-se ao nome do método a ser chamado neste componente. Finalmente, o símbolo indica um terceiro parâmetro para passar.

Chamando o manipulador HTTP

Dada uma URL como home/teste/*, verifica-se que a casa identifica a classe, testar o método identifica, e qualquer que seja trilhas é o parâmetro. O nome da classe é ainda mais trabalhado e ampliado para incluir um namespace e um sufixo. De acordo com o exemplo, o nome da classe final é MvcEmule.Components.HomeController. Esta classe é esperado para estar disponível para a aplicação. A classe também é esperado para expor um método chamado de teste, como mostrado aqui:

namespace MvcEmule.Components
{
public class HomeController
{
public String Test(Object param1)
{
var message = "
Got it! You passed '{0}'

";
return String.Format(message, param1);
}
}
}

Este exemplo simples demonstra a mecânica básica usada pelo ASP.NET MVC .. O componente especializado que atende a uma solicitação é o controlador. O controlador é uma classe com métodos e não apenas do Estado. Um único nível de sistema manipulador de HTTP cuida de despachar os pedidos de entrada para uma classe de controlador específico para que a instância da classe executa um método determinada ação e produz uma resposta.

E sobre o esquema de URLs? Neste exemplo, basta usar uma URL codificada. No ASP.NET MVC, você tem uma sintaxe muito flexível você pode usar para expressar as URLs da aplicação reconhece. Além disso, um componente novo sistema nas intercepções em tempo de execução pedidos pipeline, processa a URL, e aciona o ASP.NET MVC manipulador HTTP. Este componente é o módulo de roteamento de URL HTTP.

using System.Runtime.InteropServices;

adicione as seguintes const e as funções DLL:

public const int WM_NCLBUTTONDOWN = 0xA1;
public const int HT_CAPTION = 0x2;
DllImportAttribute("user32.dll")]
public static extern int SendMessage(IntPtr hWnd,  int Msg, int wParam, int lParam);
[DllImportAttribute("user32.dll")]
public static extern bool ReleaseCapture();

Em seguida, coloque o seguinte código no evento MouseDown:

private void Form1_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
ReleaseCapture();
SendMessage(Handle, WM_NCLBUTTONDOWN, HT_CAPTION, 0);
}
}

Caso o VS não adicionar automáticamente no arquivo .Designer.cs do seu Form, adicione a seguinte linha (no local marcado com // Form 1 //)

this.MouseMove += new System.Windows.Forms.MouseEventHandler(this.Form1_MouseDown);

Depois disso.. F5 e Boa Sorte.. !!

string texto = "1";   //  Definimos 1, mas aqui você pode colocar um request.form, etc..etc..

switch(text) {

case "1":
     Page.Response.Write("Texto é 1"); // Escreve na Página 'Texto é 1'
     break; // O Comando 'break' vai parar o switch
case "2":
     Page.Response.Write("Texto é 2"); // Escreve na Página 'Texto é 2'
     break; // O Comando 'break' vai parar o switch

 default: // o 'default' é usado quando nenhum dos casos acimas for ativado
    Page.Response.Write("Não é 1 nem 2"); // Escreve na Página 'Não é 1 nem 2'
    break; // O Comando 'break' vai parar o switch
}

Fácil ? Boa Sorte