Manipulando CSS com Jquery
Jquery é um framework javascript muito poderoso, que simplifica muito o desenvolvimento e trabalha a questão cross-browser internamente. Um recurso legal do Jquery é a facilidade em manipular os estilos dos elementos do HTML da página, através da função .css().
Essa função pode ser chamada tanto para obter o valor de um estilo do elemento quanto para definir o valor para esse estilo:
- Obter o estilo: com o elemento selecionado, basta chamar a função .css() passando apenas um parâmetro, que identifica o nome do estilo que se quer obter. Exemplos:
var larguraBorda = $('div#retangulo').css('border-width');
var cor = $('p#mazembe').css('color');
- Definir o estilo: com o elemento selecionado, basta chamar a função .css() passando dois parâmetros, o primeiro identifica o nome do estilo que se quer definir e o segundo indica o valor que este estilo irá assumir. Exemplos:
$('div#retangulo').css('border-width', '5px');
$('p#mazembe').css('color', 'red');
É isso. Com essa função é muito fácil manipular os estilos dos elementos do lado cliente da aplicação web. Até a próxima.
Registrando script com RegisterStartupScript
Vou falar sobre o método RegisterStartupScript.
Este método é semelhante ao RegisterClientScriptBlock.
A diferença, é que o RegisterStartupScript registra o script apenas no fim da página asp.net.
Então, quando usar o RegisterStartupScript?
Quando você precisar trabalhar com algum controle adicionado na página, por exemplo.
Vejamos o exemplo a seguir.
No html, temos o textbox abaixo:
<asp:TextBox ID="txtExemplo" Runat="server">AbsolutCode</asp:TextBox>
E no carregar da página, executamos o seguinte trecho de código:
protected void Page_Load(object sender, EventArgs e)
{
string script = String.Format(@"alert(document.getElementById('{0}').value);", txtExemplo.ClientID);
ClientScript.RegisterStartupScript(this.GetType(), "MeuScript", script, true);
}
Isso faz com que o código javascript seja executado depois que todos controles já foram adicionados na tela.
Entendendo o uso de Generics
Generics é uma ferramenta que foi introduzida no .NET 2.0 e que possui grande aplicabilidade. O importante de se saber é que com Generics podemos criar uma classe genérica que vai poder ser utilizada para uma diversidade de tipos de dados, garantindo reusabilidade e diminuição de tamanho de código. Se, por um lado, pode parecer difícil de entender, por outro lado também é muito difícil de explicar. Portanto, nada melhor do que exemplificar.
Primeiramente, vamos pensar no funcionamento de uma Pilha de livros: inserimos um livro sempre no topo e removemos ele sempre do topo também. Ótimo, já podemos criar uma classe Pilha para livros. Mas se for uma Pilha de cadernos? Ou uma Pilha de caixas? Ou mesmo uma Pilha de roupas? É, já vimos que uma Pilha tem funcionamento igual para uma diversidade de tipos de objetos, ou seja, a Pilha se comporta de maneira genérica, independente do tipo de objeto que está sendo empilhado. E isso lembra alguma coisa? Se não lembra, estou afirmando para vocês: isso é GENERICS.
Agora que já refletimos e entendemos o que é Generics, vamos colocar em prática para criar uma classe genérica para o comportamento de uma Pilha.
Passando para o inglês, Pilha fica Stack. Portanto, o nome da classe será Stack. O primeiro passo é a assinatura dessa classe, de forma que utilizando a letra T entre <> para indicar que, ao criar um objeto, precisamos informar de qual TIPO é essa classe. Difícil de entender? Exemplificamos, então:
/// <summary>
/// Classe que implementa uma pilha.
/// </summary>
/// <typeparam name="T">Tipo de cada elemento da pilha.</typeparam>
public class Stack<T>
{
...
}
Desta forma, sempre que criarmos um objeto da classe Stack, precisamos dizer de que tipo é essa Pilha (mais adiante teremos um exemplo disso). Seguindo, vamos ter um atributo na classe, que é uma Lista que irá auxiliar no empilhamento dos objetos. Por ironia do destino, a Lista também utiliza Generics, então precisamos informar qual o tipo da lista. O tipo da nossa Pilha é o T, portanto a lista também será do tipo T (já podemos ver como criamos um objeto de uma classe que usa Generics). Temos um construtor, que apenas inicia a lista.
/// <summary>
/// Classe que implementa uma pilha.
/// </summary>
/// <typeparam name="T">Tipo de cada elemento da pilha.</typeparam>
public class Stack<T>
{
/// <summary>
/// Atributo que guarda a lista de elementos.
/// </summary>
private List<T> elements;
/// <summary>
/// Construtor padrão.
/// </summary>
public Stack()
{
elements = new List<T>();
}
...
}
Na pilha, temos dois métodos: O método PUSH, que realiza o empilhamento de um objeto, colocando-o no topo da pilha (consideramos que o topo da pilha é sempre o último elemento da lista). Portanto, o método PUSH vai receber como parâmetro o objeto que se quer empilhar, que deve ser do tipo da pilha, ou seja, T. O outro método é o POP, que remove um objeto do topo da pilha (como o topo é o último elemento da lista, remove o último). Esse método POP, além de remover o objeto deve retorná-lo. Portanto, o método POP retorna um objeto do tipo T também.
/// <summary>
/// Classe que implementa uma pilha.
/// </summary>
/// <typeparam name="T">Tipo de cada elemento da pilha.</typeparam>
public class Stack<T>
{
/// <summary>
/// Atributo que guarda a lista de elementos.
/// </summary>
private List<T> elements;
/// <summary>
/// Construtor padrão.
/// </summary>
public Stack()
{
elements = new List<T>();
}
/// <summary>
/// Insere um elemento no topo da pilha (final da lista).
/// </summary>
/// <param name="element">Elemento a ser inserido.</param>
public void Push(T element)
{
// Insere o elemento no topo da pilha.
elements.Add(element);
}
/// <summary>
/// Remove o elemento do topo da pilha (final da lista).
/// </summary>
/// <returns>Retorna o elemento removido.</returns>
public T Pop()
{
if (elements.Count > 0)
{
// Obtém o elemento do topo da lista, remove-o e retorna.
int indiceElementoTopo = elements.Count-1;
T elementTopo = elements[indiceElementoTopo];
elements.RemoveAt(indiceElementoTopo);
return elementTopo;
}
else
{
throw new Exception("A pilha está vazia.");
}
}
}
Bom, é isso. Segue abaixo e um exemplo de utilização da Pilha para dois tipos diferentes de objetos. Até a próxima!
static void Main(string[] args)
{
Stack<int> pilhaInteiros = new Stack<int>();
pilhaInteiros.Push(1);
pilhaInteiros.Push(2);
pilhaInteiros.Push(3);
pilhaInteiros.Pop();
pilhaInteiros.Pop();
pilhaInteiros.Push(4);
pilhaInteiros.Push(5);
Stack<String> pilhaStrings = new Stack<string>();
pilhaStrings.Push("João");
pilhaStrings.Push("Pedro");
pilhaStrings.Push("Marcelo");
pilhaStrings.Pop();
pilhaStrings.Pop();
}
Sockets parte 1, uma introdução
Sockets constituem o principal mecanismo para comunicação entre processos. Basicamente, qualquer aplicação que envolva troca de dados entre diferentes processos, sejam eles locais ou remotos,muito provavelmente, em algum ponto os utiliza.
Todas as atuais tecnologias para computação distribuída, como Webservices, RMI, RPC, etc… utilizam sockets por debaixo dos panos, então se você ainda não os conhece, já está na hora de conhecer. Mas não se preocupe, estou aqui justamente para tornar essa jornada o mais agradável e indolor quanto possível.
Background teórico:
É, não há como escapar disso, para termos um bom domínio de uma tecnologia antes precisamos estudar alguns conceitos teóricos.Com já conversamos anteriormente, sockets são mecanismos de comunicação entre processos, onde estes processos são identificados por nomes. Estes nomes por sua vez são traduzidos em endereços.
Os endereços podem ser especificados para diferentes domínios. Até aqui não há motivo para pânico, temos apenas dois domínios:
● AF_UNIX:
Utilizado para comunicação entre os processos de uma mesma máquina, utilizando para isso o sistema de arquivos local. Os processos irão referenciar um nome de arquivo válido.
● AF_INET :
Este é o domínio que mais nos interessa, pois é o utilizado para comunicação entre processos remotos. É através dele que vamos poder trocar dados pela Internet, por exemplo. Além disso também pode ser utilizado para comunicação entre processos locais.
Todos os processos serão identificados pelo endereço da máquina na rede (sim crianças, o endereço IP) e um número de porta.
O domínio AF_UNIX não é muito usual, então vamos focar nossa atenção daqui pra frente no AF_INET.
Prosseguindo na nossa aventura, agora temos que entender a diferença entre três tipos de sockets que temos disponíveis:
● Stream :
Considero o tipo mais utilizado. Se você está familiarizado com o conceito de “fluxo” então se sentirá bem a vontade com este socket, pois é exatamente isto que ele irá nos fornecer, uma conexão , um fluxo. Por isso dizemos que o socket stream é orientado a conexões.
No domínio AF_INET ele é implementado utilizando o protocolo TCP/IP. Basicamente, ele irá nos fornecer uma conexão confiável, com tratamento de erros implícito, realizado pelo próprio protocolo.
A principal característica que temos que saber é que ao enviarmos uma mensagem nosso programa irá ficar esperando uma confirmação de recebimento. Caso ocorra algum erro nesta comunicação , a mensagem será enviada novamente. O melhor de tudo é que isso fica totalmente transparante para o programador.
Vale lembrar que as operações com sockets streams são síncronas e bloqueantes, ou seja, ao enviar um dado pelo socket o seu programa irá ficar esperando pela confirmação de recebimento , ou pelo estouro do time out.
● Datagram:
Sockets Datagram, como o nome sugere, possuem um modelo de funcionamento orientado a datagramas, ao invés de fluxos, como no caso do Stream. Obviamente, você meu querido leitor, deve estar a se perguntar “Mas que diabos é um datagrama?“. Bem , datagramas nada mais são do que “pacotes de informação”, você os envia, porém não há um mecanismo de verificação para validar se a mensagem foi recebida, como no caso anterior.Ou seja, se chegar, chegou, senão, sinto muito.
As operações com sockets datagramas são assíncronas e não bloqueantes, ou seja, quando o seu programa envia uma mensagem, ele não fica bloqueado esperando pela confirmação de recebimento, como no caso do socket stream.
Este tipo de socket é implementado utilizando o protocolo UDP (User Datagram Protocol) e é geralmente utilizado para realizarmos distribuição de conteúdo via Broadcast (um pacote destinado a todos os hosts da rede) ou Multicast (um pacote destinado a um conjunto de hosts).
● Raw:
Os Sockets Raw (crús) consistem em um recurso muito interessante, pois ignoram o tratamento que o sistema operacional dá aos pacotes recebidos e fornecem um fluxo onde é possível ler diretamente os dados que estão chegando na placa de rede, exatamente como estes estão sendo recebidos.
Este tipo de socket merece uma explicação bem mais detalhada do que iremos desenvolver aqui. Talvez mais adiante possamos voltar a conversar sobre este sujeito, mas para simplificar as coisas, por hora, vou dizer que com ele podemos ler não somente os dados enviados para a nossa máquina (o chamando “payload” do pacote), mas também todas as informações referentes aos protocolos utilizados.
Este é o socket que você vai utilizar caso deseje implementar um novo protocolo de rede, por exemplo, ou programar um sniffer de rede, fazer injeção de pacotes, enfim, da pra fazer muita coisa divertida com ele.
Bem, não vou prolongar muito mais a conversa, acho que o nosso arcabouço teórico já está vasto o suficiente (não tão vasto quanto deveria ser, mas a vida nunca é como deveria ser) para desenvolver-mos alguns exemplos práticos.
Por enquanto conversamos apenas sobre conceitos, achei melhor discutimos a API que estaremos utilizando (padrão dos sistemas Unix) durante o próprio desenvolvimento do código. Na sequência vamos criar um simples cliente web que baixa o código html de algum site e então iremos criar um simples servidor web, capaz de fornecer páginas html estáticas.
Consultando arquivo XML com LINQ + C#
Olá pessoal,
Aprenderemos hj, de uma forma simples e ágil acessar dados de um arquivo XML utilizando LINQ.
Então vamos lá…
Caso tenhamos o Arquivo XML Filmes.xml armazenado em c:\Filmes.xml com as seguintes marcações abaixo.
<?xml version="1.0" encoding="utf-8" ?> <Filme> <Titulo>Duro de Matar 4.0</Titulo> <Categoria>Ação</Categoria> <Ano>2008</Ano> </Filme>
No C#, necessitaremos adicionar os NameSpaces na classe do Form.
using System.Xml; using System.Xml.Linq;
Adicionamos então neste Form, um botão e um Rich TextBox
No evento do botão adicionado, colocaremos o código abaixo.
XDocument xmlDoc = XDocument.Load("c:\\Filmes.xml");
var filmes = from filme in xmlDoc.Descendants("Filme")
select new
{
Titulo = filme.Element("Titulo").Value,
Categoria = filme.Element("Categoria").Value,
Ano = filme.Element("Ano").Value,
};
richTextBox1.Text = "";
foreach (var filme in filmes)
{
richTextBox1.Text += "Titulo:" + filme.Titulo + "\n";
richTextBox1.Text += "Categoria:" + filme.Categoria + "\n";
richTextBox1.Text += "Ano:" + filme.Ano + "\n";
richTextBox1.Text += "----------------------------- \n\n";
}
Até a próxima
Formatando DateTime com C#
Formatar um DateTime com C# é muito simples, podemos fazer isso utilizando o método ToString() e passando como parâmetro o formato desejado.
String data = DateTime.Now.ToString("formato");
Vejamos agora, alguns exemplos de formato que podemos utilizar:
DateTime hoje = DateTime.Now;
//apenas retorna a data no formato de String
hoje.ToString(); //17/6/2010 22:17:12
//formatos para data/hora completos
hoje.ToString("t"); //22:17
hoje.ToString("T"); //22:17:12
hoje.ToString("d"); //17/6/2010
hoje.ToString("g"); //17/6/2010 22:17
hoje.ToString("G"); //17/6/2010 22:17:12
hoje.ToString("s"); //2010-06-17T22:17:12
hoje.ToString("u"); //2010-06-17 22:17:12Z
hoje.ToString("r"); //Thu, 17 Jun 2010 22:17:12 GMT
hoje.ToString("D"); //quinta-feira, 17 de junho de 2010
hoje.ToString("f"); //quinta-feira, 17 de junho de 2010 22:17
hoje.ToString("F"); //quinta-feira, 17 de junho de 2010 22:17:12
//formatos para dia, mês e ano
hoje.ToString("dd"); //17
hoje.ToString("ddd"); //qui
hoje.ToString("dddd"); //quinta-feira
hoje.ToString("m"); //17 de junho
hoje.ToString("M"); //17 de junho
hoje.ToString("MM"); //06
hoje.ToString("MMM"); //jun
hoje.ToString("MMMM"); //junho
hoje.ToString("y"); //junho de 2010
hoje.ToString("yy"); //10
hoje.ToString("yyyy"); //2010
//formatos para hora, minutos e segundos
hoje.ToString("hh"); //10
hoje.ToString("HH"); //22
hoje.ToString("mm"); //17
hoje.ToString("ss"); //12
//utilizando diferentes formatadores
writer.WriteLine("HH:mm:ss:ffff : " + hoje.ToString("HH:mm:ss")); //22:17:12
writer.WriteLine("dd/MM/yyyy : " + hoje.ToString("dd/MM/yyyy")); //17/06/2010
writer.WriteLine(hoje.ToString("dd-MM-yyyy HH:mm:ss")); //17-06-2010 22:17:12
Urls amigáveis
Apartir da versão 2.0 do asp.net, podemos realizar o mapeamento de urls estáticas.
Para utilizar esse recurso é muito simples, basta adicionar no web.config a tag urlMappings dentro de System.Web.
Observe o exemplo a seguir:
<urlMappings enabled="true"> <add url="~/materias.aspx?id=1" mappedUrl="~/banco-dados" /> <add url="~/materias.aspx?id=2" mappedUrl="~/logica" /> </urlMappings>
Supondo que nós temos um site que em uma determinada página liste a nota do aluno para cada matéria. Para isso, ele usa o id da matéria como parâmetro. Acessando www.seusite.com/logica, ele irá redirecionar para www.seusite.com/materias.aspx?id=2.
Sites de busca deixam de indexar algumas páginas devido ao uso de caracteres como “&” e “?”. E convenhamos… além de ser mais bonita é muito mais fácil memorizar este tipo de url.
Claro, esse tipo de mapeamento não é vantajoso para sites grandes… pois por ser um processo manual, se torna muito trabalhoso e pode levar a erros com mais facilidade. Aconselho que usem dessa forma apenas para sites com poucas páginas. Para sites maiores, podemos utilizar outros componentes.
Por hoje é isso, num outro post falarei sobre um componente mais robusto para mapeamento de url onde é possível o uso de urls dinâmicas.
Guia de Comandos SQL
Galera, seguindo os mesmos passos do último post, vou indicar um bom site para consulta de comandos de SQL. Vale a pena dar uma olhada, tem bastante coisa para guiar em DDL(Data Definition Language), DML(Data Manipulation Language) e DQL(Data Query Language).
http://www.1keydata.com/sql/sql.html
Se tiverem sugestões de outros sites, deixem a sugestão em um comentário. Abraços.
Guia de Connection String
Olá pessoal, um guia rápido e bem completo guia com quase todos se não todos os tipos de connection strings possíveis.
De Database Servers como Sql Server, Oracle até Data Files como Excel e DBF. Segue a dica. Forte Abraço
Trocando informações entre WebForms utilizando Cross Page Posting
O Cross Page Posting, é um recurso do .net (disponível apartir da versão 2.0) que nos permite trocar informações entre páginas Web sem precisarmos utilizar Session ou QueryString.
Supondo que tenhamos um botão e um textbox na tela, e queremos passar o valor digitado pelo usuário para uma segunda página.
Abra o Visual Studio e crie um WebApplication, na página Default adicione um TextBox e um Button.
Nosso botão possui uma propriedade chamada “PostBackUrl“, nessa propriedade setamos a página na qual trabalharemos com as informações digitadas pelo usuário.
Adicione agora uma segunda página no projeto, e nela coloque um Label. Nessa página, vamos obter o valor digitado no TextBox da página Default e mostra-lo no Label.
No Page_Load da segunda página basta adicionar o seguinte trecho de código:
TextBox result = (TextBox)PreviousPage.FindControl("txtCrossPage");
lblCrossPage.Text = result.Text;
Através da propriedade PreviousPage, obtemos o TextBox da página anterior e depois pegamos o valor guardado na propriedade Text e atribuimos ao texto do Label.
Alexandre Rapaki
dodo
sergiodl
Barreto, M.
