Bom, muitos devem conhecer esse arquivo, mas tenho que confessar que eu não sabia da existência dessa excelente funcionalidade do ASP.NET 2.0.

Criando um arquivo HTML com o nome de “app_offline.htm” e colocando esse arquivo na raiz de uma aplicação Web, irá forçar um redirect em toda requisição do IIS para esse arquivo. Bom, ai você deve perguntar qual a vantagem disto?

Imagine que você queira colocar um site em manutenção, onde ninguém em hipótese nenhuma poderá acessar qualquer página do site. Como fazer isso? Simples, coloque um arquivo chamado “app_offline.htm” que você não terá problemas.

Pensando um pouco mais pra frente, imagine que você tenha duas aplicações Web distintas (uma seria o Site a outra seria o Sistema Administrativo do site). Imagine agora que o Sistema Administrativo possui uma mensalidade e o “donos” do sistema não efetuaram o pagamento do mês. Colocando este arquivo na raiz do Sistema Administrativo você bloquea o acesso de qualquer usuário a esta área sem afetar o Site.

Bem simples e legal essa funcionalidade.

Espero que tenham gostado desta dica. Em breve tem mais.

Finalmente vamos encerrar o post: Criando um COM+ integrado com SVN: Parte I. Primeiro, desculpe a demora em finalizar este post, mas realmente não estava conseguindo um tempo para escrever.

No post Utilizando SVN com C# nós vimos a utilização da classe System.Diagnostics.Process para executar algumas ações do SVN.

Bom, juntando o útil ao agradável, o que nós precisamos fazer agora é criar alguns métodos no nosso COM+ para que ele possa executar determinadas ações do SVN.

Abaixo veja alguns exemplos que podem ser criados:

public bool CriaRepositorio(string CaminhoSVNServer, string CaminhoRepositorio, string repositorio)
{
	try
	{
		Process processo = new Process();
		processo.StartInfo = new ProcessStartInfo(CaminhoSVNServer + "svnadmin.exe", "create "+ CaminhoRepositorio + repositorio);

		processo.Start();
		processo.WaitForExit();

		return true;
	}
	catch (Exception ex)
	{
		EventLog.WriteEntry("SVN - Criação de Repositório", "Erro: " + ex.Message.ToString() +" || "+ ex.Source.ToString());
		return false;
	}
}

public bool CriaPasta(string SVNSever, string CaminhoSVNServer, string pasta, string usuario, string password)
{
	try
	{
		Process processo = new Process();
		processo.StartInfo = new ProcessStartInfo(CaminhoSVNServer+ "svn.exe", "mkdir -m[notepad] --username \""+ usuario +"\" --password \""+ password +"\" " + SVNSever + pasta);
		processo.Start();
		processo.WaitForExit();

		return true;
	}
	catch (Exception ex)
	{
		EventLog.WriteEntry("SVN Webroom - Criação de Pasta", "Erro: " + ex.Message.ToString() + " || " + ex.Source.ToString());
		return false;
	}
}

Agora vocês podem usar a imaginação e criar mais métodos. Assim que todos os métodos forem criados o que precisamos fazer é dar permissões ao COM+ para que o mesmo possa rodar no servidor, com permissões para executar os processos do SVN.

Passo 1

Registre novamente a DLL, para isso digite a seguinte linha de comando do Visual Studio.

//Linha de comando para registrar uma DLL:
//Digite o caminho até a DLL que será registrada
//regsvcs D:\Arquivos de programas\Complus\Complus\bin\Debug\nome_da_dll.dll

Passo 2

Uma vez registrado a DLL, devemos acessar o Painel de Controle -> Ferramentas Administrativas -> Componetes de Serviço. Você irá notar que existe um processo com o mesmo nome da DLL, pois é, este é seu COM+ rodando.

Passo 3

Feito isso, você deve agora setar as seguintes permissões no COM+.

Clique com o botão direito no Serviço criado e em seguida na guia de Segurança. Marque a primeira opção Autorização e em Nível de Segurança marque a segunda opção.

Agora vá na guia Ativação, em Tipo de Ativação marque Aplicativo de servidor e executar aplicativo como Serviço NT.

Clique em OK. Bom, após realizar todos esses passos o seu COM+ já deve estar funcionando. Caso vocês tenham algum problema podem me perguntar.

Espero que tenham gostado desta série.

Em breve tem mais.

Agora é oficial, saiu a versão final do ASP.NET MVC. Com pouco mais de 20 dias de atraso (estava sendo previsto o lançamento para o final de fevereiro) saiu a versão final do ASP.NET MVC e agora a MSDN possui a documentação. (veja a documentação aqui).

Você pode acompanhar tutorias liberados para Microsoft aqui ou também pode ver alguns exemplos que criei aqui no blog nas categorias MVC, Linq ou JQuery que é a biblioteca javascript oficial do MVC.

Pegue a versão do MVC 1.0 e aproveite este lançamento, que eu particularmente estou gostando.

Espero que vocês tenham gostado desta dica.

Vou mostrar em uma série de 2 posts como criar um COM+ para realizar ações do SVN. Há um tempo atrás precisei criar um COM+ que realiza-se as principais ações do SVN, como por exemplo: Criar pastas, repositórios, “commitar” (se é assim que posso falar) e deletar ações, além de outras funções.
Mas antes de começarmos a mexer com o código, vamos entender o que é o SVN.

O que é SVN e pra que serve um SVN

O SVN é um sistema de controle de versão e com esse controle nós podemos gravar o histórico de todos os arquivos. A idéia é simples, manter um controle de backup do seus arquivos, não utilizando o “Ctrl+C” e “Ctrl+V”.
O SVN mantém um versionamento do projeto, podendo garantir a recuperação de versões antigas do mesmo.
Imagine que você criou um projeto e gravou no SVN. Passado um mês você realizou diversas alterações neste projeto, pois o escopo do mesmo foi alterado (o que é normal na nossa área rsrs).
Ok, você acabou o projeto e gravou tudo no SVN. Vamos imaginar agora que se passaram alguns meses e você precise criar agora um projeto idêntico à aquela primeira versão gravada no SVN.
Pronto, ai entra o controle de versão. Basta você recuperar aquela versão e seu projeto já estará pronto.

Criando o COM+

Chega de teoria chata (mas importante) e vamos ao código. A primeira coisa a ser feita é a criação de um projeto com uma classe que neste caso chama: SVN
Adicione a biblioteca System.EnterpriseServices e a linha [Transaction(TransactionOption.Required), JustInTimeActivation()].

using System;
using System.EnterpriseServices;
using System.Configuration;

namespace Integracao
{
    [Transaction(TransactionOption.Required), JustInTimeActivation()]
    public class SVN : ServicedComponent
    {
    }
}

Agora será necessário criar uma chave e registrar a DLL como Service Component. Para isto, execute as seguintes linhas de comando usando os arquivos sn.exe e regsvcs.exe. Você pode executar no prompt de comando.

//Linha de comando para criar uma Chave:
//Digite o caminho da raiz do projeto e o nome da chave a ser criado
//sn -k "C:/Arquivos de programas/ComPlus/Complus/nome_da_chave.snk"

//Linha de comando para registrar uma DLL:
//Digite o caminho até a DLL que será registrada
//regsvcs D:\Arquivos de programas\Complus\Complus\bin\Debug\nome_da_dll.dll

Assim chegamos ao final do primeiro post. Já estamos com o COM+ praticamente pronto e agora só falta criar os métodos para acessarem as ações do SVN e dar as devidas permissões ao COM+, para que o mesmo funcione corretamente.
Em breve irei finalizar essa integração. Espero que tenham gostado.

No novo MVC você tem a capacidade de criar seus elementos HTML personalizados atráves da classe HTMLHelper.
O objetivo é que você possa criar uma estrutura na qual diminua a quantidade de HTML padrão que você irá escrever.
Vamos ver o exemplo abaixo:

Imagine que você queira criar um HTMLHelper que crie este HTML padrão.

<label for="usuario">Usuario:</labe>
<input type="text" id="usuario" value="" />

Para que tenhamos essa funcionalidade teremos que criar a seguinte classe.

namespace Controles {
public static class HtmlHelperBase
{
   public static string LabelTextbox(this HtmlHelper helper, string identificador, string label_texto, string tipo)
     {
          return String.Format("<label for='{0}'>{1}</label><input type='{2}' id='{3}' value='' />", identificador, label_texto, tipo, identificador);
     }
  }
}

Uma vez criada a classe, agora precisamos importar a namespace e utilizar o método criado em uma View. Veja o exemplo abaixo:

<%@ Page Language="C#" MasterPageFile="~/Views/Shared/Site.Master" AutoEventWireup="true" CodeBehind="Index.aspx.cs" Inherits="Mvc.Views.Home.Index" %>
<%@ Import Namespace="Controles" %>
  <asp:Content ID="indexContent" ContentPlaceHolderID="MainContent" runat="server">
<%= Html.LabelTextbox("usuario", "Aqui vem o texto", "text") %>

</asp:Content>

Bem simples e muito útil esse “poder” de personalização que temos.
Espero que tenham gostado. Em breve tem mais.

Esse assunto pode até parecer muito simples, mas é de extrema importância no desenvolvimento de sistemas, sejam eles simples ou complexos, na verdade em sistemas complexos os comentários são fundamentais.

No C# possuímos 2 tipos de comentários:

Em linha - usando duas barras: //

Este tipo de comentário é utilizado quando necessitamos comentar apenas uma linha de código.

Exemplo:

//Aqui vem um comentário de uma linha
string a = "teste";

Bloco - usando barra asterico para iniciar /* e asterisco barra para fechar */

Este tipo de comentário serve para comentar um bloco de código.

Exemplo:

/*
* Aqui vem um comentário de bloco
* com mais texto descritivo
*/
string a = "teste";

Bom, pode até parecer inútil, mas na verdade comentários são extremamente importantes em um detalhamento do sistema, pois, nem sempre será você que irá dar manutenção no sistema.

É importante comentar os pontos chaves criados por você, para que outros programadores possam enteder o que quer dizer aquele trecho de código.

Espero que tenham gostado.

Em breve tem mais.

Continuando a série C# para iniciantes, irei mostrar neste post como é simples criar e escrever em arquivo txt usando C#.

Primeiro devemos escolher onde iremos criar o arquivo

string nome_arquivo = "C:/Teste/arquivo.txt";

Depois devemos verificamos se o arquivo existe, se não existir então criamos o arquivo

if (!System.IO.File.Exists(nome_arquivo))
  System.IO.File.Create(nome_arquivo).Close();

Agora usamos a classe TextWriter para escrever no arquivo

System.IO.TextWriter arquivo = System.IO.File.AppendText(nome_arquivo);
arquivo.WriteLine("Escrendo no arquivo");

Fechamos o arquivo

arquivo.Close();

Bem, simples né. Espero que tenham gostado.
Em breve tem mais.

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.