Depois de mais de 10 dias sem escrever nada (logo mais vocês irão entender porque eu não escrevi nada), estou ressurgindo em 2009 tentando montar uma lista do que eu irei tentar passar para todos neste próximo ano.

Bom, vamos lá. Irei dar sequência a série C# para iniciantes agora focando nas inovações do Framework 3.5, além dessa série irei continuar também a série Programação Orientada a Objetos.

Neste ano irei focar um pouco mais no MVC Framework ASP.NET que ainda está na versão Beta, junto com o MVC irei abordar também sobre LINQ. Apresentar soluções usando JavaScript, JQuery, CSS, além de sites de referência.

Além desses assuntos citados acima, irei abordar sobre diversas tecnologias. É claro que está não é uma lista definitiva e que não irei escrever sobre outros assuntos, isto é apenas uma idéia do que quero começar a fazer neste ano.

Espero que vocês estejam comigo neste próximo ano e que gostem dos assuntos.

Ah, antes de encerrar este post preciso dizer porquê eu não estava escrevendo durantes esses 10 dias. ISOLAMENTO TECNOLÓGICO. Sim, fiquei todo esse tempo sem ter contato com qualquer tipo de tecnologia, nada, nem mesmo TV, mas não me arrependo, aproveitei e estou renovado para este ano.

Feliz 2009 para todos.

Mais simples do que realizar uma busca usando LinqToSQL (veja o post aqui), é realizar uma busca em um arquivo XML usando LinqToXML.

Vamos logo ao que interessa, ou seja, o código.

Primeiros devemos montar um arquivo do tipo XML.

<?xml version="1.0" encoding="utf-8" ?>
<garage>
  <carro>
    <cor>Azul</cor>
    <ano>2000</ano>
    <modelo>Gol</modelo>
  </carro>
  <carro>
    <cor>Preto</cor>
    <ano>2008</ano>
    <modelo>Palio</modelo>
  </carro>
  <carro>
    <cor>Branco</cor>
    <ano>2006</ano>
    <modelo>Uno</modelo>
  </carro>
</garage>

Agora devemos carregar o arquivo criado acima e em seguida realizarmos uma consulta usando LINQ para escrever o resultado.
Ao montar a consulta você poderá realizar qualquer tipo de filtro, pois, nosso XML já está em uma collection, o que nos permite realizar uma busca atráves do LINQ.

  //Carregue um arquivo do tipo XML
  XDocument xml = XDocument.Load(Server.MapPath("upload/Arquivo.xml"));

  //Recupere todos os nós do tipo "carro"
  //Logo em seguida renomeie para os campos que você está retornando
  var carros = from carro in xml.Descendants("carro")
  select new
  {
    Cores = carro.Element("cor").Value,
    Modelos = carro.Element("modelo").Value
  };

  //Realize um foreach em carros(Collections.Generic.IEnumerable)
  //e escreva usando um dos nomes que você criou para retorno em sua consulta
  foreach (var carro in carros)
  {
    Response.Write(carro.Cores);
  }

Bem simples hein!

Qualquer dúvida podem me escrever.

Espero que tenham gostado e em breve tem mais.

Recentemente participei de um processo de migração em minha empresa, onde criamos um COM+ para disparar processos de criação de pastas em um servidor SVN.

Irei abordar neste post como podemos executar comandos do SVN através do C# e em breve irei disponibilizar um tutorial de como criar um COM+ com permissões para executar esses processos.

Todos os processos são executados através da classe System.Diagnostics.Process.

Criando um repositório - Comando create

Usando a classe Process do ASP.NET nós podemos disparar qualquer processo do Windows (é claro que em alguns casos são necessárias permissões de administrador), para isto, basta informar o caminho do executável e se necessário passar os parâmentros do aplicativo a ser disparado.
Veja abaixo como é simples criar um repositório no SVN através do C#:

//Primeiro criamos um processo
Process processo = new Process();

//Definimos dois parâmetros:
//Primeiro: o caminho do arquivo executável
//Segundo: os parâmetros necessários para criação do repositório
processo.StartInfo = new ProcessStartInfo("C:/Arquivos de programas/VisualSVN Server/bin/svnadmin.exe", "create /Repositories/nome_do_repositorio");

//Iniciamos o processo
processo.Start();

//Esperamos o processo finalizar
processo.WaitForExit();

Veja que no segundo parâmetro o caminho do repositório está “/Repositories”, isso porque o servidor SVN está instalado no C:, caso você não consiga acessar por esse caminho, preencha o parâmetro com o caminho completo.

Criando pastas - Comando mkdir

Tão simples quanto criar repositórios, são as criações de pastas nos repositórios. Para criar pastas em um determiando repositório basta executar o seguinte código:

//Criamos um processo
Process processo = new Process();

//Definimos os parâmetros:
//Primeiro: o caminho do arquivo executável
//Segundo: os parâmetros necessários para criação da pasta, caso necessário passe o usuário e a senha
processo.StartInfo = new ProcessStartInfo("C:/Arquivos de programas/VisualSVN Server/bin/svn.exe", "mkdir -m[notepad] --username "usuario"--password "password" https://caminho_do_servidor:8443/svn/nome_do_repositorio/"+ nome_da_pasta);

//Inicia o processo
processo.Start();

//Esperamos o processo finalizar
processo.WaitForExit();

Alguns servidores necessitam que seja informado o usuário e senha para permitir a criação das pastas.

Mais comandos do SVN

Vocês ainda podem utilizar outros comandos do SVN como:

• Commit: Grava todas atualização feita em um repositório.
• Import: Importa uma determinada pasta para um repositório.
• Add: Adiciona um arquivo em um determinado repositório, mas não grava a alteração (necessita de um Commit após sua execução)
• Delete: Deleta o arquivo do repositório.

Qualquer dúvida estou a disposição.

Espero que tenham gostado. Em breve tem mais.

Bom, já estava na hora de finalizar esse post da utilização do MVC com LINQ To SQL.
Depois de mapearmos a tabela a ser utilizada no projeto, já podemos criar consultas, realizarmos inserções, alterações e exclusão de valores.

Listando as informações

Importe a namespace “Mvc.Models” (onde Mvc é o nome da namespace que estou utilizando).

Faça um foreach na classe “tb_cidade” em um ViewData. Escreva o nome da cidade atráves do “c.nome_cidade”.
Bom, esse código foi criado na página “Index.aspx” que é uma View, dentro da pasta Home. (View/Home/Index.aspx), preste atenção que Home é o nosso controle, então será nesse controle que iremos retornar os valores.

<%@ Page Language="C#" MasterPageFile="~/Views/Shared/Site.Master" AutoEventWireup="true" CodeBehind="Index.aspx.cs" Inherits="Mvc.Views.Home.Index" %>
<%@ Import Namespace="Mvc.Models" %>
<asp:Content ID="indexContent" ContentPlaceHolderID="MainContent" runat="server">
   <h2><%= Html.Encode(ViewData["Message"]) %></h2>
   <p>To learn more about ASP.NET MVC visit <a href="http://asp.net/mvc" title="ASP.NET MVC Website">http://asp.net/mvc</a>.</p>

   <ul>
     <% foreach (tb_cidade c in (IEnumerable)ViewData.Model)
     { %>
       <li><%= c.nome_cidade %></li>
     <% } %>
   </ul>
</asp:Content>

Bem simples né? Mas como essa informação foi preenchida neste ViewData?

Retornando os dados em um Controller

Devemos retornar os dados no Controller “HomeController.cs” que fica na pasta (Controllers/HomeController.cs).

Primeiro devemos importar a namespace “Mvc.Models”, depois devemos instanciar a classe LINQ To SQL criado anteriormente, neste caso o EstudoDataContext (Estudo.dbml).

Depois devemos montar nossa consulta LINQ.

IQueryable query = (from c in estudoDC.tb_cidades
select c);

Neste caso, estou retornando todos os dados da tabela “tb_cidades” em uma interface IQueryable.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Mvc.Ajax;
using Mvc.Models;

namespace Mvc.Controllers
{
  [HandleError]
  public class HomeController : Controller
  {
    public ActionResult Index()
    {
      EstudoDataContext estudoDC = new EstudoDataContext();
      IQueryable query = (from c in estudoDC.tb_cidades
                         select c);
      return View(query);
    }
  }
}

Agora sim, ficou fácil entender como conseguimos retornar esses dados para uma View.

Inserção, Alteração e Exclusão de informações

Veja abaixo os exemplos de insert, delete e update:

//Realizando um insert
tb_cidade cidade = new tb_cidade();
cidade.nome_cidade = "São Paulo";
estudoDC.tb_cidades.InsertOnSubmit(cidade);

//Realizando um delete
tb_cidade cidade = estudoDC.tb_cidades.Single(c => c.cidade_pk == 1);
estudoDC.tb_cidades.DeleteOnSubmit(cidade);

//Realizando um update
tb_cidade cidade = estudoDC.tb_cidades.Single(c => c.cidade_pk == 1);
cidade.nome_cidade = "Rio de Janeiro";

//Para qualquer uma das ações acima você deve comitar a alteração
//através do seguinte código
estudoDC.SubmitChanges();

Bem, caso vocês tenham alguma dúvida podem entrar em contato comigo, mas a idéia deste post foi como realmente implementar essas ações usando o MVC e LinqToSQL, e não explicar cada um das linhas detalhadamente.
Espero que tenham gostado. Em breve tem mais.

Essa é uma dica rápida para você que está usando Linq To SQL e não sabe onde testar suas “novas consultas”. O LinqPad é um aplicativo para executar consultas de:

- LINQ To SQL
- LINQ To Objects
- LINQ To XML

Este programa que não precisa ser instalado na sua máquina permite a execução de consultas e ainda vem com cerca de 300 exemplos para auxiliar no aprendizado do LINQ To SQL.

Além de ser uma excelente ferramenta o LINQPad é gratuito para download e uso, mas atenção, ele não é OpenSource.

Para rodar o LINQPad na sua máquina são necessários alguns itens:

• LINQPad requer .NET Framework 3.5 (Framework 3.5 já vem com Visual Studio 2008 ou Visual C# 2008 Express) .
• Um banco de dados. LINQPad suporta SQL Express, SQL 2000, SQL 2005, e (com algumas limitações) o SQL 2008.

Espero que tenham gostado desta dica. Em breve irei encerrar o post sobre Usando Linq To SQL e MVC.

Vou mostrar hoje como utilizar Linq To SQL juntamente com o MVC para .NET Framework.

Não irei abordar neste post detalhes do que é Linq To SQL, nem mesmo aspectos relativos ao MVC para .NET, pois, a internet está cheia dessas informações. O principal objetivo deste post é mostrar como realizar o mapeamento de uma tabela, listar as informações, inserir, alterar e excluir registros usando Linq To SQL.

Irei dividir o post em duas partes:

Parte I

• Criação do projeto;
• Criação da classe Linq to SQL;
• Mapeamento do banco;

Parte II

• Inserção de valores;
• Atualização;
• Exclusão;
• Listagem de informações

Criação do projeto

Bom, vamos começar criando um projeto, no meu caso irei criar um projeto MVC Web application, mas você pode ficar a vontade e criar o projeto que quiser, pois, o processo de utilização do Linq é o mesmo.

Criação da Classe Linq to SQL

Assim que criarmos o projeto, devemos criar uma classe do tipo Linq to SQL. Para isso, clique com o botão na pasta Models (criada automaticamento com o MVC Web Application, ou se for um projeto comum crie dentro do App Code), Add new item, clique no sub-item Data e escolha um objeto do tipo Linq to SQL Classes. Dê o nome do arquivo de Estudo.dbml.

Mapeamento da tabela do projeto

Assim que criarmos uma classe do tipo Linq to SQL Classes, devemos criar a conexão com banco de dados.

Use o Server Explorer para conectar a base de dados, assim que a conexão for estabelecida, abra o item tables e arraste a tabela que deseja mapear. Para mapear diferentes tabelas basta arrastá-las para o Estudo.dbml (LinqToSQL Classes)

No meu caso, eu mapeie uma tabela que possui a seguinte estrutura:

Nome da Tabela: tb_cidade
Campos: cidade_pk, nome_cidade.

Com isso encerramos a primeira parte. Aguarde pela Parte II em breve, onde iremos listar, inserir, alterar e excluir informações usando LinqToSQL.

Espero que tenham gostado.

Neste novo artigo da série C# para iniciantes, irei falar sobre Operadores. No C# temos os seguintes tipos de operadores:

• Atribuição;
• Aritméticos;
• Relacionais;
• Lógicos.

Operadores de Atribuição

Operadores de atribuição são utilizados para setar valores a determinadas váriaveis. No C# possuímos os seguintes operadores de atribuição.

= (Atribuição simples)
+= (Atribuição aditiva)
-= (Atribuição Subtrativa)
*= (Atribuição Multiplicativa)
/= (Atribuição de divisão)
%= (Atribuição de módulo)

Exemplos:

//Atribuição Simples
// Define-se um valor para a variavel i, neste caso 50
int i = 50;

//Atribuição de Adicição
//Este operador "+=" equivale a (i = i + x), portanto o valor de i será 100
int i = 50;
int x = 50;

i += x;

//Atribuição de Subtração
//Este operador "-=" equivale a (i = i - x), portanto o valor de i será 0
int i = 50;
int x = 50;

i -= x;

//Atribuição de Multiplicação
//Este operador "*=" equivale a (i = i * x), portanto o valor de i será 2500
int i = 50;
int x = 50;

i *= x;

//Atribuição de Divisão
//Este operador "/=" equivale a (i = i / x), portanto o valor de i será 1
int i = 50;
int x = 50;

i /= x;

//Atribuição de Módulo ou Resto
//Este operador "%=" equivale a (i = i % x) onde neste será retornado o resto da divisão, portanto o valor de i será 0
int i = 50;
int x = 50;

i %= x;

Operadores Aritméticos

Como o próprio nome sugere, esses operadores são utilizados para realizar cálculos aritméticos. No C# possuímos os seguintes operadores aritméticos:

+ (Adição)
- (Subtração)
* (Multiplicação)
/ (Divisão)
% (Módulo/Resto)

Exemplos:

//Adicição
//A váriavel i possui o valor 60
int i = 50 + 10;

//Subtração
//A váriavel i possui o valor 40
int i = 50 - 10;

//Multiplicação
//A váriavel i possui o valor 500
int i = 50 * 10;

//Divisão
//A váriavel i possui o valor 5
int i = 50 / 10;

//Módulo ou Resto
//A váriavel i possui o valor 0
int i = 50 % 10;

Operadores Relacionais

Os operadores relacionais são utilizados nas expressões relacionais, estas sempre retornam um valor booleano: Verdadeiro ou Falso. O C# possui os seguintes operadores relacionais:

== (Igualdade)
> (Maior)
< (Menor)
<= (Menor igual)
>= (Maior igual)
!= (Diferente)

Exemplos:

int i = 30;
int x = 20;

//Igualdade
//O resultado será Falso
i == x

//Maior
//O resultado será Verdadeiro
i > x

//Menor
//O resultado será Falso
i < x

//Maior ou igual
//O resultado será Verdadeiro
i >= x

//Menor ou igual
//O resultado será Falso
i <= x

//Diferente
//O resultado será Verdadeiro
i != x

Operadores Lógicos

Os operadores lógicos são utilizados para combinar diferentes comparações. Esses são os operadores lógicos do C#:

&& (E)
|| (OU)

Exemplos:

int i = 1;
int x = 3;

//Operador && (E)
//Utilizando o operador && (E), esta condição será Falso
bool resultado = i > x && x < 5;

//Operador || (OU)
//Utilizando o operador || (OU), esta condição será Verdadeiro
bool resultado = i > x || x < 5;

Ainda existem os operadores de Incremento (++) e Decremento (–), estes são responsáveis por adicionar/subtrair o valor 1, a uma determinada váriavel.
Espero que tenham gostado. Em breve tem mais.

Bom, pode até parecer estranho, mas eu nunca precisei enviar um e-mail com autenticação, isso até hoje.
Me deparei com este simples problema e acho interessante compartilhar com todos como pode ser feito o envio de e-mails em servidores de SMTP que requerem autenticação.
Utilizando a namespace System.Net.Mail ficou muito simples o envio com autenticação. Veja o exemplo abaixo:

//Crie o email
MailMessage mail = new MailMessage();

//Adicione os endereços de e-mail
mail.From = new MailAddress("teste@teste.com.br");
mail.To.Add("teste@teste.com.br");

//Adicione o conteúdo do e-mail
mail.Subject = "Este é o Assunto";
mail.Body = "Este será o corpo do e-mail.";

//Crie o STMP de acordo com suas configurações
SmtpClient smtp = new SmtpClient("localhost");

//Para autenticar, basta setar o usuário e a senha do servidor de SMTP
smtp.Credentials = new NetworkCredential("usuario", "senha");

//Envie o e-mail
smtp.Send(mail);

Bem simples hein! Espero que tenham gostado.
Em breve tem mais.

Continuando a série de post’s para guia de consulta rápida, iremos finalizar a série de estrutura de dados falando sobre estruturas de repetição.

Diferente das estruturas condicionais, onde um determinado código é executado apenas uma vez, as estruturas de repetição tem como objetivo executar um determinado bloco de código até que uma determinada condição seja alcançada.

Bom, existem 4 estruturas de repetição no C#, são elas:

Estrutura de Repetição

For

Toda estrutura For é constituída de uma variável de inicialização, uma condição e o incremento. No exemplo abaixo podemos observar a inicialização: int i = 0, a condição: i < 10 e o incremento i++, sendo o “;” separador desses atributos.
Exemplo:

for (int i = 0; i < 10; i++)
{
   ... código ...
}

While

A estrutura While é bem mais simples que o for, pois, nele não é necessário declarar uma variável de inicialização, nem mesmo o incremento, somente é necessário declarar a condição de parada da repetição. Mas lembre-se que apesar de você não precisar declarar o incremento, você tem que preocupar com a condição, pois, caso a condição não seja falso em algum momento, você irá criar um loop infinito.
Exemplo:

while(i < 10)
{
   ... código ...
}

Do … While

O Do … While é muito semelhante à estrutura While, tendo como principal diferença a inicialização da estrutura, pois no While existe a possibilidade do código não ser executado nenhum vez (lógico que isso será vinculado ao resultado da condição), já no Do … While o código escrito dentro da estrutura será executado pelo menos uma vez, isso porque a verificação é realizada apenas no final da estrutura.
Exemplo:

do
{
   ... código ...
}
while(i != 10);

Foreach

A estrutura Foreach é utilizada para percorrer coleções ou arrays. Sua estrutura é formada pelo tipo de dado: string (porque estamos percorrendo um array de strings), o nome da variável: marca e a lista a ser percorrida: carros.
Exemplo:

string[] carros = {"Mercedes", "Ferrari", "Gol", "Palio"};
foreach (string marca in carros)
{
   Console.WriteLine("{0} ", marca);
}

Bom, com isso fechamos a estrutura de dados no C#. Podemos é claro misturar estruturas condicionais e estruturas de repetições para criar algoritmos cada vez melhor.

Espero que tenham gostado. Até o próximo post.

Seguindo a idéia de post’s para guia de consulta rápida, irei falar um pouco da estrutura de dados do C#, mais especificamente Estruturas Condicionais.

A criação de algoritimos visá à manipulação de dados para obter algum tipo de informação. Quando estes dados estão organizados de forma coerente, caracterizam uma forma, ou seja, uma estrutura de dados.

Estruturas Condicionais

If Then Else

Exemplo:

if (condição)
{
  ...código...
}elseif(condicao){
  ...código...
}else{
  ...código...
}

No C# existe também o IF-Inline:

Exemplo:

/***
* If-inline é definido da seguinte forma:
* Se condição for VERDADEIRA, então
* retorna valor1, senão
* retorna valor2
***/

int NumeroPar = 2;
int NumeroImpar = 3;

int numero = (NumeroPar > NumeroImpar) ? NumeroPar : NumeroImpar;
int numero = (condicao) ? valor1 : valor2;

Switch/Case

Exemplo:

int Numero = 2;
switch(Numero){
	case 1:
		..código...
	        break;
        case 2:
                ..código...
                break;
        case 3:
                ..código...
                break;
        default:
                ..código...
                break;
}

Estas estruturas sempre são utilizadas quando necessitamos tomar algum fluxo, mediante a uma condição ou um valor pré-definido.

Mas quando utilizarmos cada uma delas? Sempre que nós soubermos os valores das condições devemos utilizar o Switch/Case, já quando necessitarmos realizar alguns testes lógicos ou testes aritiméticos onde o valor não é exatamente conhecido, devemos utilizar o If Then Else.

Na próxima iremos ver estrutura de repetição ou estrutura de loop. Espero que tenham gostado. Em breve tem mais.