O formato PDF (Portable Document Format) foi criado pela empresa Adobe Systems em 1990 e vem sendo aperfeiçoado constantemente. O mesmo tem o objetivo principal de exibir e manipular documentos independentes do aplicativo, sistema operacional ou hardware ao qual for submetido.

Como o PDF é um padrão aberto, qualquer pessoa pode escrever aplicativos que criem ou leiam documentos neste padrão. Suas vantagens vão além, já que sua formatação costuma ser exatamente igual ao do arquivo de origem, preservando assim a qualidade do arquivo original. Além disso, o formato PDF preza pela segurança, visto que temos a opção de gerar arquivos e bloqueá-los por senha, impedindo assim o acesso e o limitando apenas a determinados usuários.

Para entendermos melhor como é gerado o PDF, vamos imaginar o funcionamento de uma impressora: quando clicamos na opção para imprimir um determinado arquivo, os dados deste arquivo são transmitidos à impressora de uma forma que ela o imprima da forma mais parecida possível com a versão digital. Seguindo este conceito, o PDF recebe estes dados e, ao invés de imprimir em um papel, os “imprime” no formato de visualização eletrônica.
Quando convertemos um documento do Word, por exemplo, para o formato PDF, todo seu conteúdo é exibido como se fosse uma imagem, não permitindo assim ao usuário alterar seu conteúdo. Esse recurso é um dos motivos de sua imensa popularidade, sendo muito usado na distribuição de e-books e até mesmo de demonstrativos financeiros de grandes empresas.
O formato PDF é tão seguro que é até mesmo difícil de corrompê-lo. Sem contar o fato de que, quando um documento é convertido para PDF, ele sofre um processo de compactação chegando a ser 10 vezes menor do que o seu tamanho original.

A tecnologia .NET nos oferece um grande arsenal de frameworks para a manipulação de arquivos no formato PDF. Estes que serão visto no decorrer do artigo.

Antes de nos aprofundarmos nas bibliotecas, é necessário que você esteja habituado a alguns conceitos importantes da Orientação a Objetos, pois as bibliotecas utilizadas fazem uso desses conceitos intensivamente.


Classes – Uma classe é definida pela palavra reservada “class” e serve como modelo para armazenar informações, realizar tarefas e disparar mensagens. Um sistema completo é composto, geralmente, por muitas classes que são instanciadas na memória do computador durante a execução do programa. Essa instância feita em memória, no momento em que o programa está sendo executado, chama-se objeto.


Métodos – São ações que realizam tarefas. Eles podem ou não retornar valores e, podem ou não, receber parâmetros. Podem ser criados dentro de uma classe e serem “chamados” na mesma ou em outra classe, por exemplo, usando a instanciação.

Instanciação – É a tarefa de trazer à existência de uma classe. Para compreender melhor isso vamos comparar com algo bem real. Nós fazemos parte da raça humana. Esta define nossas características, como quantidade de membros, ossos e ...

Olá pessoal, neste artigo demonstro como realizar o upload de imagens em ASP.NET, salvando-as em uma pasta física. Acompanhem:

Introdução

Em uma série de artigos feita tempos atrás abordei como fazer o upload de imagens e gravá-las no banco de dados. Mas como em muitos casos as imagens não costumam serem gravadas no banco e sim na própria aplicação, em uma determinada pasta física, resolvi fazer este artigo.

Dito isto, crie uma aplicação Web, adicione a ela uma pasta, chamada Imagens e, na Default.aspx, adicione o controle FileUpload, necessário para ser feito o upload das imagens, além de mais alguns controles, como a Figura 01 ilustra.


Figura 01 - Layout da página

Note a presença do controle ListBox na página, ele será usado mais a frente. O nome Gravar Imagens não é o mais indicado para o botão, já que iremos apenas fazer o upload da imagem em uma pasta física, mais para fins didáticos deixarei este nome.

A Listagem 01 ilustra a codificação deste botão, onde é feito o upload da imagem.

Listagem 01 - Upload da imagem para uma pasta física

protected void btnGravar_Click(object sender, EventArgs e)
        {
            var mensagem = string.Empty;
            if (this.fupImagem.HasFile)
            {
                this.fupImagem.SaveAs(Server.MapPath("Imagens/" + fupImagem.FileName));
                mensagem = "Imagem gravada com sucesso!";
            }
            else
                mensagem = "Selecione uma imagem!";
                
            ScriptManager.RegisterClientScriptBlock(this, this.GetType(), "Mensagem", "alert(' " + mensagem + "')", true);
        }

Repare que, com poucas linhas de código, fazemos o upload da imagem para a pasta Imagens. Note também que é utilizado o método MapPath para se referenciar a pasta física do projeto.

É salvo na pasta como nome da imagem, o atributo FileName do FileUpload, que “pega” o nome exato da imagem, sem a extensão.

A Figura 02 ilustra as imagens na pasta Imagens.


Figura 02 - Pasta Imagens

Vamos agora adicionar um botão ao formulário, abaixo do Gravar Imagens. Dê a esse botão o nome Ver Imagens. Ainda no modo Design, clique na SmartTag do ListBox e cheque a opção Enable AutoPostBack. Agora ...

     Olá pessoal, neste artigo veremos o funcionamento das janelas Immediate, Watch e Quick Watch, do Visual Studio.

     O Visual Studio é uma ferramenta poderosíssima, muito a frente de ser apenas um “editor de códigos” como algumas pessoas acham. Ele conta com muitas (muitas mesmo!) ferramentas essenciais a todo desenvolvedor de sistemas. Pretendo abordar as mais importantes, aos poucos.

     Temos diversas janelas no Visual Studio, que nos auxiliam na execução de nossos sistemas. Neste artigo citarei três delas.

     Immediate Window – Esta é, dentre todas as janelas do VS, a mais útil, com certeza. Ela nos permite realizar codificações e alterações no código em tempo de execução (enquanto estamos debugando a aplicação).

     A documentação da MSDN sobre esta janela diz o seguinte: “O Immediate Window é usado em tempo de design para debugar e avaliar expressões, executar statements, imprimir valores de variáveis, etc. Permite a você digitar expressões para serem avaliadas ou executadas pela linguagem de desenvolvimento durante o debugging.” (tradução livre).

     Assim, podemos avaliar o código da aplicação, como avaliarmos qualquer outro código, como podemos ver na Figura 01, que ilustra a operação básica de soma das variáveis criadas em tempo de execução.

Figura 01 – Criando variáveis e as somando, no Immediate Window

Podemos utilizar a interrogação antes de declarar as expressões, é de uso opcional.

    

...

    Às vezes, nas aplicações Web que desenvolvemos, de acordo com a lógica desenvolvida em nossos métodos, precisamos exibir uma mensagem ao usuário informando determinada situação.

    Para exibirmos essa mensagem podemos utilizar o famoso alert, do Javascript. Confira na Listagem 01 a função JS e na Listagem 02 como chama-la de forma simples e rápida, em apenas uma linha de código.

Listagem 01 – Função JS

function Mensagem() {

            alert('Registro gravado com sucesso!');
        }

Listagem 02 – Chamando a função JS via código

ScriptManager.RegisterClientScriptBlock(Page, Page.GetType(), "mensagem",
 "Mensagem()", true);

    É chamado o método RegisterClientScriptBlock, da classe ScriptManager, e são passados cinco parâmetros, que são descritos abaixo:

 - O controle ou página em que o script está sendo registrado;

 - O tipo que está sendo chamado no parâmetro (no caso indica a própria página);

 - Uma string definindo um nome qualquer ao alert;

 - A chamada a função da Listagem 01 (sempre passada entre aspas, já que ela é uma string);

...

A struct DateTime, do namespace System, do .NET Framework é constantemente utilizada por desenvolvedores (lembrando que, como ela é uma struct também é usada como um tipo de dado).

Esta struct conta com dezenas de objetos para manipular valores relacionados a datas e horas, como é bem explicado pela documentação oficial da MSDN. Veremos neste artigo os principais e de uso comum pelos desenvolvedores no dia-a-dia.

Começando pelos construtores, quando instanciamos a struct temos nada menos que 12 sobrecargas nela (a 1ª vazia, por padrão), as quais podem ser vistas em detalhes neste link.

De métodos estáticos (que não precisam ser instanciados) temos 13 deles (sem contar o ReferenceEquals, que herda de Object e está presente na grande maioria dos objetos) onde destaco 4 deles, que serão descritos a seguir.
· DaysInMonth – Este método retorna um valor inteiro que mostra o número de dias de um mês, especificado pelo usuário. O método contém dois parâmetros, que são o ano e o mês, ambos do tipo int.

· IsLeapYear – Também retorna um valor inteiro, a diferença é que este método recebe apenas um parâmetro, que é o ano, do tipo int, e mostra se o ano fornecido pelo usuário é bissexto.

· Parse – Utilizado em diversos outros tipos de dados, o Parse serve para converter uma variável do tipo string para o tipo que executou o método (em nosso caso para DateTime). Seu método tem três sobrecargas, porém a mais utilizada é a 1ª, que espera uma string, representando a data a ser convertida.

· SpecifyKind – Retorna um DateTime com a data de acordo com o horário local, padrão UTC ou um valor não especificado, de acordo com o parâmetro DateTimeKind, do método. Como estamos no Brasil ele retorna a data no formato DD/MM/YYYY, caso estivéssemos nos EUA, por exemplo, ele retornaria MM/DD/YYYY.

A struct DateTime contém 28 métodos, abaixo é listado alguns deles.

· Add, AddDays, AddHours, AddMinutes, AddSeconds, AddYears – Este conjunto de métodos são utilizados, na ordem, para adicionar um intervalor de tempo, dias, horas, minutos, segundos e anos a variável que a chamou.

· Subtract – Como o nome sugere, este método subtrai um intervalo de tempo da variável que a chamou. Ele espera como parâmetro um objeto do tipo TimeSpan, que representa um intervalo de tempo, definido pelo usuário.

· ToLongDateString e ToLongTimeString – Converte a data para o formato longo de data (quarta-feira, 08 de Fevereiro de 2012) e/ou hora (00:00:00).

· ToShortDateString e ToShortTimeString – Faz a mesma operação que o método acima, apenas convertendo para o formato curto de data (08/02/2012) e/ou de hora (0:00).

A struct DateTime conta com 16 propriedades, 3 estáticas. Abaixo é listado 12 delas.

· Now, Today e Date – As 2 primeiras propriedades são estáticas (não necessitam de instanciação) e retornam, respectivamente, a data e hora exata, no momento em que a mesma for chamada, e o dia de hoje. A 3ª faz o mesmo que a propriedade Today, a diferença é que ela precisa ser instanciada pra ser utilizada.

· Day, DayOfWeek e DayOfYear – Como os nomes sugerem, estas propriedades retornam, respectivamente, o dia atual, o dia da semana (em inglês, é claro) e o dia do ano. Fazendo um teste com o dia em que este artigo foi feito, foram retornados, dia 08, dia da semana Wednesday e dia do ano 39.

· Hour, Minute ...

Em determinadas situações temos métodos com nomes e ações parecidas, mais que são de tipos diferentes.

Para evitar o copiar e colar (pode ser perigoso, acredite!) de métodos podemos criar uma interface, com métodos genéricos, fazendo com que nossas classes herdem dessa interface, implementando assim esses métodos (e repetindo-os, apenas trocando o tipo).

A Listagem 01 ilustra a criação dessa interface.

Listagem 01 – Interface com métodos genéricos

public interface IMetodos<T> where T : new()
        {
            string Excluir<P>(P id);
            int Inserir(T objModel);
            List<T> Consultar(T objModel);
            string Atualizar<P>(T objModel);
        }

Defino um nome qualquer para a interface, onde o T (o T indica que é um tipo de dado do Framework, sem especificar qual) herdar da palavra-chave new, indicando que é uma instância da interface. Note que a interface tem como parâmetro um tipo, definido por T.

Para mais informações sobre Interfaces Genéricas sugiro a leitura deste link.

Na Listagem 02 conferimos uma classe Produtos, herdando de nossa interface.

Listagem 02 – Classe herdando a interface criada e aplicando os métodos genéricos

public class ModeloProdutos
    {
 
    }

    public class Produtos : Conexao.IMetodos<ModeloProdutos>
    {
        public string Excluir<P>(P id)
        {
            throw new NotImplementedException();
        }
 
        public int Inserir(ModeloProdutos objModel)
        {
            throw new NotImplementedException();
        }
 
        public List<ModeloProdutos> Consultar(ModeloProdutos objModel)
        {
            throw new NotImplementedException();
        }
 
        public string Atualizar<P>(ModeloProdutos objModel)
        {
            throw new NotImplementedException();
        }
    }

Note que antes da classe criei outra classe, a ModeloProdutos, que nada mais é do que o tipo que a interface espera, para que a implementação funcione sem erros.

Os métodos foram gerados automaticamente, conforme é ilustrado pela Figura 01.



Figura 01 – Gerando os métodos implementados pela interface

Apenas lembrando que se uma classe herda de uma interface, ele deve, obrigatoriamente, conter os métodos implementados pela interface.

Assim finalizo a quick tip. Muito obrigado a todos!

Um abraço, e até o próximo artigo.

Wellington Balbo de Camargo
wellingtonbalbo@gmail.com-->">

Inicialmente veremos como limitar um campo texto para receber apenas caracteres numéricos.

Para isso, em sua ASPX, dentro da tag head crie uma função que irá fazer essa limitação, como ilustra a Listagem 01.

Listagem 01 – Função para permitir somente números

<script type="text/javascript">
        function PermiteSomenteNumeros(event) {
            var charCode = (event.which) ? event.which : event.keyCode
            if (charCode  >  31 && (charCode  <  48 || charCode  >  57))
                return false;
            return true;
        }
     < /script>

No TextBox chame a função pelo evento onkeypress, como ilustra a Listagem 02.

Listagem 02 – Chamada a função no TextBox

<asp:TextBox ID="txtProduto" runat="server" 
onkeypress="return PermiteSomenteNumeros(event);" />

O evento onkeypress é “chamado” a cada novo caracter inserido pelo usuário no TextBox. Faça os testes e tente incluir letras.
A próxima função é muito útil, com ela conseguimos recuperar o valor de um TextBox e atribuirmos outro valor qualquer a ele.
A Listagem 03 exibe esta função.

Listagem 03 – Recuperando o ID do controle

<script type="text/javascript">
       function RecuperandoValorControle() {
            var controle = document.getElementById(" < %=txtProduto.ClientID% > ")
           alert(controle.value);
        }
     < /script>

...

Olá pessoal, neste artigo será dado continuidade ao projeto criado para editar dados do GridView, em .NET, utilizando a linguagem C#. Acompanhem:

Já temos feito o carregamento dos dados e passagem via QueryString do ID do produto para a página de detalhes, onde é recuperado esse ID, feito uma consulta no banco e retornado os valores para os TextBoxes.

Adicione a esta página um botão, dando a ele o ID btnAlterarValores. Agora vá a página de códigos e crie uma variável que será a propriedade que irá armazenar o ID do produto, no momento em que essa página for chamada. Dessa forma utilizaremos o conceito de ViewState. A Listagem 01 ilustra a criação dessa propriedade.

Listagem 01 - Propriedade IdProduto, usando ViewState

public Int32 IdProduto
        {
            get
            {
                if (ViewState["IdProduto"] != null)
                    return Convert.ToInt32(ViewState["IdProduto"]);

                return 0;
            }
            set
            {
                ViewState["IdProduto"] = value;
            }
        }

Obs: Note que é usado o get e o set, já que a utilizo para retornar e atribuir valor.

Assim, conseguimos manter o valor do ID mesmo após a página sofrer um Postback. Altere o evento Load da página para que a propriedade criada receba o valor do ID, como ilustra a Listagem 02.

Listagem 02 - Evento Page Load

protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                if (Request.QueryString["IdProduto"] != null)
                {
                    this.CarregarDetalhesProduto(Convert.ToInt32(Request.QueryString["IdProduto"]));
                    this.IdProduto = Convert.ToInt32(Request.QueryString["IdProduto"]);
                }
            }
        }

Agora é necessário criar o método para atualizar os dados no banco. Para isso vá a classe Produtos e crie uma variável que irá conter a instrução de UPDATE, ilustrado na Listagem 03.

Listagem 03 - Instrução SQL de Update

public string strUpdate = "UPDATE Products SET " + 
                          " ProductName = @ProductName, UnitPrice = @UnitPrice, " + 
                          " UnitsInStock = @UnitsInStock " + 
                          " WHERE ProductID = @ProductID";

A Listagem 04 ilustra o método para atualizar os dados. Listagem 04 - Método AtualizarValores

public void AtualizarValores(ModeloProdutos objModelo)
        {
            using (objConexao = new SqlConnection(strStringConexao))
            {
                using (objCommand = new SqlCommand(str

...

Olá pessoal, neste artigo será criado um projeto para editar dados do GridView, em .NET, utilizando a linguagem C#. Acompanhem:

Introdução- Em projetos de software, sejam pessoais ou profissionais, é normal que tenhamos a situação em que precisamos ver uma lista de dados e, ao clicar em cada registro desta lista, vermos os detalhes da mesma, em uma nova página. Como essa tarefa já é algo mais do que normal em nossa área (se você ainda não precisou fazer isso, um dia irá precisar!) decidi fazer este artigo, também devido a alguns pedidos dos leitores deste blog.

Crie um projeto em ASP.NET. Para este exemplo usarei o banco de dados Northwind, da Microsoft. Caso não o tenha instalado, clique aqui! .
A tabela que será usada para este exemplo é a Products.
Após instalar o banco e configurar a conexão com o Visual Studio, abra o Web.config e adicione uma chave, responsável por conter a string de conexão com o banco de dados, ilustrado na Listagem 01.

Listagem 01 - String de conexão adicionada ao Web.config

<connectionStrings>
		<add name="StringConexao" 
connectionString="Data Source=.\SQLEXPRESS;Initial 
Catalog=Northwind;Integrated Security=True" 
providerName="System.Data.SqlClient"/>
	</connectionStrings>

Adicione ao projeto uma classe, dando a ela o nome Produtos. Essa classe irá conter a lógica de acesso aos dados. Nela, adicione cinco variáveis públicas, visíveis por toda a classe, como ilustrado pela Listagem 02.

Listagem 02 - Variáveis públicas

public SqlConnection objConexao;
public SqlCommand objCommand;
public string strStringConexao = 
ConfigurationManager.ConnectionStrings["StringConexao"].ConnectionString;
public string strSelect = "SELECT TOP 10 ProductID, ProductName, UnitPrice,
 UnitsInStock FROM Products";
public string strSelectPorID = "SELECT ProductID, ProductName, UnitPrice, 
UnitsInStock FROM Products WHERE ProductID = @ProductID";

As duas primeiras variáveis conterão os objetos de conexão e comando do banco de dados, a terceira conterá a string de conexão, recuperada do Web.config, e as duas últimas receberão as instruções SELECT de consulta aos dados.

A Listagem 03 ilustra a classe com as propriedades referentes as colunas do banco que traremos pelas instruções SELECT.

Listagem 03 - Classe Modelo

public class ModeloProdutos
        {
            public Int32 ProductID { get; set; }
            public String ProductName { get; set; }
            public Decimal UnitPrice { get; set; }
            public Int16 UnitsInStock { get; set; }
        }

A Listagem 04 ilustra o método para retornar os produtos do banco de dados, com o auxílio da Listagem 05, que irá iterar pelo DataReader preenchendo a lista com os dados.

Listagem 04 - Método ConsultarProdutos

public List<ModeloProdutos> ConsultarProdutos()
        {
            var lstRetorno = new List<ModeloProdutos>();
            using (objConexao = new SqlConnection(strStringConexao))
            {
                using (objCommand = new SqlCommand(strSelect, objConexao))
                {
                    try
                    {
                        objConexao.Open();
                        var objDataReader = objCommand.ExecuteReader();
                        if (objDataReader.HasRows)
                            lstRetorno = PreencheValores(objDataReader);
                    }
                    catch (Exception ex)
                    {
                        throw new Exception(ex.Message);
                    }
                    finally
                    {
                        objConexao.Close();
                    }
                }
            }
            return lstRetorno;
        }

Listagem 05 - Método PreencheValores

public List<ModeloProdutos> PreencheValores(SqlDataReader reader)
        {
            var lista = new List<ModeloProdutos>();
            while (reader.Read())
            {
                var modeloProdutos = new ModeloProdutos();
                modeloProdutos.ProductID = Convert.ToInt32(reader["ProductID"].ToString());
                modeloProdutos.ProductName = reader["ProductName"].ToString();
                modeloProdutos.UnitPrice = Convert.ToDecimal(reader["UnitPrice"].ToString());
                modeloProdutos.UnitsInStock = Convert.ToInt16(reader["UnitsInStock"].ToString());
                lista.Add(modeloProdutos);
            }
            return lista;
        }

Com a estrutura praticamente pronta da classe, na próxima parte faremos a parte do layout e os testes práticos com os métodos criados.

Neste momento agora renomeie sua página para Produtos.aspx arraste para a página o controle GridView. Nele, altere suas configurações para que fique parecido com o da Listagem 06.

Listagem 06 - GridView de Produtos

<asp:GridView ID="grdDados" runat="server" AutoGenerateColumns="false" OnRowCommand="grdDados_RowCommand">
        <Columns>        
            <asp:BoundField DataField="ProductName" HeaderText="Produto" />
          

...

 Já vi (e já fiz) métodos com vários parâmetros, alguns com até dezenas (esses eu só vi!) de parâmetros em sua assinatura. Isso acarreta problemas de legibilidade e manutenção futura.

 Para resolver isso é simples: podemos encapsular todos os parâmetros passados para o método em uma única classe (desde que os parâmetros façam parte do mesmo contexto e que cheguem ao mesmo objetivo, para que não criemos uma classe problemática).

 A Listagem 01 mostra um método com muitos parâmetros em sua assinatura.

Listagem 01 – Método com N parâmetros

private void Gravar(string Nome, string Endereco, string Telefone, 
string Bairro, string Cidade, string Estado, bool Ativo, 
DateTime DataCadastro)

        {

            //código

        }

 Na Listagem 02 vemos o mesmo método, com apenas um parâmetro, que é um objeto da classe Pessoa, exibida pela Listagem 03.

Listagem 02 – Método com apenas um parâmetro

 private void Gravar(Pessoa objPessoa)

        {

            //código

        }

Listagem 03 – Classe Pessoa

public class Pessoa

  

...

Veja neste artigo uma serie de funções sobre o SQL Server.

Funções de agrupamento:

AVG() = Retorna o valor médio de uma coluna específica
BINARY_CHECKSUM() = O valor do BINARY_CHECKSUM computado sobre uma linha ou uma tabela ou sobre uma lista de expressões. BINARY CHECKSUM é usada para detectar alterações em uma linha ou uma tabela.
CHECKSUM() = O valor de CHECKSUM computado sobre uma linha ou uma tabela, ou sobre uma lista de expressões. CHECKSUM é usada para construir índices de hash.
CHECKSUM_AGG() = O valor de CHECKSUM de um grupo. Valores nulos são ignorados.
COUNT() = Retorna o número de linhas
COUNT_BIG() = igual ao COUNT mas o COUNT_BIG sempre retorna um tipo de dados bigint.
MAX() = Retorna o valor máximo de uma coluna específica
MIN() = Retorna o valor mínimo de uma coluna específica
SUM() = Retorna a soma de uma coluna específica
STDEV() = Desvio padrão de todos os valores
STDEVP() = Desvio padrão da população
VAR() = Variância estatistica de todos os valores
VARP() = Variância estatística de todos os valores da população

Funções de manipulação de strings:

ASCII(string) = pega o valor em ASCII da string
CHAR(integer) = troca inteiro do ASCII em um caracter
LEN(string) = Identifica o comprimento de uma expressão em caracteres
LOWER(string) = converte uma string uppercase para lowercase.
LTRIM(string) = remove os espaços em branco
PATINDEX(posicao, expressao) = devolve a posicão de uma string dentro de um texto. Se não encontrar, retorna zero.
REPLICATE(string, integer) = Repete N vezes um caractere especificado
REVERSE(string) = retorna o inverso de uma expressao
RTRIM (string) = remove os espaços em branco à direita de uma string
SPACE(integer) = que retorna o número de espaços em branco informados no parâmetro
STUFF(string texto, X, Y, string texto_a_inserir) = apaga da string “texto” os y caracteres a partir da posição x e os substitui por “texto_a_inserir”
SUBSTRING(string texto, posicao_inicial, tamanho) = retorna uma string com o comprimento definido em “tamanho” extraida da string “texto”, a partir da “posicao_inicial”
UPPER(string) = retorna string em maiusculas

Funções de manipulação de data/hora:
nomes das partes de data:

Year = yy, yyyy
Quarter = qualquer, que
Month = mm, m
Dayofyear = dy, y
Day = dd, d
Week = wk, ww
Hour = hh
Minute = mi, n
Second = ss, s
Millisecond = ms

DATEADD (parte, numero, data) = adiciona um valor a parte de uma data
DATEDIFF (parte, data inicial, data final) = subtrai a data inicial da data final, indicando o resultado na unidade definida em “parte”

...

 Split – O Split é usado para dividir uma string em pequenos pedaços. Para isso, seu método retorna um array de strings, contendo as respectivas partes, definidas de acordo com a string passada como parâmetro, que na verdade funciona como o “agente” divisor da mesma.

 De uma forma resumida pense na string “micro-ondas” (sim, a nova regra ortográfica fez isso conosco!). Supondo que desejamos dividi-la pelo hífen, teríamos que fazer a implementação ilustrado na Listagem 01, feita em um Console Application.

Listagem 01 – Método Split

string texto = "micro-ondas";

            string[] retornoSplit = texto.Split('-');

            Console.WriteLine(String.Format("Posição 0: {0} \nPosição 1: {1}", retornoSplit[0], retornoSplit[1]));

            Console.ReadKey();

 Note que o método Split espera um char como parâmetro, por isso são usadas as aspas simples. O resultado do código acima é ilustrado pela Figura 01.

Figura 01 – String dividida em dois

 Isso é simples, se soubermos em quantos elementos serão divididos nossa string. Mais e se não soubermos? Para isso podemos utilizar um laço for. Suponhamos que nossa string seja “micro-ondas-micro-ondas-micro-ondas”. A Listagem 02 ilustra como podemos fazer para descobrir o número de elementos do array de strings e iterar os valores.

...

Em determinadas situações precisamos percorrer os registros do GridView, um a um, sem utilizar a paginação do próprio que engloba grupos de páginas. Uma maneira de se fazer isso é utilizar botões para avançar, retroceder, ir ao primeiro e ao último registro da página.

 Para resolver isso podemos criar uma variável que será uma lista genérica, que ficará no ViewState, recuperar os dados que queremos consultar, jogarmos os mesmos nesta lista e a utilizarmos em cada um dos botões citados acima.

Se você não conhece o ViewState sugiro que veja estes artigos.

 A Listagem 01 ilustra a criação da variável citada anteriormente.

Listagem 01 – Lista armazenada no ViewState

public List<Products> listaProdutos
        {
            get
            {
                if (ViewState["vwListaProdutos"] != null)
                    return (List<Products>)ViewState["vwListaProdutos"];
                else
                    return null;
            }
            set
            {
                ViewState["vwListaProdutos"] = value;
            }
             }

 No exemplo uso uma lista genérica da classe Products, referente à tabela de mesmo nome do banco Northwind. A classe está ilustrada na Listagem 02.

Listagem 02 – Classe Products

[Serializable]
        public class Products
        {
            public int ProductID { get; set; }
            public string ProductName { get; set; }
            public decimal UnitPrice { get; set; }
        }

 Note que a classe tem, acima dela, a marcação que ela é uma classe do tipo Serializable (serializável), o que significa que estamos mantendo o estado do objeto/classe para o utilizarmos posteriormente em nosso desenvolvimento.

Mais informações sobre serialização Link 1, Link 2 e Link 3.

 A Listagem 03 ilustra a declaração de uma variável do tipo int, no ViewState. Ela será usada na codificação dos botões.

Listagem 03 – Índice da linha, armazenado no ViewState

public Int32 indiceLinha
        {
            get
            {
                if (ViewState["vwIndiceLinha"] != null)
                    return (Int32)ViewState["vwIndiceLinha"];
                else
                    return Int32.MinValue;
            }
            set
            {
                ViewState["vwIndiceLinha"] = value;
            }
        }

  Neste exemplo estou utilizando apenas dois campos, ProductName e UnitPrice. Assim, a Figura 01 ilustra a minha aspx com os botões que iremos usar para navegar entre os registros. ...

É possível vermos em diversos sites e portais endereços de url que não são tão fáceis de decorar devido ao tamanho e, a muitas vezes, inclusão de números e valores que a deixam complexa, difícil de memorizar e sem sentido (pensando no usuário comum, é claro).

Para resolver este problema existem as urls amigáveis. Com elas conseguimos transformar uma url complexa em uma url fácil de entender e memorizar.

Um exemplo simples: uma página de detalhe de um determinado produto, que teria a seguinte url:

http://www.site.com.br/DetalheProduto.aspx?IdProduto=12345

Transformar-se-ia facilmente em:

http://www.site.com.br/Produto

Temos duas formas de fazer isso (pelo menos as duas mais usadas): 1- abrindo a chave urlMappings no Web.Config e incluindo, manualmente, a url que desejamos deixar amigável, e 2- fazendo isso de forma dinâmica (a que acho melhor e mais correta).

Para a criação do exemplo deste artigo foi usada a documentação da MSDN sobre a classe UrlMapping, que pode ser vista neste link.

Crie uma aplicação Web, criando duas páginas, dando a elas o nome Produtos.aspx e DetalheProduto.aspx. No arquivo de configuração do site, o Web.Config, adicione a chave do urlMappings, dentro da chave system.web, como ilustra a Listagem 01.

Listagem 01 – Chave UrlMappings que conterá a Url amigável

<system.web>
<u

...

 Muitas vezes precisamos não só fazer um INSERT de um registro no banco, como também recuperarmos o ID gerado para o utilizarmos em outras situações. 

 Lembrando que, para que o SQL Server nos gere um ID após realizarmos o INSERT, nossa coluna deve ser do tipo Identity e ser chave primária (Primary Key).

 Se focando no método em si e na instrução SQL, a Listagem 01 nos exibe o INSERT, com o uso do SELECT SCOPE_IDENTITY(), para retornar para nós o ID gerado.

Listagem 01 – Instrução SQL

string strInstrucaoSql = "INSERT INTO Clientes VALUES (@Nome, @Endereco, 
@Telefone, @Sexo, @Ativo, @DataCadastro) SELECT SCOPE_IDENTITY()";

 Na Listagem 02 é criado uma variável do tipo Int32 que recebe o método ExecuteScalar convertido para o tipo da variável, da classe SqlCommand, necessária para nos retornar o ID que é gerado após a execução da instrução SQL da Listagem 01.

...

 Muitas aplicações recuperam a string de conexão com o banco direto na página aspx ou no formulário (essa dica serve para aplicações ASP.NET e/ou Windows Forms), o que por si só já é errado pois o programador nem se deu o trabalho de ao menos criar uma classe específica para isso, separando assim a lógica de dados da apresentação e mantendo o código mais limpo.

 Só que, mesmo que o programador deixe a string lá, em uma classe específica, isso não é considerado boa prática de desenvolvimento. O ideal é deixa-la no arquivo de configuração de sua aplicação, seja Web.Config (ASP.NET), seja App.Config (Windows Forms).

 Vamos então imaginar que o usuário já fez isso, a Listagem 01 mostra a string de conexão ao banco de teste Northwind, da Microsoft:

Listagem 01 – String de conexão adicionada ao arquivo de configuração da aplicação

<connectionStrings>
    <add name="ConnectionString" connectionString="Data Source=.\SQLEXPRESS;
Initial Catalog=Northwind;Integrated Security=True"
         providerName="System.Data.SqlClient"/>
  </connectionStrings>

 Para recuperar a string de conexão em sua classe é simples. A Listagem 02 mostra como fazer isso:

Listagem 02 – Recuperando a string de conexão e atribuindo a mesma a uma variável

[code

...

 Olá pessoal, confira as dicas rápidas de hoje:

 Dica 1 – Usando Line Numbers em seu código – Geralmente quando instalamos o Visual Studio 2008 (ou outras versões) e começamos a codificar por padrão não temos as famosas Line Numbers, que são as linhas laterais em nosso código, como a Figura 01 ilustra.

Figura 01 – Line Numbers

 Para habilitarmos a Line Numbers em todos os projetos do Visual Studio, faça o seguinte: clique em Tools > Options e aguarde a janela se abrir. Nela, expanda a aba Text Editor, como a Figura 02 nos mostra.

Figura 02 – Text Editor

 Agora clique em All Languages e, do lado direito da tela, marque a opção Line Numbers, ilustrado na Figura 03.

Figura 03 – Habilitando os Line Numbers

 Simples né? Vamos a próxima dica rápida.

Dica 2 – Alterando a página inicial do Visual Studio – Se cansou

...

Olá pessoal, desde que instalei o Visual Studio 2010 Ultimate em meu notebook, notei algo diferente, as letras ficavam borradas em toda a interface, veja como era o meu dilema minha tela de códigos, na Figura 01.

Figura 01 – Códigos Borrados

Isso atrapalhava principalmente na hora de desenvolver. Achei estranho, não sabia se era porque uso Windows 7 de 64 bits em meu notebook, não vi relação disso com o erro. Até que, fuçando na net, vi no blog do Agnaldo que ele passou pelo mesmo problema.

Pra resolver fiz o seguinte: Fui ao registro do Windows (só apertar Windows + R e digitar regedit na janela que surge), depois fui em HKEY_CURRENT_USER\Software\Microsoft e criei uma chave, como é ilustrado na Figura 02.

Figura 02 – Criando Chave no Registro do Windows

Na chave criada, dei a ela o nome Avalon.Graphics. No meu caso tive que cria-la mais podem ter casos em que ela já exista. Pra todos os casos, dentro desta chave temos que criar uma chave DWord, chamada DisableHWAcceleration, como a Figura 03 ilustra.

...

 Olá pessoal, a dica de hoje é em homenagem ao André Raiça, amigo meu que teve esse problema e conseguimos resolver depois de apanhar um pouco!

 Quando tentamos compilar nosso código com erro, seja uma aplicação Web, seja Windows Forms aparece a mensagem da Figura 01.

Figura 01 – Mensagem de erros na aplicação

 Se você marca o CheckBox com a mensagem Do not show this dialog again, que traduzindo seria algo como Não exibir esta caixa de diálogo novamente, da próxima vez que ocorrerem erros em seu código e você debugar o projeto, esta mensagem de erro não aparecerá.



...

 Introdução – Todo desenvolvedor deve se prevenir e capturar possíveis erros em suas aplicações utilizando os blocos try/catch. Só que, em determinadas situações, não é suficiente capturarmos o erro e não fazermos nada com ele. Em certos casos é importante também gravarmos os erros em um log para que o mesmo seja recuperado em um momento posterior.

 Nesta série de artigos começaremos a criar, nesta parte, a aplicação ASP.NET e o arquivo XML, que receberá os erros.

 Assim sendo crie a aplicação ASP.NET e adicione a ela um arquivo XML, dando a ele o nome LogErros. Nele, apenas adicione a chave , como é ilustrado na Figura 01.

Figura 01 – Estrutura do arquivo XML

 Na Default.aspx, adicione alguns controles para que o aspx fique parecido como na Listagem 01 (usei um exemplo de formatação do Visual Studio) e o resultado como na Figura 02.

Listagem 01 – Default.aspx

<div>
        <h3>Exemplo Log de Erros</h3>
        <asp:Button ID="btnGerarExcecao" runat="server" Text="Gerar Exceção" />   
        <br />
        <br />
        <asp:GridView ID="grdExcecoes" runat="server" AutoGenerateColumns="False"
            BackColor="White" BorderColor="#999999" BorderStyle="None" BorderWidth="1px"
            CellPadding="3" GridLines="Vertical">
            <RowStyle BackColor="#EEEEEE" ForeColor="Black" />
            <FooterStyle BackColor="#CCCCCC" ForeColor="Black" />
            <PagerStyle BackColor="#999999" ForeColor="Black" HorizontalAlign="Center" />
            <SelectedRowStyle BackColor="#008A8C" Font-Bold="True" ForeColor="White" />
            <HeaderStyle BackColor="#000084" Font-Bold="True" ForeColor="White" />
            <AlternatingRowStyle BackColor="#DCDCDC" />
        </asp:GridView>
</div>

Figura 02 – Layout da página

 Assim iremos gerar as exceções e vermos, logo após as gravarmos no XML, o resultado exibido no GridView.

 Crie uma classe dando a ela o nome GerenciamentoLog. Nela, inicialmente criaremos o método para gravar o registro no XML. A Listagem 02 ilustra este método (lembre-se de declarar o namespace System.XML).

Listagem 02 – Método para gravar o Log em XML

public void GravarErro(string mensagemErro, Exception innerException, string stackTrace)
        {
            try
            {
                //Instancio o objeto da classe XmlDocument que irá carregar o arquivo XML
                XmlDocument xmlDocument = new XmlDocument();
                xmlDocument.Load(HttpContext.Current.Server.MapPath(@"LogErros.xml"));
 
                //Instancio o objeto da classe XmlElement e crio os elementos
                XmlElement xmlElementoPai = xmlDocument.CreateElement("erro");
                XmlElement xmlElementMensagemErro = xmlDocument.CreateElement("mensagemerro");
                XmlElement xmlElementInnerException = xmlDocument.CreateElement("innerexception");
                XmlElement xmlElementStackTrace = xmlDocument.CreateElement("stacktrace");
                XmlElement xmlElementDataErro = xmlDocument.CreateElement("dataerro");
 
                //Atribuo o valor dos parâmetros do método nos objetos criados anteriormente
                xmlElementMensagemErro.InnerText = mensagemErro;
 
                if (innerException != null)
                    xmlElementInnerException.InnerText = innerException.ToString();
                else
                    xmlElementInnerException.InnerText = "sem InnerException.";
               
                xmlElementStackTrace.InnerText = stackTrace;
                xmlElementDataErro.InnerText = "Data: " + DateTime.Now.ToShortDateString() +
                    " | Hora: " + DateTime.Now.ToShortTimeString();
 
                //Adiciono o elemento XML na lista de nós filhos do objeto xmlElementoPai
                xmlElementoPai.AppendChild(xmlElementMensagemErro);
                xmlElementoPai.AppendChild(xmlElementInnerException);
                xmlElementoPai.AppendChild(xmlElementStackTrace);
                xmlElementoPai.AppendChild(xmlElementDataErro);
 
                //Adiciono o elemento XML na lista de nós filhos do objeto xmlDocument
                xmlDocument.DocumentElement.AppendChild(xmlElementoPai);
 
                //Salvo os dados do xmlDocument no arquivo XML
                xmlDocument.Save(HttpContext.Current.Server.MapPath(@"LogErros.xml"));
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

 Acho que os comentários no código falam por si só. Assim eu gravo os dados no arquivo XML.

 Agora dê dois cliques no botão Gerar Exceção, para que o mesmo crie seu evento click. Nele, adicione o código da Listagem 03.

Listagem 03 – Gerando a Exceção

protected void btnGerarExcecao_Click(object sender, EventArgs e)
       {
            GerenciamentoLog objLogErros = new GerenciamentoLog();

           try
            {
                // Simulação de erro - tentativa de divisão por 0
                int numero = 0;
                int resultado = 5 / numero;
            }
            catch (Exception ex)
            {
                objLogErros.GravarErro(ex.Message, ex.InnerException, ex.StackTrace.TrimStart());
            }
        }

 Assim simulamos uma exceção, para que o método que criamos na Listagem 01 seja utilizado. O

...