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.

Dando sequência a série de post’s sobre POO iremos abordar agora sobre conceitos essenciais da POO e para falar sobre esse assunto irei dividi-lo nas seguintes partes:

• Objeto;
• Herança;
• Encapsulamento;
• Polimorfismo;
• Classes;
• Relacionamentos;
  • Agregação;
  • Generalização;
  • Associações N(Árias)
  • Abstração

Neste post iremos detalhar os seguintes itens: Classe e Objeto, já no próximo post serão descritos os itens: Herança, Encapsulamento e Polimorfismo e os demais itens em sequência.

No post Programação Orientada a Objeto - O início nós já percebemos que a POO, veio para auxiliar a solução de problemas, através da modelagem do problema no meio computacional. Essa modelagem é feita através de objetos.

Nosso mundo é composto por objetos e cabe a nós desenvolvedores entendermos quais são os objetos necessários na resolução de um determinado problema.

Bom, mas como definimos um objeto? Basta dizer que um objeto é do tipo de uma determinada classe.

Antes que isso fique complicado, vamos tentar explicar de uma forma mais simples a idéia básica do assunto.

Primeiro definimos quais são as classes do nosso sistema (Ex: Carro, Pessoa, Movimento). Assim que as classes forem definidas podemos utilizar os itens herança e polimorfismo para conseguirmos um melhor mapeamento dessas classes. A partir do momento em que você utiliza classes para criar uma instância da mesma (Ex: Carro meuCarro = new Carro() - a sintaxe não é a mesma para qualquer linguagem de programação), então você tem um objeto de um determinado tipo, neste caso um objeto do tipo Carro.

Vamos agora detalhar um pouco mais cada um desses itens.

Classe

No mundo atual existem carros e cada carro possui uma particularidade, mas todos possuem a mesma estrutura e comportamento. A definição de um modelo que descreve essa estrutura e esses comportamentos é nomeado como uma Classe.

Por exemplo, a classe Carro possui a estrutura com: cor, altura, comprimento. Os comportamentos que um carro pode ter são: andar(), virarDireita(), virarEsquerda(), parar().

Objeto

Uma vez definida a classe do tipo Carro, fica mais fácil criar objetos que utilizem desta mesma estrutura. Basta instanciar N objetos do tipo Carro que teremos, carros diferentes, porém, com estrutura e comportamento iguais.

O objeto é alguma coisa com limites bem definidos e significados bem claros dentro de uma aplicação, ou seja, é a instancia de alguma classe.

Grady Booch colocou uma definição para objeto: “Um objeto possui um Estado, Comportamento e uma Identidade”.

Entendendo esses 3 pontos:

1. Identidade: Todo objeto possui uma identidade. Por exemplo, um novo objeto - Carro meuCarro = new Carro() - é um objeto com a identidade meuCarro;
2. Estado: O estado são as estruturas de um objeto. Por exemplo, o objeto meuCarro possui o atributo cor. Quando definimos um valor para esse atributo, nós definimos isso como estado. meuCarro.cor = Azul;
3. Comportamento: Acima, nós também vimos os comportamentos de um objeto (andar, virarDireita). Quando nós chamamos esses ‘métodos’ de um objeto, ele realiza a ação que lhe foi solicitada. meuCarro.virarDireita();

Fechamos assim a descrição desses 2 pontos que são de muita importância na POO. É claro que estes conceitos são bem básicos, até mesmo porque esse assunto é bastante complexo.

Em breve estarei falando um pouco de Herança, Polimorfismo e Encapsulamento.

Até o próximo post.

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.

Toda linguagem de programação possui seus tipos de dados primitivos, incluindo o C#. No Java existem somente 8 tipos de dados primitivos : Boolean , Char , byte , short , int , long , float , double.

Mas o que são os tipos de dados primitivos? Tipos de dados primitivos são os dados suportados diretamente pelo compilador. Esses dados possuem palavras chaves para facilitar sua utilização durante a implementação de um sistema.

Por exemplo, a palavra chave string mapeia diretamente o tipo System.String e o bom conhecimento destes tipos auxilia no desenvolvimento e pode impactar no desempenho de seu sistema.

Segue abaixo um tabela com as palavras chaves, tipos associados a cada uma delas e a faixa de valores que cada tipo aceita.

Bom, este post segue como um guia de consulta rápido e irei montar mais post nestes formatos em breve.

Espero que tenham gostado e aguardem por mais.