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

using System;

public static class TimeSpanUtil
{
#region To days
public static double ConvertMillisecondsToDays(double milliseconds)
{
return TimeSpan.FromMilliseconds(milliseconds).TotalDays;
}

public static double ConvertSecondsToDays(double seconds)
{
return TimeSpan.FromSeconds(seconds).TotalDays;
}

public static double ConvertMinutesToDays(double minutes)
{
return TimeSpan.FromMinutes(minutes).TotalDays;
}

public static double ConvertHoursToDays(double hours)
{
return TimeSpan.FromHours(hours).TotalDays;
}
#endregion

#region To hours
public static double ConvertMillisecondsToHours(double milliseconds)
{
return TimeSpan.FromMilliseconds(milliseconds).TotalHours;
}

public static double ConvertSecondsToHours(double seconds)
{
return TimeSpan.FromSeconds(seconds).TotalHours;
}

public static double ConvertMinutesToHours(double minutes)
{
return TimeSpan.FromMinutes(minutes).TotalHours;
}

public static double ConvertDaysToHours(double days)
{
return TimeSpan.FromHours(days).TotalHours;
}
#endregion

#region To minutes
public static double ConvertMillisecondsToMinutes(double milliseconds)
{
return TimeSpan.FromMilliseconds(milliseconds).TotalMinutes;
}

public static double ConvertSecondsToMinutes(double seconds)
{
return TimeSpan.FromSeconds(seconds).TotalMinutes;
}

public static double ConvertHoursToMinutes(double hours)
{
return TimeSpan.FromHours(hours).TotalMinutes;
}

public static double ConvertDaysToMinutes(double days)
{
return TimeSpan.FromDays(days).TotalMinutes;
}
#endregion

#region To seconds
public static double ConvertMillisecondsToSeconds(double milliseconds)
{
return TimeSpan.FromMilliseconds(milliseconds).TotalSeconds;
}

public static double ConvertMinutesToSeconds(double minutes)
{
return TimeSpan.FromMinutes(minutes).TotalSeconds;
}

public static double ConvertHoursToSeconds(double hours)
{
return TimeSpan.FromHours(hours).TotalSeconds;
}

public static double ConvertDaysToSeconds(double days)
{
return TimeSpan.FromDays(days).TotalSeconds;
}
#endregion

#region To milliseconds
public static double ConvertSecondsToMilliseconds(double seconds)
{
return TimeSpan.FromSeconds(seconds).TotalMilliseconds;
}

public static double ConvertMinutesToMilliseconds(double minutes)
{
return TimeSpan.FromMinutes(minutes).TotalMilliseconds;
}

public static double ConvertHoursToMilliseconds(double hours)
{
return TimeSpan.FromHours(hours).TotalMilliseconds;
}

public static double ConvertDaysToMilliseconds(double days)
{
return TimeSpan.FromDays(days).TotalMilliseconds;
}
#endregion
}

Obtendo IP do Visitante/Usuário

Request.UserHostAddress.ToString();

Obtendo o valor de um item enviado via GET

Request.QueryString["ItemGET"];

Obtendo o valor de um item enviado via POST

Request.Form["ItemPOST"];

Dica:

Use .ToString(); no final do Request para poder usar o valor para uma String. Exemplo String strValorPost = Request.Form["ItemPOST"].ToString();

–

Session

Criando uma Session:

 Session["nomeSession"] = "valorSession"; 

Lendo uma Session:

 String strValorSession = Session["nomeSession"]; 

Exibindo o Timeout da Session:

 Response.Write(Session.Timeout.ToString()); 

Definindo o Timeout:

 Session.Timeout = 5; 

Removendo:

 Session.Remove("nomeSession");

Request

Getting IP of User

Request.UserHostAddress.ToString();

Getting the value of an item sent via GET

Request.QueryString["ItemGET"];

Getting the value of an item sent via POST

Request.Form["ItemPOST"];

Tip:

Use .ToString(); the end of the Request in order to use the value to a String. Sample String strValorPost = Request.Form["ItemPOST"].ToString();

–

Session

Creating a Session

Session["nameSession"] = "amountSession";

Reading a Session

 String strValorSession = Session["nameSession"]; 

View Timeout of Session:

 Response.Write(Session.Timeout.ToString()); 

Setting the TimeOut:

 Session.Timeout = 5; 

Removing:

 Session.Remove("nomeSession");

Request

Ottenere IP del visitatore

Request.UserHostAddress.ToString();

Ottenere il valore di un element inviato tramite GET

Request.QueryString["ItemGET"];

Ottenere il valore di un element inviato tramite POST

Request.Form["ItemPOST"];

Suggerimento:

Usa .ToString(); il fine della richiesta al fine di utilizzare il valore in una stringa. Esempio String strValorPost = Request.Form["ItemPOST"].ToString();

–

Session

Creazione di una Session:

 Session["nomeSession"] = "valorSession"; 

Lettura di una Session:

 String strValorSession = Session["nomeSession"]; 

Lettura di Timeout di Session:

 Response.Write(Session.Timeout.ToString()); 

Impostazione del Timeout:

 Session.Timeout = 5; 

Rimozione:

 Session.Remove("nomeSession");

Request

Получение IP посетителя

Request.UserHostAddress.ToString();

Получение значения пункта отправлено через GET

Request.QueryString["ItemGET"];

Получение значения пункта отправлено по почте

Request.Form["ItemPOST"];

Совет:

Использование .ToString(); конце запроса, чтобы использовать значение в строку. Пример String strValorPost = Request.Form["ItemPOST"].ToString();

–

Session

Создание сессии:

 Session["nomeSession"] = "valorSession"; 

Чтение сессии:

 String strValorSession = Session["nomeSession"]; 

Просмотр сессии вышло:

 Response.Write(Session.Timeout.ToString()); 

Настройка вышло:

 Session.Timeout = 5; 

Удаление:

 Session.Remove("nomeSession");

Criando

private void CriarCookie(string texto)
{
HttpCookie cookie = new HttpCookie(“SITE”);

cookie.Values.Add(“IP”, this.Page.Request.UserHostAddress.ToString());
cookie.Values.Add(“USERNAME”, texto);

cookie.Expires = DateTime.Now.AddDays(365);
this.Page.Response.AppendCookie(cookie);
}

Lendo

private HttpCookie ReadCookie()
{
try
{
return this.Page.Request.Cookies["SITE"];
}
catch
{
return null;
}
}

A classe HttpCookie possui algumas propriedades avançadas:

Advanced Properties of the HttpCookie Class