Hoje tive a oportunidade de criar o meu primeiro Projeto a sério não Web-based. Trata-se de um processo que deverá correr sem nenhuma intervenção humana (salvo as opções como: “Iniciar”, “Pausar”, “Continuar” e “Parar”), justamente o que um Windows Service tem como finalidade.

Claro que o design ainda esta longe do ideal, mas so o fato de ver o mesmo correndo em background automaticamente achei muito interessante e curioso. Tive até a oportunidade de criar algo a mais, como por exemplo um projeto em WinForms onde vocè pode executar as funcionalidade básicas de um Windows Service, como já descrevi acima, inclusive colocando-o no SysTray e criando um Menu de Contexto para que o administrador tenha um acesso rápido ao serviço quando precisar dar algum tipo de manutenção.

Claro que pra muitos isso é até banal, mas fica aqui registrada a minha experiència nesta área e com certeza a minha satisfação. 😉

Não sou lá um especialista em COM+, mas leio sobre. Aliás, é algo que me tenta, ou seja, estou obsecado para fazer um projeto que utilize componentes no COM+ para trabalhar com Pool de Objetos, Transações, entre outras coisas que o mesmo nos oferece, mas até então não tive oportunidade para isto. 😥

Estou nas horas vagas lendo um livro de Juval Löwy chamado COM + e .NET onde é mostrado como criar e manter componentes .NET no COM+, e lendo sobre Pooling de Objeto COM+, algo que achei interessante foi dito, e gostaria de aqui expor:

O objeto é retornado para o pool quando o cliente libera a sua referencia a ele. Sendo assim, sabemos que objetos gerenciados utilizam a chamada “coleta de lixo” (Garbage Collector), e com isso, o objeto gerenciado só retorna ao pool quando este lixo é coletado.

Isso pode ser de certa forma prejudicial, pois poderá haver um retardo entre o momento em que este objeto não é mais necessário até o momento em que o mesmo retorna ao pool, pois lembre-se que o “coletor de lixo” tem um período/tempo para passar, pois ele não sai varrendo o nosso objeto assim que nós o descartamos. Agora o que de mais interessante achei: como já sabemos, um objeto é colocado em pool porque a sua criação é custosa e se este objeto gastar um tempo esperando que o “coletor de lixo” o recolha, então o aplicativo quase não se beneficia do pool de objetos.

Vi que existem duas maneiras de resolver este problema. A primeira é utilizando JITA e a segunda já requer a participação do cliente, pois como todo componente .NET que tira proveito dos serviços COM+ precisa derivar da classe base ServicedComponent que tem um método público estático chamado DisposeObject(), definido como:

public static void DisposeObject(ServicedComponent sc);

Assim que continuar os testes e a leitura por aqui, dou o feedback do uso do método DisposeObject() e sobre o JITA. 😉 Mas claro que se alguém quiser contribuir, fico/ficaremos grato 😉

Há dois dias tive a necessidade de exibir um relatório criado em Crystal Reports em uma Aplicação ASP.NET. Crei o RPT utilizando DataSet tipado como fonte de dados. Tirando a complexidade de fazer o relatório, me deparei em como exibir o tal na Web. Esta fora de cogitação utilizar o CrystalReportViewer, então a solução foi exportar o arquivo *.rpt para PDF.

Inicialmente pensei em utilizar o System.IO para criar o mesmo fisicamente utilizando o Session.SessionID como o nome do arquivo. Funcionou perfeitamente, porém o arquivo estava sendo criado fisicamente, que com isso, ia gerar um grande acúmulo de arquivos no servidor.

Falando com meu Amigo João, ele me sugeriu a criação de um Stream para esta exibição. Bem, não pensei duas vezes e fui logo criar. Com certeza fico bem melhor, pois o arquivo não é mais criado fisicamente, apenas é exibido seu conteúdo no browser. Eis o código em C# para realizar esta tarefa:

using CrystalDecisions.Shared;
using CrystalDecisions.ReportSource;
using CrystalDecisions.CrystalReports.Engine;
using System.IO;

MeuDataSetTipado DS = new MeuDataSetTipado();
MeuRelatorioRPT R1 = new MeuRelatorioRPT();
R1.SetDataSource(DS);

BinaryReader stream = new BinaryReader(R1.ExportToStream(CrystalDecisions.Shared.ExportFormatType.PortableDocFormat));
HttpContext.Current.Response.ClearContent();
HttpContext.Current.Response.ClearHeaders();
HttpContext.Current.Response.ContentType = “application/pdf”;
HttpContext.Current.Response.BinaryWrite(stream.ReadBytes(Convert.ToInt32(stream.BaseStream.Length)));
HttpContext.Current.Response.Flush();
HttpContext.Current.Response.Close();

Para quem gosta de Design Patterns como eu, encontrei um site que com certeza está em meus favoritos. Site qual foi adaptado para o Portugues o conteúdo do famoso doFactory. Para quem se interessar o site chama-se OODesign e sua URL: http://www.oodesign.com.br/patterns/

Não são todas as Patterns que estão publicadas (com exemplos, definições, etc.), mas as quais estão, são disponibilizados exemplos em C#, C++, Java e Delphi. Para as que ainda não foram, lá consta a data prevista para publicação. Vale a visita.

Muitas vezes criamos uma função em uma classe, disponibilizando-a para outros desenvolvedores/sistemas fazerem uso dela. Com o tempo, as regras de negócio mudam e é necessário a construção de uma nova função para que tais regras sejam atendidas.

Com isso não podemos sairmos mudando seus parametros ou sua implementação porque já existem sistemas que consomem estas funções. Como isso te obrigará a criar uma nova função (ou até mesmo sobrecarregar). Existe um Atributo dentro do .NET para dizermos ao desenvolvedor que for consumi-lá que existe uma nova versão da mesma, e podemos indicar o uso dela. Esse atributo chama-se <Obsolete()>

<Obsolete(“O Correto é utilizar a função Exibir”)> Public Function Buscar() As Integer
    ‘…
End Function

Com isso o compilador verificará e fará entradas do tipo Warning dentro da TaskList, mas o aplicativo continua rodando normalmente.

Quando criamos uma variável do tipo Integer e atribuímos à essa variável o resultado de uma variável Booleana, há algumas diferenças: o False virá 0 e o True vira -1.

Dim boo As Boolean = True
Dim x As Integer = boo

Response.Write(x.ToString)
Response.Write(boo.ToString)
Response.Write(Convert.ToInt32(boo))

A saída será:

-1
True
1

Com essas conversões, talvez nos “embaralhamos” um pouco nas condicionais, que muitas vezes nos retornam um valor que não é o esperado.

Encontrei um utilitário bastante interessante, qual lista as DLL’s que um programa carrega. Este utilitário chama-se ListDLLs, e pode ser encontrado em: http://www.sysinternals.com/ntw2k/freeware/listdlls.shtml

Por exemplo poderia escrever esta linha no prompt de comando: Listdlls.exe inetinfo.exe e ele mostrará todas as DLL’s carregadas para esse aplicativo.

Download: http://www.sysinternals.com/files/listdlls.exe